[C++]数据结构：排序算法Part1----冒泡排序、选择排序、插入排序、堆排序

1.冒泡排序：

正所谓人如其名，冒泡排序正是使用了“冒泡”的方法对元素进行了排序。

它的算法思想就是在每次遍历的时候从头到尾比较相邻的两个元素大小，将较小的元素“冒”到前面来，把最大的元素移向队尾，使得元素变得有序。

我们把已经排好序的区域称为有序区，相对应的便是没排好顺序的无序区了。

那么冒泡排序大致可以分为两类，一类是每次遍历的时候将较小的元素“冒”到前面来，把最小的元素移向队首，使得前面的元素变得有序，即将前排元素逐渐扩展成有序区，并且慢慢缩小后排元素所在的无序区。另一类则是将较大的元素“冒”到后面去，把最大的元素移向队尾，使得后面的元素变得有序，即将后排元素逐渐扩展成有序区，并且慢慢缩小前排元素所在的无序区。这两种在本质上没有任何区别，是排序家族的冒泡双胞胎。

下面来看一下冒泡算法的代码示例：

[cpp] view plain copy

1. #include <iostream>    
2. using namespace std;    
3. template <class T>    
4. void  BubbleSort(T& nData,int len)    
5. {    
6.     for(int i = 0;i<len-1;++i){    
7.         for(int j = len - 1;j > i;--j){    
8.             if(nData[j]<nData[j-1]){    
9.                 int temp = nData[j];    
10.                 nData[j] = nData[j-1];    
11.                 nData[j-1] = temp;  
12.                 show(nData,len);  
13.             }    
14.         }    
15.     }    
16. }    
17.   
18. template <class T>     
19. void show(T arr,int n){    
20.     for(int i =0;i<n-1;i++){    
21.         cout<<arr[i]<<",";    
22.     }    
23.     cout<<arr[n-1]<<endl;    
24. }    
25.   
26. void main()    
27. {    
28.     int inputNumber[]={2,7,5,9,1,4,6,3,8};    
29.     int count = 9;   
30.     cout<<"原始数组："<<endl;  
31.     show(inputNumber,count);  
32.     cout<<"排序过程："<<endl;  
33.     BubbleSort(inputNumber,count);   
34.     cout<<"排序结果："<<endl;  
35.     show(inputNumber,count);    
36. }    

运行结果如下图所示：

但是如果是这样单纯的冒泡排序在时间上存在很大的浪费，比如现在序列顺序是12345，那么冒泡排序还是老老实实的挨个将它们依次比较并进行排序。所以对于前面说到的冒泡算法还需要进行优化处理：如果某一轮遍历比较中没发生元素交换，则表示整个序列已经有序，排序提前结束。

下面来看一下升级版本也就是能够提前终止的冒泡算法源码：

[cpp] view plain copy

1. #include <iostream>    
2. using namespace std;    
3. template <class T>    
4. void  BubbleSort(T& nData,int len)    
5. {    
6.     bool isOk = false;    
7.     for(int i = 0;i<len-1&&!isOk;++i){    
8.         isOk = true;    
9.         for(int j = len - 1;j > i;--j){    
10.             if(nData[j]<nData[j-1]){    
11.                 int temp = nData[j];    
12.                 nData[j] = nData[j-1];    
13.                 nData[j-1] = temp;    
14.                 isOk = false;    
15.                 show(nData,len);  
16.             }    
17.         }    
18.     }    
19. }    
20.   
21. template <class T>     
22. void show(T arr,int n){    
23.     for(int i =0;i<n-1;i++){    
24.         cout<<arr[i]<<",";    
25.     }    
26.     cout<<arr[n-1]<<endl;    
27. }    
28.   
29. void main()    
30. {    
31.     int inputNumber[]={2,7,5,9,1,4,6,3,8};    
32.     int count = 9;   
33.     cout<<"原始数组："<<endl;  
34.     show(inputNumber,count);  
35.     cout<<"排序过程："<<endl;  
36.     BubbleSort(inputNumber,count);   
37.     cout<<"排序结果："<<endl;  
38.     show(inputNumber,count);    
39. }    

代码的运行结果如下图所示：

下面来分析一下冒泡排序的复杂度。

