国产亚洲免费的视频看,欧美激情综合色,欧美在线播放视频

bujiwu — Sun, 26 Oct 2008 14:21:00 GMT

1�?堆排序定�?
n个关键字序列Kl�Q�K2�Q?#8230;�Q�Kn�U�Cؓ堆，当且仅当该序列满��_��下性质(��U�Cؓ堆性质)�Q?
(1) ki≤K2i且ki≤K2i+1 �?2)Ki≥K2i且ki≥K2i+1(1≤i≤ )

若将此序列所存储的向量R[1..n]看做是一��完全二叉树的存储结构，则堆实质上是满��如下性质的完全二叉树�Q�树中�Q一非叶�l�点的关键字均不大于(或不��于)其左叛_��?若存�?�l�点的关键字�?
【例】关键字序列(10�Q?5�Q?6�Q?5�Q?0�Q?0)�?70�Q?6�Q?0�Q?5�Q?5�Q?0)分别满��堆性质(1)�?2)�Q�故它们均是堆，其对应的完全二叉树分别如��根堆示例和大根堆示例所�C��?
2、大根堆和小根堆
根结�?亦称为堆��?的关键字是堆里所有结点关键字中最��者的堆称为小根堆�?
根结�?亦称为堆��?的关键字是堆里所有结点关键字中最大者，�U�Cؓ大根堆�?
注意�Q?
①堆中�Q一子树亦是堆�?
②以上讨论的堆实际上是二叉堆(Binary Heap)�Q�类似地可定义k叉堆�?
3、堆排序特点
堆排�?HeapSort)是一树�Ş选择排序�?
堆排序的特点是：在排序过�E�中�Q�将R[l..n]看成是一��完全二叉树的顺序存储结构，利用完全二叉树中双亲�l�点和孩子结点之间的内在关系【参见二叉树的顺序存储结构】，在当前无序区中选择关键字最�?或最��?的记录�?
4、堆排序与直接插入排序的区别
直接选择排序中，��Z��从R[1..n]中选出关键字最��的记录�Q�必��进行n-1�ơ比较，然后在R[2..n]中选出关键字最��的记录�Q�又需要做n-2�ơ比较。事实上�Q�后面的n-2�ơ比较中�Q�有许多比较可能在前面的n-1�ơ比较中已经做过�Q�但�׃��前一��排序时未保留这些比较结果，所以后一��排序时又重复执�? 了这些比较操作�?
堆排序可通过树�Ş�l�构保存部分比较�l�果�Q�可减少比较�ơ数�?
5、堆排序
堆排序利用了大根�?或小根堆)堆顶记录的关键字最�?或最��?�q�一特征�Q��得在当前无序��Z��选取最�?或最��?关键字的记录变得��单�?br>

1 /*
2 堆排�?br> 3 (1)用大根堆排序的基本思想
4 �?nbsp;先将初始文�gR[1..n]建成一个大根堆�Q�此堆�ؓ初始的无序区
5 �?nbsp;再将关键字最大的记录R[1](卛_��?和无序区的最后一个记录R[n]交换�Q?br> 6 由此得到新的无序区R[1..n-1]和有序区R[n]�Q�且满��R[1..n-1].keys≤R[n].key
7 �?nbsp;�׃��交换后新的根R[1]可能�q�反堆性质�Q�故应将当前无序区R[1..n-1]调整为堆�?br> 8 然后再次��R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换�Q?br> 9 由此得到新的无序区R[1..n-2]和有序区R[n-1..n]�Q�且仍满��_��p�R[1..n- 2].keys≤R[n-1..n].keys�Q?br>10 同样要将R[1..n-2]调整为堆�?br>11 ……
12 直到无序区只有一个元素�ؓ止�?br>13 (2)大根堆排序算法的基本操作�Q?br>14 �?nbsp;初始化操作：��R[1..n]构造�ؓ初始堆；
15 �?nbsp;每一��排序的基本操作�Q�将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后��新的无序区调整为堆(亦称重徏�?�?br>16 注意�Q?br>17 ①只需做n-1��排序，选出较大的n-1个关键字卛_��以��得文仉��增有序�?br>18 ②用��根堆排序与利用大根堆类��|��只不�q�其排序�l�果是递减有序的�?br>19 堆排序和直接选择排序相反�Q�在��M��时刻�Q�堆排序中无序区��L��在有序区之前�Q?br>20 且有序区是在原向量的��N��由后往前逐步扩大��x��个向量�ؓ止�?nbsp;
21 */
22
23 //生成大根�?/span>
24 void HeapAdjust(int SortData[],int StartIndex, int Length)
25 {
26     while(2*StartIndex+1 < Length)
27     {
28         int MinChildrenIndex = 2*StartIndex+1 ;
29         if(2*StartIndex+2 < Length )
30         {
31             //比较左子树和叛_��树，记录最大值的Index
32             if(SortData[2*StartIndex+1]<SortData[2*StartIndex+2])
33             {
34                 MinChildrenIndex = 2*StartIndex+2;
35             }
36         }
37         if(SortData[StartIndex] < SortData[MinChildrenIndex])
38         {
39             //交换i与MinChildrenIndex的数�?/span>
40             int tmpData =SortData[StartIndex];
41             SortData[StartIndex] =SortData[MinChildrenIndex];
42             SortData[MinChildrenIndex] =tmpData;
43             //堆被破坏�Q�需要重新调�?/span>
44             StartIndex = MinChildrenIndex ;
45         }
46         else
47         {
48             //比较左右孩子均大则堆未破坏，不再需要调�?/span>
49             break;
50         }
51     }
52
53     return;
54 }
55
56 //堆排�?/span>
57 void HeapSortData(int SortData[], int Length)
58 {
59     int i=0;
60
61     //��Hr[0,Lenght-1]建成大根�?/span>
62     for (i=Length/2-1; i>=0; i--)
63     {
64         HeapAdjust(SortData, i, Length);
65     }
66
67     for (i=Length-1; i>0; i--)
68     {
69         //与最后一个记录交�?/span>
70         int tmpData =SortData[0];
71         SortData[0] =SortData[i];
72         SortData[i] =tmpData;
73         //��H.r[0..i]重新调整为大根堆
74         HeapAdjust(SortData, 0, i);
75     }
76
77     return;
78 }

