最大堆、最小堆、堆排序

最（大）小堆的性质：

（1）是一颗完全二叉树，遵循完全二叉树的所有性质。

（2）父节点的键值（大于）小于等于子节点的键值

（3）在堆排序中我们通常用的是最大堆，最小堆通常用在优先队列中（尚未找到恰当的例子）。

堆排序：

数组：a[10]={16,14,10,8,7,9,3,2,4,1}可以利用建堆的方式对其进行排序。因为堆是一颗完全二叉树，根据完全二叉树的性质可以得知：对数组进行建堆之后，给定任意下标节点其父节点下标PARENT（i）=i/2      (取下整数)。左孩子下标为LEFT（i）=2*i 。右孩子下标为RIGHT（i）=2*i+1.如下图所示

堆排序代码见如下：

[cpp] view plain copy

1. #include<iostream>  
2. using namespace std;  
3. //获取父节点  
4. int Parent(int i)  
5. {  
6.     return i/2;  
7. }  
8. //获取左孩子  
9. int Left(int i)  
10. {  
11.     return 2*i;  
12. }  
13. //获取右孩子  
14. int Right(int i)  
15. {  
16.     return 2*i+1;  
17. }  
18. //从i节点开始生成最大堆  
19. void MaxHeap(int *a,int i,int length)  
20. {  
21.     int L,R;  
22.     L=Left(i);  
23.     R=Right(i);  
24.     int largest;  
25.     if(L<=length&&a[L-1]>a[i-1])  
26.     {  
27.         largest=L;  
28.     }  
29.     else  
30.         largest=i;  
31.     if(R<=length&&a[R-1]>a[largest-1])  
32.     {  
33.         largest=R;  
34.     }  
35.     if(largest!=i)  
36.     {  
37.         int temp;  
38.         temp=a[i-1];  
39.         a[i-1]=a[largest-1];  
40.         a[largest-1]=temp;  
41.         MaxHeap(a,largest,length);  
42.     }  
43. }  
44. //将整个树生成最大堆  
45. void Build_Max_Heap(int *a,int length)  
46. {  
47.     //从length/2开始是因为length/2节点以下的都是叶子节点  
48.     for(int i=length/2;i>=1;i--)  
49.     {  
50.         MaxHeap(a,i,length);  
51.     }  
52. }  
53. //堆排序  
54. void HeapSort(int *a,int length)  
55. {  
56.     Build_Max_Heap(a,length);  
57.     int number=length;  
58.     for(int i=length;i>0;i--)  
59.     {  
60.         int temp;  
61.         temp=a[i-1];  
62.         a[i-1]=a[0];  
63.         a[0]=temp;  
64.         length-=1;  
65.         MaxHeap(a,1,length);  
66.     }  
67. }  
68. int main()  
69. {  
70.     int a[10]={4,1,3,2,16,9,10,14,8,7};  
71.     HeapSort(a,10);  
72.     for(int i=0;i<10;i++)  
73.     {  
74.         cout<<a[i]<<" ";  
75.     }  
76.     cout<<endl;  
77. }  

 利用最小堆对数组进行排序的实现代码如下：

[cpp] view plain copy