当最好的情况，也就是要排序的表本身就是有序的，那么我们比较次数，根据最后改进的代码，可以推断出就是n‐1次的比较，没有数据交换，时间复杂度为O(n)。

当最坏的情况，即待排序表是逆序的情况，此时需要比较的次数为：

 并作等数量级的记录移动。因此，总的时间复杂度为O(n2)。

再来看一下冒泡排序的稳定性。

排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

总结一下冒泡排序：

原理：将序列划分为无序和有序区，不断比较无序区的相邻元素，通过交换较大元素至无序区尾完成排序。

要点：设计交换判断条件，提前结束已经排好序的序列循环。

2.选择排序：

选择排序可以说是最容易理解的排序算法，它的思想和正常人脑的思路基本一致：先把最小的那个拎出来，逐渐减少排序的规模。在我们给学生按照高矮排序的时候，一般都是先把最矮的学生排在队伍的最前面，然后再从剩下的学生中挑选最矮的排在剩下的学生队伍的最前面。

有人可能会感觉选择排序和冒泡排序很相似，因为都是将最大值放到队尾或最小值放到队首的操作。他们之间的不同点在于，选择排序每扫描一遍数组，只需要一次真正的交换，而冒泡可能需要很多次。但是比较的次数是一样的。

和冒泡排序一样，我们把序列分割成有序区和无序区，每一次的操作都是将无序区中的最小的元素放到无序区的头部，并且将其纳为有序区的成员。所以每次遍历有序区元素个数加一并且无序区元素个数减一。

下面来看一下选择排序的源码：

[cpp] view plain copy

1. #include <iostream>    
2. using namespace std;    
3.   
4. template <class T>  
5. void SelectionSort(T a[],int n)  
6. {//对数组a[0:n-1]中的n个元素进行排序  
7.     for(int size=n;size>1;size--)  
8.     {  
9.         int j=Max(a,size);  
10.         Swap(a[j],a[size-1]);  
11.         show(a,n);  
12.     }  
13. }  
14.   
15.   
16. template<class T>  
17. void Swap(T&a,T&b)  
18. {  
19.     T temp = a;  
20.     a = b;  
21.     b = temp;  
22.     return;  
23. }  
24.   
25. template<class T>  
26. int Max(T a[],int n)  
27. {//寻找a[0;n-1]中的最大元素  
28.     int pos=0;  
29.     for(int i=1;i<n;i++)  
30.         if(a[pos]<a[i])  
31.             pos=i;  
32.         return pos;  
33. }  
34.   
35. template <class T>     
36. void show(T arr,int n){    
37.     for(int i =0;i<n-1;i++){    
38.         cout<<arr[i]<<",";    
39.     }    
40.     cout<<arr[n-1]<<endl;    
41. }    
42.   
43. void main()    
44. {    
45.     int inputNumber[]={2,7,5,9,1,4,6,3,8};    
46.     int count = 9;   
47.     cout<<"原始数组："<<endl;  
48.     show(inputNumber,count);  
49.     cout<<"排序过程："<<endl;  
50.     SelectionSort(inputNumber,count);   
51.     cout<<"排序结果："<<endl;  
52.     show(inputNumber,count);    
53. }    

排序之后的流程图如下所示：

上述选择排序函数的一个缺点是：即使元素已经按序排列，程序仍然继续运行。为了终止不必要的循环，在查找最大元素的期间，可以顺便检查数组是否已按序排列。可以在遍历该数组的过程中添加一个名为sorted的布尔值来判断当前序列是否已经按照顺序排列完毕。下面程序给出了一个按照这种思想实现的选择排序函数。在该函数中，把查找最大元素的循环直接与函数SelectionSort合并在一起，而不是把它作为一个独立的函数：

[cpp] view plain copy

