序列排序总结之比较排序算法

这里我们着重讲解插入排序，归并排序，快速排序，堆排序

---

插入排序

基本思路是 将无序集合的元素插入到有序集合中，每次插入元素的时候保持有序集合的有序性。
步骤：

1. 默认单个元素的集合是有序
2. 选择无序集合中的一个元素
3. 在有序集合中寻找适当的位置
4. 将选择出的元素插入到适当的位置
5. 迭代执行步骤2-4的内容，直到无序集合为空

#include <stdlib.h>
#include <stdio.h>

void
OutArray(int * a, int len) 
{
    int i;
    for (i=0; i<len; ++i) {
        printf("%d ", a[i]);
    }
    putchar('\n');
}

int
main(int argc, char ** argv)
{
    int a[] = {2, 3, 6, 8, 1, 0, 9, 4, 5, 7};
    int len = sizeof(a) / sizeof(int);
    int i;
    int j;
    int tmp;

    OutArray(a, len);

    // 默认一个元素的时候是有序的， 所以只需要处理len-1个元素
    for (i=1; i<len; ++i) {
        tmp = a[i]; // 1. 临时存储需要处理的元素值

        // 2. 寻找合适的位置用于插入元素值
        for (j=i-1; j>=0; --j) {
            if (a[j] > tmp) {
                a[j+1] = a[j];
            } else {
                break;
            }
        }

        // 3. 插入元素值
        a[j+1] = tmp;
    }

    OutArray(a, len);


    exit(0);
}

---

归并排序

这个排序算法的基本思路是让两个有序的序列组合成一个有序的序列，这种方法使用了分治法的思想
步骤：
1. 将无序序列分成两个等分的无序序列
2. 将这两个无序序列分别排序成有序序列
3. 组合这两个无序序列，形成一个有序序列

其中
1. 单个元素是认为是有序的
2. 上述步骤2使用的方式是任选的，这里我们依然使用上述步骤过程（这就是递归的所在）

#include <stdlib.h>
#include <stdio.h>

void
OutArray(int * a, int len) 
{
    int i;
    for (i=0; i<len; ++i) {
        printf("%d ", a[i]);
    }
    putchar('\n');
}

void
MergerSort(int * a, int p, int q)
{
    if (q - p <= 1) return ;    // 当只有一个元素的时候，默认是已经排序好的

    int m = (p+q) >> 1;
    MergerSort(a, p, m);  // 排序前半部分
    MergerSort(a, m, q);  // 排序后半部分

    int *   a_tmp = (int *)malloc(sizeof(int) * q);  // 使用辅助空间
    int i;
    int j;
    int k;

    for (i=p; i<q; ++i) {
        a_tmp[i] = a[i];
    }

    i = p;
    j = m;
    k = p;
    while (i < m && j < q) {
        if (a_tmp[i] < a_tmp[j]) {
            a[k++] = a_tmp[i++];
        } else {
            a[k++] = a_tmp[j++];
        }
    }
    while (i < m) {
        a[k++] = a_tmp[i++];
    }
    while (j < q) {
        a[k++] = a_tmp[j++];
    }

    free(a_tmp);
}

int
main(int argc, char ** argv)
{
    int a[] = {2, 3, 6, 8, 1, 0, 9, 4, 5, 7};
    int len = sizeof(a) / sizeof(int);
    int i;
    int j;
    int tmp;

    OutArray(a, len);

    MergerSort(a, 0, len);

    OutArray(a, len);


    exit(0);
}

---

快速排序

算法的核心思想是如何确定一个元素在序列中的位置

步骤：
1. 选择末位的元素（对于随机化的版本这一步骤有所不同）
2. 无序序列分成两部分，第一部分所有元素都小于末位的元素，第二部分所有的元素都大于末位元素，将末位元素插入到这两部分之间（这个位置就是这个元素在这个序列中的有序位置）
3. 对第一部分和第二部分递归使用此方法

#include <stdlib.h>
#include <stdio.h>

void
OutArray(int * a, int len) 
{
    int i;
    for (i=0; i<len; ++i) {
        printf("%d ", a[i]);
    }
    putchar('\n');
}

void
QSort(int * a, int p, int q)
{
    if (p+1 >= q) return;

    int d = q-1;
    int i;  
    int j;
    int tmp;

    j = p;
    for (i=p; i<q-1; ++i) {
        if (a[i] < a[d]) {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
            ++j;
        } 
    }

    tmp = a[j];
    a[j] = a[d];
    a[d] = tmp;

    QSort(a, p, j);
    QSort(a, j+1, q);
}

int
main(int argc, char ** argv)
{
    int a[] = {2, 3, 6, 8, 1, 0, 9, 4, 5, 7};
    int len = sizeof(a) / sizeof(int);
    int i;
    int j;
    int tmp;

    OutArray(a, len);

    QSort(a, 0, len);

    OutArray(a, len);


    exit(0);
}

---