CODE:http://www.shnenglu.com/Files/bujiwu/HeapSort.rar
参考文章：
http://www.cnblogs.com/xiaotao823/articles/1055399.html
http://zhidao.baidu.com/question/1003067.html

bujiwu 2008-10-26 22:21 发表评论

几种内部排序��法�ȝ��!(冒��排序、快速排序、直接插入排序、拆半插入排序、简单选择排序)

bujiwu — Sat, 25 Oct 2008 15:53:00 GMT

  1 #include <iostream>
  2 using namespace std;
  3
  4 /*/////////////////////////////////////////////////////////////////////////
  5 以下为快速排�?br>  6 /////////////////////////////////////////////////////////////////////////*/
  7 /*
  8 冒��排序
  9 ��法�Q?br> 10 核心思想是扫描数据清单，��L��出现乱序的两个相�ȝ��目。当扑ֈ��q�两个项目后
11 交换��目的位�|�然后��l�扫描。重复上面的操作直到所有的��目都按��序排好
12 旉��复杂度n*n  (n-1)*n/2
13 */
14 void BubbleSortData(int SortData[], int Length)
15 {
16     int tmpData =0;
17     bool swapFlag =true;
18
19     for (int i=Length-1; i>0 && swapFlag; i--)
20     {
21         swapFlag =false;
22         for(int j=0; j<i; j++)
23         {
24             if ( SortData[j] > SortData[j+1])
25             {
26                 tmpData =SortData[j];
27                 SortData[j] =SortData[j+1];
28                 SortData[j+1] =tmpData;
29                 swapFlag =true;
30             }
31         }
32     }
33
34     return;
35 }
36 /*
37 快速排序是对�v泡排序的一�U�改�q�，通过一��排序将待排序记录分割成独立的两部分�Q�其中一部分记录的关键字均比另一部分记录的关�?br> 38 字小�Q�则可分别对�q�两部分�l�箋�q�行排序�Q�以辑ֈ�整个序列有序.
39 交换��序表L中子表L.r[low..high]的记录，使枢轴记录到位，�q�返回其所在位�|�，此时在它之前(�?的记录均不大(��?于它
40 旉��复杂度�ؓ n*logn,其��^均性能最好，若初始记录序列按关键字有序或基本有序�Q�快速排序将锐化��v泡排�?br> 41 */
42 int  Partition(int SortData[], int low, int high)
43 {
44     int tmpData =SortData[low];//用于子表的第一个记录作枢��u记录
45     int temp=0;
46
47     while ( low<high )
48     {
49         //从表的两端交替的向中间扫�?/span>
50         while (low<high && SortData[high]>=tmpData)
51         {
52             high--;
53         }
54         //��比枢��u记录��的记录�U�d��低端
55         SortData[low] =SortData[high];
56
57         while (low<high && SortData[low]<=tmpData)
58         {
59             low++;
60         }
61         //��比枢��u记录大的记录�U�d��高端
62         SortData[high] =SortData[low];
63     }
64     //枢��u记录��C��
65     SortData[low] =tmpData;
66
67     return low;//�q�回枢��u所在位�|?/span>
68 }
69
70 void QuickSortData(int SortData[], int low, int high)
71 {
72     int offset;
73
74     if ( low<high )
75     {
76         offset =Partition(SortData, low, high);
77         QuickSortData(SortData, low, offset-1);
78         QuickSortData(SortData, offset+1, high);
79     }
80 }
81
82 /*/////////////////////////////////////////////////////////////////////////
83 以下为插入排�?br> 84 /////////////////////////////////////////////////////////////////////////*/
85 /*
86 直接插入排序
87 ��法�Q�经�q�i-1遍处理后�Q�L[1..i-1]己排好序。第i遍处理仅��L[i]插入L[1..i-1]的适当位置�Q?br> 88 使得L[1..i]又是排好序的序列。要辑ֈ��q�个目的�Q�我们可以用��序比较的方法�?br> 89 首先比较L[i]和L[i-1]�Q�如果L[i-1]<=L[i]�Q�则L[1..i]已排好序�Q�第i遍处理就�l�束�?
90 否则交换L[i]与L[i-1]的位�|�，�l�箋比较L[i-1]和L[i-2]�Q�直到找到某一个位�|�j(1≤j≤i-1)�Q?br> 91 使得L[j] ≤L[j+1]时�ؓ�?br> 92 优点:�U�d��元素�ơ数��，只需要一个辅助空�?br> 93 旉��复杂度n*n
94 当待排序记录的数量n很小�Ӟ��q�是一�U�很好的排序�Ҏ��。但是n很大�Ӟ��则不适合
95 */
96 void InsertSortData(int SortData[], int Length)
97 {
98     int tmpData =0;
99     int i=0;
100     int j=0;
101
102     for(i=1; i<Length; i++)
103     {
104         if ( SortData[i] <SortData[i-1])
105         {
106             tmpData =SortData[i];
107             //数据往后移�?/span>
108             for (j=i-1; j>=0 && tmpData<SortData[j]; j--)
109             {
110                 SortData[j+1] =SortData[j];
111             }
112             //��数据插入到j+1位置
113             SortData[j+1] =tmpData;
114         }
115     }
116
117     return;
118 }
119
120 /*
121 拆半插入排序所需要的辅助�I�间和直接插入排序相同，从时间上比较�Q�折半插入排序仅减少了关键字间的比较�ơ数�Q�而记录的�U�d��ơ数不变�?br>122 因�ؓ旉��复杂度仍为n*n
123 */
124 void BInsertSortData(int SortData[], int Length)
125 {
126     int tmpData =0;
127     int i=0;
128     int j=0;
129     int low;
130     int high;
131     int middle;
132
133     for(i=1; i<Length; i++)
134     {
135         tmpData =SortData[i];
136         low =0;
137         high =i-1;
138         //在r[low..high]中折半查找有序插入的位置
139         while ( low<=high )
140         {
141             middle =(low+high)/2;
142             if ( tmpData <SortData[middle] )
143             {
144                 high =middle-1;
145             }
146             else
147             {
148                 low =middle+1;
149             }
150         }
151         //记录后移
152         for (j=i-1; j>=high+1; j--)
153         {
154             SortData[j+1] =SortData[j];
155         }
156         SortData[high+1] =tmpData;
157     }
158
159     return;
160 }
161
162
163 //////////////////////////////////////////////////////////////////////////
164
165 /*
166 ��单选择排序
167 ��法�Q�首先找到数据清单中的最��的数据�Q�然后将�q�个数据同第一个数据交换位�|�；接下来找�W�二��的数据�Q�再��其同第二个数据交换位置�Q�以此类推�?br>168 所需�U�d��的操作次数最��ؓ0,,最大�ؓ3(n-1)
169 然而无��录的初始排列如何�Q�需要比较的�ơ数相同n(n-1)/2 复杂度�ؓn*n
170 */
171 void SelectSortData(int SortData[], int Length)
172 {
173     int tmpData;
174     int offset =0;
175     int j=0;
176
177     for (int i=0; i<Length-1; i++)
178     {
179         offset =0;
180         tmpData =SortData[i];
181         for (j=i+1; j<Length; j++)
182         {
183             if ( tmpData>SortData[j] )
184             {
185                 tmpData =SortData[j];
186                 offset =j;
187             }
188         }
189
190         if( offset >i)
191         {
192             SortData[offset] =SortData[i];
193             SortData[i] =tmpData;
194         }
195     }
196
197     return;
198 }
199
200 int main()
201 {
202     //int Buffer[] ={1,2,3,4,5,6};
203     int Buffer[] ={6,5,4,3,2,1};
204
205     QuickSortData(Buffer,0, 5);
206
207     for (int i=0; i<6; i++)
208     {
209         cout<<Buffer[i]<<" ";
210     }
211     cout<<endl;
212
213     return 0;
214 }
215 http://www.shnenglu.com/Files/bujiwu/SortData.rar

bujiwu 2008-10-25 23:53 发表评论

国产亚洲免费的视频看,欧美激情综合色,欧美在线播放视频

几种内部排序���法�ȝ��!(冒��排序、快速排序、直接插入排序、拆半插入排序、简单选择排序)

几种内部排序��法�ȝ��!(冒��排序、快速排序、直接插入排序、拆半插入排序、简单选择排序)