1. #include <iostream>    
2. using namespace std;    
3.   
4. template <class T>  
5. void SelectionSort(T a[],int n)  
6. {//及时终止的选择排序  
7.     bool sorted=false;  
8.     for(int size=n;!sorted && (size>1);size--)  
9.     {  
10.         int pos=0;  
11.         sorted=true;  
12.         //找最大元素  
13.         for(int i=1;i<size;i++)  
14.             if(a[pos]<=a[i])  
15.                 pos=i;//如果已经按序排列，那么就不会有else的机会，sorted也就一直为true，最红将终止外部for循环。  
16.             else  
17.                 sorted=false;//非未按序排列，表示需要外部for循环  
18.             Swap(a[pos],a[size-1]);  
19.             show(a,n);  
20.     }  
21. }  
22.   
23. template<class T>  
24. void Swap(T&a,T&b)  
25. {  
26.     T temp = a;  
27.     a = b;  
28.     b = temp;  
29.     return;  
30. }  
31.   
32. template <class T>     
33. void show(T arr,int n){    
34.     for(int i =0;i<n-1;i++){    
35.         cout<<arr[i]<<",";    
36.     }    
37.     cout<<arr[n-1]<<endl;    
38. }    
39.   
40. void main()    
41. {    
42.     int inputNumber[]={2,7,5,9,1,4,6,3,8};    
43.     int count = 9;   
44.     cout<<"原始数组："<<endl;  
45.     show(inputNumber,count);  
46.     cout<<"排序过程："<<endl;  
47.     SelectionSort(inputNumber,count);   
48.     cout<<"排序结果："<<endl;  
49.     show(inputNumber,count);    
50. }    

排序结果截图：

下面来分析一下选择排序的复杂度：

从简单选择排序的过程来看，它最大的特点就是交换移动数据次数相当少，这样也就节约了相应的时间。分析它的时间复杂度发现，无论最好最差的情况，其比较次数都是一样的多，第i趟排序需要进行n－i次关键字的比较,此时需要比较的次数为：

而对于交换次数而言，当最好的时候，交换为0次，最差的时候，也就初始降序时，交换次数为n－1次，基于最终的排序时间是比较与交换的次数总和，因此，总的时间复杂度依然为O(n2)。

应该说，尽管与冒泡排序同为O(n2)，但简单选择排序的性能上还是要略优于冒泡排序。

下面来看一下选择排序的稳定性：

选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

总结一下选择排序：

原理：将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序。要点：设计交换判断条件，提前结束已经排好序的序列循环。

3.插入排序：

插入排序和前面两种排序的原理基本相同，都是使用扩大有序区缩小无序区的方法实现排序。但是插入排序是按照顺序遍历无序区的元素，并且将它们挨个插入到有序区中。借用明哥博客里一个非常恰当的比喻，就好比是打扑克时的插扑克的操作一样。

插入排序的源码如下：

[cpp] view plain copy

1. #include <iostream>    
2. using namespace std;    
3. template <class T>  
4. void Insert(T a[],int n,const T &x)  
5. {//向有序数组a[0:n-1]中插入元素x  
6.     int i;  
7.     for(i=n-1;i>=0 && x<a[i];i--)  
8.         a[i+1]=a[i];  
9.     a[i+1]=x;  
10. }  
11.   
12. template <class T>  
13. void InsertionSort(T a[],int n)  
14. {//对a[0:n-1]进行排序  
15.     for(int i=1;i<n;i++)  
16.     {  
17.         T t=a[i];  
18.         Insert(a,i,t);  
19.         show(a,n);  
20.     }  
21. }  
22.   
23. template <class T>     
24. void show(T arr,int n){    
25.     for(int i =0;i<n-1;i++){    
26.         cout<<arr[i]<<",";    
27.     }    
28.     cout<<arr[n-1]<<endl;    
29. }    
30.   
31. void main()    
32. {    
33.     int inputNumber[]={2,7,5,9,1,4,6,3,8};    
34.     int count = 9;   
35.     cout<<"原始数组："<<endl;  
36.     show(inputNumber,count);  
37.     cout<<"排序过程："<<endl;  
38.     InsertionSort(inputNumber,count);   
39.     cout<<"排序结果："<<endl;  
40.     show(inputNumber,count);    
41. }    

插入排序的截图如下：

插入排序的复杂度分析：

当最好的情况，也就是要排序的表本身就是有序的，没有移动的记录，时间复杂度为O(n)。

当最坏的情况，即待排序表是逆序的情况，比如{6,5,4,3,2}，此时需要比较的次数为：

而记录的移动次数也达到最大值：

如果排序记录是随机的，那么根据概率相同的原则，平均比较和移动次约为四分之一乘以N的平方次。

因此，我们得出直接插入排序法的时间复杂度为O(n2)。从这里也看出，同样的O(n2)时间复杂度，直接插入排序法比冒泡和简单选择排序的性能要好一些。

