堆排序

堆排序（heapsort）是一种比较快速的排序方式，它的时间复杂度为O(nlgn)，并且堆排序具有空间原址性，任何时候只需要有限的空间来存储临时数据。我将用c++实现一个堆来简单分析一下。

堆排序的基本思想为：

1、升序排列，保持大堆；降序排列，保持小堆；

2、建立堆之后，将堆顶数据与堆中最后一个数据交换，堆大小减一，然后向下调整；直到堆中只剩下一个有效值；

下面我将简单分析一下：

第一步建立堆：

1、我用vector顺序表表示数组；

2、用仿函数实现大小堆随时切换，实现代码复用；

3、实现向下调整算法，时间复杂度为O（lgn）；

下面是我用某教材中的一个建最小堆的过程图，希望能更直观一些：

为了保证复用性，用仿函数重载了(),下面是复用的向下调整算法：

[cpp]  view plain  copy

 

1. void _AdjustDown(int root,int size)  
2. {  
3.     Camper camper;       //仿函数  
4.     int parent = root;  
5.     int child = parent * 2 + 1;  
6.     while (child <= size)  //保证访问不越界  
7.     {  
8.         if (child < size && camper(_vec[child+1] , _vec[child])) //保证存在右子树、同时判断右子树是否大于或小于左子树  
9.         {  
10.             child++;  
11.         }  
12.         if (camper(_vec[child], _vec[parent]))  
13.         {  
14.             swap(_vec[parent], _vec[child]);  
15.             parent = child;  
16.             child = parent * 2 + 1;  
17.         }  
18.         else  
19.         {  
20.             break;  
21.         }  
22.     }  
23.   
24. }  

排序算法思想：

1、将堆顶数据与堆中最后一个数据交换；

2、堆大小减一，然后调用向下调整算法；

3、结束条件：堆中剩下一个有效值；

排序算法实现：

[cpp]  view plain  copy

 

1. void Sort()  
2. {  
3.     size_t size = _vec.size();  //数据数量  
4.     while (size > 1)     
5.     {  
6.         swap(_vec[0], _vec[size - 1]);  
7.         size--;  
8.         _AdjustDown(size);  
9.     }  
10. }  

仿函数的实现：

[cpp]  view plain  copy

 

1. template<class T>  
2. struct Greater  //大于  
3. {  
4.     bool operator ()(const T& l, const T& p)  
5.     {  
6.         return l > p;  
7.     }  
8. };  
9.   
10. template<class T>  
11. struct Less  //小于  
12. {  
13.     bool operator () (const T&l, const T& p)  
14.     {  
15.         return l < p;  
16.     }  
17. };  

完整的代码实现：

[cpp]  view plain  copy

 

1. #include<iostream>  
2. using namespace std;  
3.   
4. #include<vector>  
5.   
6.   
7. template<class T>  
8. struct Greater  //大于  
9. {  
10.     bool operator ()(const T& l, const T& p)  
11.     {  
12.         return l > p;  
13.     }  
14. };  
15.   
16. template<class T>  
17. struct Less  //小于  
18. {  
19.     bool operator () (const T&l, const T& p)  
20.     {  
21.         return l < p;  
22.     }  
23. };  
24.   
25. template<class T,class Camper>  
26. class HeapSort  //建大堆  
27. {  
28. public:  
29.     HeapSort()  
30.     {}  
31.     HeapSort(T* arr, size_t n)  
32.     {  
33.         _vec.reserve(n);  
34.         if (arr != NULL)  
35.         {  
36.             for (size_t i = 0; i < n; i++)  
37.             {  
38.                 _vec.push_back(arr[i]);  
39.             }  
40.         }  
41.           
42.         _AdjustDown(_vec.size());  
43.     }  
44.   
45.     void Sort()  
46.     {  
47.         size_t size = _vec.size();  //数据数量  
48.         while (size > 1)     
49.         {  
50.             swap(_vec[0], _vec[size - 1]);  
51.             size--;  
52.             _AdjustDown(size);  
53.         }  
54.     }  
55.     void Print()  
56.     {  
57.         for (size_t i = 0; i < _vec.size(); i++)  
58.         {  
59.             cout << _vec[i] <<" ";  
60.         }  
61.         cout << endl;  
62.     }  
63. protected:  
64.     void _AdjustDown(int size)  
65.     {  
66.         int parent = (size - 2) / 2;  
67.         while (parent >= 0)  
68.         {  
69.             _AdjustDown(parent, size - 1);  
70.             parent--;  
71.         }  
72.     }  
73.     void _AdjustDown(int root,int size)  
74.     {  
75.         Camper camper;       //仿函数  
76.         int parent = root;  
77.         int child = parent * 2 + 1;  
78.         while (child <= size)  //保证访问不越界  
79.         {  
80.             if (child < size && camper(_vec[child+1] , _vec[child])) //保证存在右子树、同时判断右子树是否大于或小于左子树  
81.             {  
82.                 child++;  
83.             }  
84.             if (camper(_vec[child], _vec[parent]))  
85.             {  
86.                 swap(_vec[parent], _vec[child]);  
87.                 parent = child;  
88.                 child = parent * 2 + 1;  
89.             }  
90.             else  
91.             {  
92.                 break;  
93.             }  
94.         }  
95.   
96.     }  
97. private:  
98.     vector<T> _vec;  
99. };  

测试用例代码：

[cpp]  view plain  copy

 

1. void TextSort()  
2. {  
3.     int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };  
4.     HeapSort<int,Greater<int>> h(a, sizeof(a) / sizeof(a[0]));  
5.     h.Print();  
6.     h.Sort();  
7.     h.Print();  
8. }