C语言：排序算法

本节中所讲的排序均以升序为例。

一、冒泡排序

1. 基本思想：

从左到右，两两比较；如果发现前者比后者大，则交换元素。每一轮比较完毕后，序列中最大的一个元素会至于最后。流程图如下:



2. 代码清单：

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

int main(int argc, const char * argv[]) {
    
    int a[] = {2, 4, 9, 1, 0, 3};
    bubbleSort(a, 6);
    
    for (int i = 0; i < 6; i++) {
        printf("%d\n", a[i]);
    }
    
    return 0;
}

二、选择排序

1. 基本思想：

每次循环的时候，找出数组中最小的元素，并且与循环操作中数组最前面的元素进行交换。流程图如下:



2. 代码清单：

void selectionSort(int *a, int length) {
    int outer, inner, min;
    for (outer = 0; outer < length - 1; outer++) {
        min = outer;
        for (inner = outer + 1; inner < length; inner++) {
            if (a[inner] < a[min]) {
                min = inner;
            }
        }
        
        int temp = a[outer];
        a[outer] = a[min];
        a[min] = temp;
    }
}

int main(int argc, const char * argv[]) {
    
    int a[] = {2, 4, 9, 1, 0, 3};
    selectionSort(a, 6);
    
    for (int i = 0; i < 6; i++) {
        printf("%d\n", a[i]);
    }
    
    return 0;
}

三、插入排序

1. 基本思想：

每次假定数组第一个元素为在正确的位置上面，然后在数组后面依次寻找比这个元素大得并且是最小的那个元素，将其插入到指定元素的后面，与此同时，那些原本紧挨着指定元素后面的所有元素，依次往后移动一个位置。



2. 代码清单：

void insertSort(int *a, int length) {
    int i, j, target;
    // 假定第一个元素被放到了正确的位置上，这样仅需要便利n-1次
    for (i = 1; i < length; i++) {
        j = i;
        target = a[i];
        while (j > 0 && target < a[j - 1]) {
            a[j] = a[j - 1];
            j--;
        }
        
        a[j] = target;
    }
}

int main(int argc, const char * argv[]) {
    
    int a[] = {4, 2, 6, 1, 8, 3};
    insertSort(a, 6);
    for (int i = 0; i < 6; i++) {
        printf("%d\t", a[i]);
    }
    
    return 0;
}

四、归并排序

1. 基本思想：

将一个数组分解成多个数组，依次对每个子数组进行排序，最终将排序完成的子数组合并，进行最终的排序。



2. 代码清单:

void merge(int a[], int p, int q, int r) {
    int i, j, k, n1, n2;
    // 变量用于申请两个内存空间
    int *front, *back;
    // 前一部分长度
    n1 = q - p + 1;
    // 后一部分长度
    n2 = r - q;
    // 申请两个空间存放拍好的数组
    front = (int *)malloc(n1 * sizeof(int));
    back = (int *)malloc(n2 * sizeof(int));
    // 将数组转入两个新空间中
    for (int i = 0; i < n1; i++) {
        front[i] = a[p + i];
    }
    for (int i = 0; i < n2; i++) {
        back[i] = a[q + i + 1];
    }
    
    // 将元素合并
    i = 0; j = 0; k = p;
    while (i < n1 && j < n2) {
        if (front[i] < back[j]) {
            a[k++] = front[i++];
        } else {
            a[k++] = back[j++];
        }
    }
    
    // 将剩余元素合并
    while (i < n1) {
        a[k++] = front[i++];
    }
    while (j < n2) {
        a[k++] = back[j++];
    }
}

void marge_sort(int a[], int p, int r) {
    int q;
    if (p < r) {
        q = (p + r) / 2;
        marge_sort(a, p, q);
        marge_sort(a, q + 1, r);
        merge(a, p, q, r);
    }
}

int main(int argc, const char * argv[]) {
    
    int a[8] = {1, 6, 4, 5, 3, 9, 7, 8};
    
    marge_sort(a, 0, 7);
    
    for (int i = 0; i < 8; i++) {
        printf("%d\t", a[i]);
    }
    
    return 0;
}

五、快速排序

1. 基本思想：

假设用户输入了如下数组：

下标	0	1	2	3	4	5
数据	6	2	7	3	8	9

创建变量i=0（指向第一个数据）, j=5(指向最后一个数据), k=6(赋值为第一个数据的值)。

我们要把所有比k小的数移动到k的左面，所以我们可以开始寻找比6小的数，从j开始，从右往左找，不断递减变量j的值，我们找到第一个下标3的数据比6小，于是把数据3移到下标0的位置，把下标0的数据6移到下标3，完成第一次比较：

下标	0	1	2	3	4	5
数据	3	2	7	6	8	9

i=0 j=3 k=6

接着，开始第二次比较，这次要变成找比k大的了，而且要从前往后找了。递加变量i，发现下标2的数据是第一个比k大的，于是用下标2的数据7和j指向的下标3的数据的6做交换，数据状态变成下表：

下标	0	1	2	3	4	5
数据	3	2	6	7	8	9

i=2 j=3 k=6

称上面两次比较为一个循环。

接着，再递减变量j，不断重复进行上面的循环比较。

在本例中，我们进行一次循环，就发现i和j“碰头”了：他们都指向了下标2。于是，第一遍比较结束。得到结果如下，凡是k(=6)左边的数都比它小，凡是k右边的数都比它大：

下标	0	1	2	3	4	5
数据	3	2	6	7	8	9

如果i和j没有碰头的话，就递加i找大的，还没有，就再递减j找小的，如此反复，不断循环。注意判断和寻找是同时进行的。

然后，对k两边的数据，再分组分别进行上述的过程，直到不能再分组为止。
2. 代码清单：

void sort(int *a, int left, int right) {
    // 表示一组排序结束
    if (left > right) {
        return;
    }
    int i = left; int j = right; int key = a[left];
    while (i < j) {
        // 找到比key小的值，交换位置(放在左边)
        while (i < j && key <= a[j]) {
            j--;
        }
        a[i] = a[j];
        
        // 找到比key大的值，交换位置(放在右边)
        while (i < j && key >= a[i]) {
            i++;
        }
        a[j] = a[i];
    }
    
    a[i] = key;
    // 递归执行
    sort(a, left, i - 1);
    sort(a, i + 1, right);
}

int main(int argc, const char * argv[]) {
    
    int a[] = {3, 5, 8, 1, 0, 2};
    sort(a, 0, 5);
    for (int i = 0; i < 6; i++) {
        printf("%d\t", a[i]);
    }
    
    return 0;
}