下面来看一下插入排序的稳定性：

  插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

下面来总结一下插入排序：

原理：将数组分为无序区和有序区两个部分，然后不断的将无序区的第一个元素按照大小的顺序插入到有序区中，每次遍历操作无序区中的元素个数减一并且有序区元素加一。

要点：设立标志，作为临时存储和判断数组边界之用。

4.堆排序

在介绍堆排序之前，还得说一说堆的概念。

相关博文的链接传送门：

[C++]数据结构：最大堆MaxHeap的创建与使用

简单来说，最大堆就是一个从上而下的每一层都满足从大到小顺序的完全二叉树。

那么最简单的堆排序就是每次取出堆顶元素，并且保持剩下的元素依旧构成一个最大堆，就可以实现堆排序了。具体的相关操作参考连接的博文内容。

所以堆排序的排序方法非常简单，因为重点在堆结构的操作上。源码如下：

[cpp] view plain copy

1. //优先队列：堆MaxHeap的定义与使用  
2. #include <iostream>  
3. using namespace std;  
4.   
5. void OutOfBounds(){    
6.     cout<<"Out Of Bounds!"<<endl;    
7. }    
8.   
9.   
10. void BadInput(){    
11.     cout<<"Bad Input!"<<endl;    
12. }    
13.   
14.   
15. void NoMem(){    
16.     cout<<"No Memory!"<<endl;    
17. }    
18.     
19. template<class T>  
20. class MaxHeap{  
21.     public:  
22.         MaxHeap(int MaxHeapSize = 10);  
23.         int Size()const{return CurrentSize;}  
24.         T Max(){  
25.             if (CurrentSize == 0)  
26.                 throw OutOfBounds();  
27.             return heap[1];  
28.         }  
29.   
30.         MaxHeap<T>& Insert(const T&x);  
31.         MaxHeap<T>& DeleteMax(T&x);  
32.         void Initialize(T a[],int size,int ArraySize);  
33.         void Output(ostream& out)const;  
34.   
35.         int CurrentSize;  
36.         int MaxSize;  
37.         T *heap;//元素数组    
38. };  
39.   
40.   
41. //输出链表    
42. template<class T>    
43. void MaxHeap<T>::Output(ostream& out)const{    
44.     for (int i= 0;i<CurrentSize;i++)  
45.     {  
46.         cout<<heap[i+1]<<"  ";  
47.     }  
48.     cout<<endl;  
49. }    
50. //重载操作符    
51. template<class T>    
52. ostream& operator<<(ostream& out,const MaxHeap<T>&x){    
53.     x.Output(out);    
54.     return out;    
55. }    
56.   
57. template<class T>  
58. MaxHeap<T>::MaxHeap(int MaxHeapSize /* = 10 */){  
59.     MaxSize = MaxHeapSize;  
60.     heap = new T[MaxSize+1];  
61.     CurrentSize = 0;  
62. }  
63.   
64. //将x插入到最大堆中  
65. template<class T>  
66. MaxHeap<T>& MaxHeap<T>::Insert(const T&x){  
67.     if(CurrentSize==MaxSize)  
68.         throw NoMem();  
69.   
70.     //为x寻找插入位置  
71.     //i从新的叶结点开始，并沿着树慢慢上升  
72.     int i = ++CurrentSize;  
73.     while(i!=1&&x>heap[i/2]){  
74.         //不能把x放到heap[i]  
75.         heap[i] = heap[i/2];//将元素下移  
76.         i/=2;  
77.     }  
78.     heap[i] = x;  
79.     return *this;  
80. }  
81.   
82.   
83. //将最大的元素放到x并从堆中删除  
84. template<class T>  
85. MaxHeap<T>& MaxHeap<T>::DeleteMax(T&x){  
86.     //检查堆是否为空  
87.     if(CurrentSize==0)  
88.         throw OutOfBounds();  
89.       
90.     x = heap[1];                    //取出最大元素并放入x中  
91.     T y = heap[CurrentSize];        //y为最后一个元素  
92.   
93.     CurrentSize--;  
94.   
95.     //从根开始为y寻找合适的位置  
96.     int i = 1;          //堆的当前节点  
97.     int ci = 2;         //i的孩子  
98.     while(ci<=CurrentSize){  
99.         //heap[ci]应该是较大的孩子  
100.         if(ci<CurrentSize&&heap[ci]<heap[ci+1])  
101.             ci++;  
102.   
103.         //能否把y放入heap[i]  
104.         if(y>=heap[ci])  
105.             break;  
106.         heap[i]=heap[ci];  
107.         i = ci;  
108.         ci = 2*ci;  
109.     }  
110.   
111.     heap[i]=y;  
112.     return *this;  
113. }  
114.   
115.   
116. //把最大堆初始化为数组a  
117. template<class T>  
118. void MaxHeap<T>::Initialize(T a[],int size,int ArraySize){  
119.     delete []heap;  
120.     heap = a;  
121.     CurrentSize = size;  
122.     MaxSize = ArraySize;//数组空间大小  
123.   
124.     //产生一个最大堆  
125.     for (int i = CurrentSize/2;i>=1;i--){  
126.       
127.         T y = heap[i];      //子树的根  
128.   
129.         //寻找放置y的位置  
130.         int c = 2*i;    //c的父节点是y的目标位置  
131.           
132.         while(c<=CurrentSize){  
133.   
134.             //heap[c]应该是较大的同胞节点  
135.             if(c<CurrentSize&&heap[c]<heap[c+1])  
136.                 c++;  
137.   
138.             //能否把y放入heap[c/2]  
139.             if(y>=heap[c])       //能把y放入heap[c/2]  
140.                 break;                
141.   
142.             //不能把y放入heap[c/2]  
143.             heap[c/2]=heap[c];  //将孩子上移  
144.             c=2*c;              //下移一层  
145.   
146.         }  
147.         heap[c/2] = y;  
148.     }  
149. }  
150.   
151. template<class T>  
152. void HeapSort(T a[],int n)  
153. {  
154.     MaxHeap<T>H;  
155.     H.Initialize(a,n-1,20);  
156.     T x;  
157.     for (int i=n-1;i>=1;i--)  
158.     {  
159.         show(a,10);  
160.         H.DeleteMax(x);  
161.         a[i]=x;  
162.     }  
163. }  
164. template <class T>     
165. void show(T arr,int n){    
166.     for(int i =1;i<n-1;i++){    
167.         cout<<arr[i]<<",";    
168.     }    
169.     cout<<arr[n-1]<<endl;    
170. }  
171.   
172. int main(){  
173.     MaxHeap<int>myHeap;  
174.     const int number = 10;  
175.     int myArray[number+1] = {-1,2,7,5,9,1,4,6,3,8};  
176.     cout<<"原始数组："<<endl;  
177.     show(myArray,number);  
178.     cout<<"排序过程："<<endl;  
179. //  myHeap.Initialize(myArray,number,20);  
180.     HeapSort(myArray,number);  
181.     cout<<"排序结果："<<endl;  
182.     show(myArray,number);  
183.     return 0;  
184. }  

