【排序】排序算法之---交换排序

所谓排序，就是要将一堆记录，使之按关键字递增(或递减)次序排列起来。根据排序所采用的策略，可以分为如下五种：

1、插入排序（直接插入排序、希尔排序）；

2、交换排序（冒泡排序、快速排序）；

3、选择排序（直接选择排序、堆排序）；

4、归并排序；

5、桶排序（桶排序，基数排序）；

---------------------------------------------------------------------------------

交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序（Bubble Sorting）

基本思想：从后往前扫描序列，通过相邻元素之间的比较与交换，使值较小的元素逐渐从后部移向前部（从下标较大的单元移向下标较小的单元），就象水底下的气泡一样逐渐向上冒。故称为冒泡排序法。

C 代码实现：

void bubble_sort(int* array, int length)
 {
     assert(array && length >= 0);
 
     int i, j, temp;
 
     for (i = 1; i < length; ++i) {
         for (j = length - 1; j >= i; --j) {
             if (array[j] < array[j - 1]) {
                temp = array[j];
                array[j] = array[j - 1];
                array[j - 1] = temp;
            }
        }
    }
}

若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止。因此，上面的实现可以优化如下：

 1void bubble_sort(int* array, int length)
 2{
 3    assert(array && length >= 0);
 4
 5    int i, j, temp;
 6    bool exchange;
 7
 8    for (i = 1; i < length; ++i) {
 9        exchange = false;
10
11        for (j = length - 1; j >= i; --j) {
12            if (array[j] < array[j - 1]) {
13                temp = array[j];
14                array[j] = array[j - 1];
15                array[j - 1] = temp;
16
17                exchange = true;
18            }
19        }
20
21        if (!exchange) {
22            break;
23        }
24    }
25}

还可以通过减少排序的趟数作进一步的优化。 在每趟扫描中，记住最后一次交换发生的位置 lastExchange （该位置之前的相邻记录均已有序）。下一趟排序开始时，array[1..lastExchange - 1] 是有序区， array[lastExchange..n] 是无序区。这样，一趟排序可能使当前有序区扩充多个记录，从而减少排序的趟数。实现如下：

1void bubble_sort(int* array, int length)
 2{
 3    assert(array && length >= 0);
 4
 5    int i, j, temp;
 6    bool exchange;
 7    int lastExchange = 1;
 8
 9    for (i = 1; i < length;) {
10        exchange = false;
11
12        for (j = length - 1; j >= i; --j) {
13            if (array[j] < array[j - 1]) {
14                temp = array[j];
15                array[j] = array[j - 1];
16                array[j - 1] = temp;
17
18                lastExchange = j;
19                exchange = true;
20            }
21        }
22
23        if (!exchange) {
24            break;
25        }
26
27        i = lastExchange + 1;
28    }
29}

