数据结构——交换排序

冒泡排序

算法原理

• 从前往后（或从后往前）两两比较相邻元素的值，若为逆序，则交换，直到序列比较完。此时最小的元素交换到序列第一个位置（或最大的元素交换到序列最后一个位置）。称为一趟排序。
• 下一趟排序时，之前确定的元素不再参与比较，最多做$n-1$趟排序

代码实现

void BubbleSort(int A[], int n){
	bool flag;
	int i, j;
	for(i=1; i<=n; i++){
		flag = false;
		for(j=n; j>i; j--)
			if(A[j-1] > A[j]){
				int k = A[j];
				A[j] = A[j-1];
				A[j-1] = k;
				flag = true;
			}
		if(flag == false)		// 如果没有发生交换，则证明已经有序
			return;
	}
}

举例

性能分析

• 空间效率：仅使用常数个辅助单元，空间复杂度为$O(1)$
• 时间效率
  • 最好情况：初始序列已经有序，比较次数为$n-1$，移动次数为0，时间复杂度为$O(n)$
  • 最坏情况：初始序列为逆序，需要$n-1$趟排序，第$i$趟进行$n-i$次比较，每次比较后移动三次元素，即比较次数为${\sum }_{i=1}^{n-1}(n-i)$，移动次数为${\sum }_{i=1}^{n-1}3(n-i)$，时间复杂度为$O(n^2)$
  • 平均时间复杂度为$O(n^2)$
• 稳定性：稳定

快速排序

算法原理

假设该数组为q。

采用分治思想：
第一步：确定分界点x（左边界q[ l ]，右边界q[ r ]，q[ l+r>>2 ]，随机）。
第二步：将大于等于x的数放在其右边，小于等于x的数放在其左边（重点）。
第三步：递归处理左右两段。

每趟排序后会将分界点元素放在最终位置

第二步的实现方法：

• 简单的方法:
  另外开两个数组 a 和 b，分别放置所有小于x的数和大于x的数，最后将其合并到 q 中。
• 高效方法:
  使用两个指针 i 和 j，i 从头向尾开始扫描，j 从尾到头开始扫描，当 i 扫描到的数大于 x 时停止，当 j 扫描到的数小于x 时停止，若此时i < j，则交换 q[ i ] 和 q[ j ] ，然后 i 和 j 继续向中间走，直到 i 和 j 相遇。

注意事项:

由于该算法采用分治的思想，所以要考虑边界情况，即：将n个数划分为0个数和n个数的情况，将导致无限划分。

当以 j 划分时，x不能取 q[r]；当以 i 划分时，x不能取 q[l]。

所以我们直接采用下面的划分方法：

int x = q[l+r>>1];

此时使用 i 或者 j 划分都不会出差错

quick_sort(q, l, j);
quick_sort(q, j+1, r);
或者
quick_sort(q, l, i-1);
quick_sort(q, i, r);

代码实现

#include <iostream>
using namespace std;

const int N = 100010;
int q[N];

void quick_sort(int q[], int l, int r){
    if(l >= r) return;
    int i =  l - 1, j = r + 1, x = q[l+r>>1];
    while(i < j){
        do i++; while(q[i] < x);
        do j--; while(q[j] > x);
        if(i < j){
            int y = q[i];
            q[i] = q[j];
            q[j] = y;
        }
    }
    quick_sort(q, l, j);
    quick_sort(q, j+1, r);
}

int main(){
    int n;
    scanf("%d", &n);
    for(int i=0;i<n;i++) scanf("%d", &q[i]);
    quick_sort(q, 0, n-1);
    for(int i=0;i<n;i++) printf("%d ", q[i]);
    return 0;
}

性能分析

• 空间效率：递归算法，借助递归栈，最好情况下为$O({\log }_{2}n)$，最坏情况下为$O(n)$，平均情况下为$O({\log }_{2}n)$
• 时间效率：运行时间与划分是否对称有关，最坏情况下为$O(n^2)$，平均时间复杂度为$O(n{\log }_{2}n)$
• 稳定性：不稳定