代码执行的过程图如下：

下面来分析一下堆排序的复杂度。

它的运行时间主要是消耗在初始构建堆和在重建堆时的反复筛选上。

在构建堆的过程中，因为我们是完全二叉树从最下层最右边的非终端结点开始构建，

将它与其孩子进行比较和若有必要的互换，对于每个非终端结点来说，其实最多进行两次比较和互换操作，因此整个构建堆的时间复杂度为O(n)。

在正式排序时，第i次取堆顶记录重建堆需要用O(log i)的时间。完全二叉树的某个结点到根结点的距离为log（i＋1），并且需要取n－1次堆顶记录，因此，重建堆的时间复杂度为O(nlogn)。

所以总体来说，堆排序的时间复杂度为O(nlogn)。

由于堆排序对原始记录的排序状态并不敏感，因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)。这在性能上显然要远远好过于冒泡、简单选择、直接插入的O(n2)的时间复杂度了。

空间复杂度上，它只有一个用来交换的暂存单元，也非常的不错。

不过由于记录的比较与交换是跳跃式进行，因此堆排序也是一种不稳定的排序方法。

另外，由于初始构建堆所需的比较次数较多，因此，它并不适合待排序序列个数较少的情况。

下面来分析一下堆排序的稳定性：

我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2,...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。

下面来总结一下堆排序的要点：

原理：利用大根堆或小根堆思想，首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区。

要点：建堆、交换、调整堆。