如果待排序序列是基本有序（比如只有第一个元素是最大的，其他的都已有序，在这种情况下，本该只需要 1 趟排序就可以完成），如果用上面的实现 ，这时平均时间复杂达到最坏 O(n^2）。 在这种情况下，可以通过交替改变扫描方向（从后往前，从前往后，再从后往前...）改变不对称性达到优化的目的。具体实现就留着当作业啦，^_^

时间复杂度：
最好的情况下，待排序记录已经有序，只需要一趟排序就可以完成，所以冒泡排序的最好时间复杂度为 O(n)。
最坏的情况下，待排序记录反序，这时需要 n - 1 趟排序，每趟排序需要比较 n - i 次比较操作，这时比较和移动的次数达到最大值，所以冒泡排序的最坏时间复杂度为 O(n ^ 2)。

冒泡排序的平均时间复杂度为 O(n ^ 2)。因为它移动的次数较多，其平均时间性能还不如直接插入排序。

空间复杂度：
很明显，O(1)。

补充：
冒泡排序是就地排序，且是稳定排序。

快速排序

基本思想：采用分治法。 设当前待排序的无序区为 array[low..high]，在其中任选一个记录作为基准(Pivot)，调整基准在序列中的位置 prvotpos，使左边子区间中所有记录的关键字均小于等于基准记录的关键字，右边的子区间中所有记录的关键字均大于等于基准记录的关键字。即基准将当前无序区划分为左、右两个较小的子区间 array[low..pivotpos - 1] 和 array[pivotpos + 1..high]，而基准记录已经处在正确的位置上，它无须参加后续的排序。这时，排序问题就分解成两个子区间的排序问题（这就是分而治之的思想啊）， 递归对左右子区间进行快速排序，就可以完成排序。

BTW，分治法的基本思想：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
代码实现：

// 选取第一个元素为pivot（当然也有别的选法），然后根据此pivot将比它小的全放左边，比它大的全放右边，排序完成后返回该基准记录所在的位置
int quick_partition(int* array, int low, int high)
{
    assert(array && low >= 0 && low <= high);

    int pivot = array[low]; // 用区间的第 1 个记录作为基准

    while (low < high) {	//从区间两端交替向中间扫描，直至low=high为止
       while (low < high && array[high] >= pivot) {	//pivot相当于在位置low上
            --high;		//从右向左扫描，查找第1个小于pivot的记录array[high]
        }

       if (low < high) {	//表示找到的array[high]< pivot
            array[low++] = array[high];	//相当把array[high]放到了pivot的左边，交换后low指针加1，换到
        }

        while (low < high && array[low] <= pivot) {//pivot相当于在位置high上
            ++low;		//然后，从左向右扫描，查找第一个大于pivot的记录arrayp[low]	19	  }

        if (low < high) {	//表示找到了array[low]> pivot
            array[high--] = array[low];	//相当于把array[low]放到了pivot的右边，交换后high指针减1
 	}
   }

 	array[low] = pivot;   //基准记录已被最后定位

 	return low;
}

void quick_sort_impl(int* array, int low, int high)
{
	 if (low < high) {
 	int pivotPos = quick_partition(array, low, high);
        //每做一次，这个点就到了它应该在的位置（所有比它小的都在它左边，比它大的都在它右边）
	//接下来对它左边和右边的区域分别进行递归处理，
 	quick_sort_impl(array, low, pivotPos - 1);
 	quick_sort_impl(array, pivotPos + 1, high);
 	}
}

// 快速排序
//
 void quick_sort(int* array, int length)
{
    assert(array && length >= 0);

    if (length <= 1) {
        return;
    }

    quick_sort_impl( array, 0, length - 1);
}

时间复杂度分析：最坏情况是每次划分选取的基准都是当前无序区中关键字最小(或最大)的记录，划分的结果是基准左边的子区间为空(或右边的子区间为空)，而划分所得的另一个非空的子区间中记录数目，仅仅比划分前的无序区中记录个数减少一个。此时，时间复杂度为 O(n ^ 2)。在最好情况下，每次划分所取的基准都是当前无序区的"中值"记录，划分的结果是基准的左、右两个无序子区间的长度大致相等。总的关键字比较次数：0(nlgn)。尽管快速排序的最坏时间为
 O(n ^ 2)，但就平均性能而言，它是基于关键字比较的内部排序算法中速度最快者，快速排序亦因此而得名。它的平均时间复杂度为 O(nlgn)。

空间复杂度分析：快速排序需要一个栈来实现递归。若每次划分较为均匀（也就是对半分，基准值总是中值），则其递归树的高度为O(lgn)，故递归后需栈空间为O(lgn)。最坏情况下，递归树的高度为O(n)，所需的栈空间为O(n)。补充：快速排序是非稳定的。例如，对
 [5, 5, 1] 进行排序。对时间复杂度进行分析之后，可以看出，在当前无序区中选取划分的基准关键字是决定算法性能的关键。可以对这个进行一定程度的优化：第一办法是，取中值，即比较当前无序区间的第一个，中间那个以及最后一个记录的大小，取中间的那个记录作为基准，进行快速排序；第二个办法是，在当前无需区间中进行随机选取。

转载自（http://www.cppblog.com/kesalin）