1. #include<iostream>  
2. using namespace std;  
3. template<typename Type>class MinHeap  
4. {  
5. private:  
6.     Type *heap;  
7.     static const int defaultsize=1000;  
8.     int MaxSize;  
9.     int currentsize;  
10. public:  
11.     MinHeap<Type>(int size)  
12.     {  
13.         currentsize=0;  
14.         Maxsize=defaultsize>size?size:defaultsize;  
15.     }  
16.     MinHeap<Type>(Type a[],int n);  
17.     bool Insert(Type n);  
18.     bool IsFull()  
19.     {  
20.         return currentsize==MaxSize;  
21.     }  
22.     bool IsEmpty()  
23.     {  
24.         return currentsize==0;  
25.     }  
26.     bool Delete(Type n);  
27.     void Adjust(int start,int n);  
28.     void Print();  
29.     void Sorte();  
30. };  
31. template<typename Type> MinHeap<Type>::MinHeap(Type a[], int n)  
32. {  
33.       
34.     MaxSize=defaultsize>n?n:defaultsize;  
35.     currentsize=MaxSize;  
36.     heap=new Type[MaxSize];  
37.     for(int i=0;i<MaxSize;i++)  
38.     {  
39.         heap[i]=a[i];  
40.     }  
41.     int temp=(MaxSize-2)/2;  
42.     for(int i=temp;i>=0;i--)  
43.     {  
44.         Adjust(i,currentsize);  
45.     }  
46. }  
47. template<typename Type>bool MinHeap<Type>::Insert(Type n)  
48. {  
49.     if(currentsize==MaxSize)  
50.     {  
51.         cout<<"the heap is full!"<<endl;  
52.     }  
53.     heap[currentsize]=n;  
54.     int j=currentsize;  
55.     while(j>0)  
56.     {  
57.         int P=j/2-1;  
58.         if(heap[P]<heap[j])  
59.             break;  
60.         int temp;  
61.         temp=heap[P];  
62.         heap[P]=heap[currentsize];  
63.         heap[currentsize]=temp;  
64.         j=P;  
65.     }  
66.     currentsize++;  
67.     return 1;  
68. }  
69. template<typename Type>bool MinHeap<Type>::Delete(Type n)  
70. {  
71.     if(currentsize==0)  
72.     {  
73.         cout<<"this heap is empty!"<<endl;  
74.     }  
75.     bool flag=0;  
76.     for(int i=0;i<currentsize;i++)  
77.     {  
78.         if(heap[i]==n)  
79.         {  
80.             flag=1;  
81.             heap[i]=heap[currentsize-1];  
82.             Adjust(i,currentsize-2);  
83.             currentsize--;  
84.             i=0;  
85.         }  
86.         if(i==currentsize-1&&flag==0)  
87.         {  
88.             cout<<"there is no this element!"<<endl;  
89.         }  
90.     }  
91.     return 1;  
92. }  
93. template<typename Type>void MinHeap<Type>::Print()  
94. {  
95.     for(int i=0;i<currentsize;i++)  
96.     {  
97.         cout<<heap[i]<<"   ";  
98.     }  
99.     cout<<endl;  
100. }  
101. template<typename Type>void MinHeap<Type>::Adjust(int start, int n)  
102. {  
103.     int L,R,min;  
104.     L=start*2+1;  
105.     R=L+1;  
106.       
107.     if(heap[start]>heap[L]&&L<n)  
108.     {  
109.         min=L;  
110.     }  
111.     else  
112.         min=start;  
113.     if(heap[min]>heap[R]&&R<n)  
114.     {  
115.         min=R;  
116.     }  
117.     if(start!=min)  
118.     {  
119.         int temp;  
120.         temp=heap[start];  
121.         heap[start]=heap[min];  
122.         heap[min]=temp;  
123.         Adjust(min,n);  
124.     }  
125. }  
126. template<typename Type>void MinHeap<Type>::Sorte()  
127. {  
128.     int num=currentsize;  
129.     for(int i=currentsize-1;i>0;i--)  
130.     {  
131.         int temp;  
132.         temp=heap[i];  
133.         heap[i]=heap[0];  
134.         heap[0]=temp;  
135.         num-=1;  
136.         Adjust(0,num);  
137.     }  
138. }  
139. int main()  
140. {  
141.     int init[30]={17,6,22,29,14,0,21,13,27,18,2,28,8  
142.         ,26,3,12,20,4,9,23,15,1,11,5,19,24,16,7,10,25};  
143.     MinHeap<int> heape(init,30);  
144.     heape.Print();  
145.     cout<<endl<<endl<<endl;  
146.   
147.     heape.Insert(20);  
148.     heape.Print();  
149.     cout<<endl<<endl<<endl;  
150.   
151.     heape.Delete(20);  
152.     heape.Sorte();  
153.     heape.Print();  
154.     cout<<endl<<endl<<endl;  
155.   
156.     return 0;  
157. }