数据结构之——交换排序

1.交换排序算法实现

这里的交换排序指的是冒泡排序和快速排序，

其中快速排序的过程可以简单的理解为：选取序列首元素为枢轴值（pivot），然后分别从序列尾部找到第一个小于pivot的元素（A），从序列首部找到第一个大于pivot的元素（B），然后交换此A，B两元素，直至首尾遍历的两指针重合，一趟排序结束。

以下是这两算法的具体实现：

 1 #include<iostream>
 2 using namespace std;
 3
 4 //声明打印辅助函数
 5 void printArray(int array[], int length);
 6 //声明冒泡排序函数
 7 void BubbleSort(int array[], int lenght);
 8 //声明分割函数，供快速排序函数调用
 9 int Partition(int array[], int low, int high);
10 //声明快速排序函数
11 void QuickSort(int array[], int low, int high);
12
13 int main()
14 {
15     int array[] = { 12, 3, 6, 4, 27, 9 };
16     int length = sizeof(array) / sizeof(*array);
17
18     cout << "排序前序列为：" << endl;
19     printArray(array, length);
20
21     BubbleSort(array, length);
22     cout << endl << "冒泡排序后序列为：" << endl;
23     printArray(array, length);
24     cout << endl;
25
26     QuickSort(array, 0, length - 1);
27     cout << endl << "快速排序后序列为：" << endl;
28     printArray(array, length);
29     cout << endl;
30
31     cout <<endl;
32     system("pause");
33     return 0;
34 }
35
36 void printArray(int array[], int length)
37 {
38     for (int i = 0; i < length; i++)
39     {
40         if (i == length - 1)
41             cout << array[i];
42         else
43             cout << array[i] << ",";
44     }
45 }
46
47 void BubbleSort(int array[], int lenght)
48 {
49     int tmp;
50     //标记是否发生了交换
51     bool flag;
52     for (int i = 0; i < lenght;i++)
53     {
54         flag = false;
55         for (int j = lenght - 1; j >i; j--)
56         {
57             if (array[j-1]>array[j])
58             {
59                 tmp = array[j - 1];
60                 array[j - 1] = array[j];
61                 array[j] = tmp;
62                 flag = true;
63             }
64         }
65         //一趟排序未发生交换时，表示已经排序已经完成
66         if (flag==false)
67         {
68             return;
69         }
70     }
71 }
72
73 int Partition(int array[], int low, int high)
74 {
75     int pivot = array[low];
76     while (low<high)
77     {
78         while (low < high && array[high] >= pivot) high--;
79         array[low] = array[high];
80         while (low < high && array[low] <= pivot) low++;
81         array[high] = array[low];
82     }
83     array[low] = pivot;
84     return low;
85 }
86
87 void QuickSort(int array[], int low, int high)
88 {
89     if (low<high)
90     {
91         int pivot = Partition(array, low, high);
92         QuickSort(array, low, pivot - 1);
93         QuickSort(array, pivot + 1, high);
94     }
95 }

2.关于交换排序的一些结论

（1）.为实现快速排序算法，待排序序列宜采用的存储方式为顺序存储。

（2）.就平均性能而言，快速排序是目前最好的内部排序算法，但是当要排序的数据已经基本有序时，不宜使用快速排序算法。

（3）.快速排序过程构成一棵递归树，递归深度即为递归树的深度，当枢轴值每次将序列等分时，递归树的高为log2n；当枢轴值每次都是子表的最大值或者最小值时，此时递归树退化为单链表，树高为n。