数据结构 排序算法

排序分为内部排序和外部排序，内部排序指待排序的记录在内存中，外部排序的记录数量很大，以至于内存放不下而放在外存中，排序过程需要访问外存。这里仅介绍内部排序，包括插入排序、交换排序、选择排序、归并排序、基数排序。

1 插入排序

1.1直接插入（straight insertion sort）

算法思路：数组｛k1,k2,……，kn｝，排序一开始k1是一个有序序列，让k2插入得到一个表长为2的有序序列，依此类推，最后让kn插入上述表长为n－1的有序序列，得到表长为n的有序序列。

c实现的代码：

//    从小到大排序

        int a[]={98,97,34,345,33};

        int k=sizeof(a)/sizeof(a[0]);

        int j;

        for (int i=1; i<k; i++) {

            int temp=a[i];

            for (j=i-1; j>=0&&a[j]>temp; j--) {

                a[j+1]=a[j];

            }

            a[j+1]=temp;

        }

1.2折半插入（binary insertion sort）

算法思路：当直接插入进行到某一趟时，对于r［i］来讲，前面i－1个记录已经按关键字有序。此时不用直接插入排序的方法，而改为折半查找，找出r［i］应插入的位置。

c实现的代码：

    //    从小到大排序

    void binasort(int r[100],int n){

        for (int i=1; i<n; i++) {

            int temp =r[i];

            int low=0;

            int high=i-1;

            while (low<=high) {

                int middle=(low+high)/2;

                if (temp<r[middle]) {

                    high=middle-1;

                }else{

                    low=middle+1;

                }

            }

            for (int j=i-1; j>=low; j--) {

                r[j+1]=r[j];

            }

            r[low]=temp;

        }

    }

1.3希尔排序（shell sort）

算法思路：“缩小增量”的排序方法，初期选用增量较大间隔比较，然后增量缩小，最后为1，希尔排序对增量序列没有严格规定。设有组关键字｛99，22，33，333，2，3，23，44｝，由小到大排序，这里n＝8，先第一个个增量取d1=4，那么记录分为4组，第一组 r［0］，r［4］，第二组r［1］，r［5］，……在各组内部使用插入排序，使得每组内是有序的，接着取d2=2，分为两组，d3=1,最后就编程有序序列。

c语言实现的代码：

    //    从小到大排序

    void shellsort(int r[100],int n){

        int k=n/2;

        while (k>0) {

            for (int i=k; i<n; i++) {

                int temp=r[i];

                int j=i-k;

                while ((r[j]>temp)&&(j>=0)) {

                    r[j+k]=r[j];

                    j=j-k;

                }

                r[j+k]=temp;

            }

            k/=2;

        }

    }

2 交换排序

2.1冒泡排序（bubble sort）

算法思路：在排序过程，关键字较小的记录经过与其他记录的对比交换，好像水中的气泡一样，移到数据序列的最前面。

c语言实现的代码：

    //    从小到大排序

    void bubblesort(int r[100],int n){

        for (int i=0; i<n-1; i++) {

            for (int j=0; j<n-1-i; j++) {

                if (r[j]>r[j+1]) {

                    int temp=r[j];

                    r[j]=r[j+1];

                    r[j+1]=temp;

                }

            }

        }

    }

2.2快速排序(quick sort)

算法思路：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。整个排序过程可以递归实现，也可以非递归实现。

c语言实现递归的快速排序的代码：

    //    从小到大排序

    void quickSort(int a[],int numsize){

        int i=0,j=numsize-1;

        int val=a[0];//指定参考值val大小

        if (numsize>1) { //确保数组长度至少为2，否则无需排序

            while (i<j) {//循环结束条件

    //            从后向前搜索比val小的元素，找到后填到a［i］中并跳出循环

                for (; j>i; j--) {

                    if (a[j]<val) {

                        a[i]=a[j];

                        break;

                    }

                }

    //            从前向后搜索比val大的元素，找到后填到a［j］中并跳出循环

                for (; i<j; i++) {

                    if (a[i]>val) {

                        a[j]=a[i];

                        break;

                    }

                }

            }

            a[i]=val;//将保存再val中的数放到a［i］中

            quickSort(a, i);//递归，对前i个数排序

            quickSort(a+i+1, numsize-1-i);//对i＋1到numsize－1-i个数排序

        }

    }

3 选择排序

3.1 简单选择排序（simple selection sort）

算法思路：对于一组关键字｛k1，k2，……kn｝，将其从小到大排序，首先从k1，k2，……k3中选择最小值Kz，在将Kz与k1对换；然后从k2……Kn中选最小值Kz，与k2交换。如此选择和调换n－2趟，第n－1趟只要调换Kn-1 和Kn比较就好了。

c语言实现的代码：

    //从小到大排序

    void sisort(int r[100],int n){

        for (int i=0; i<n-1; i++) {

            int z=i;

            for (int j=i+1; j<n; j++) {

                if (r[z]>r[j]) {

                    z=j;

                }

            }

            if (z!=i) {

                int temp=r[i];

                r[i]=r[z];

                r[z]=temp;

            }

        }

    }

3.2堆排序（heap sort）

算法思路：堆有两个性质，一是堆中某个节点的值总是不大于或不小于其父节点的值，二是堆是一棵完全树。以从大到小排序为例，首先要把得到的数组构建为一个最小堆，这样父节点均是大于或者等于子结点，根节点就是最小值，然后让根节点与尾节点交换，这样一次之后，再把前n－1个元素构建出最小根堆，让根结点与第n－2个元素交换，依此类推，得到降序序列。

c语言实现代码：

    //从大到小排序

    //以i节点为根，调整为堆的算法，m是节点总数，i节点的子结点为i*2+1,i*2+2

    void heapMin(int r[100],int i,int m){

    //    temp保存根节点，j为左孩子编号

        int j,temp;

        temp=r[i];

        j=2*i+1;

        while (j<m) {

            if (j+1<m && r[j+1]<r[j]) {//在左右孩子中找最小的

                j++;

            }

            if (r[j]>=temp) {

                break;

            }

            r[i]=r[j];

            i=j;

            j=2*i+1;

        }

        r[i]=temp;

    }

    void heapSort(int r[100],int n){

    //   n/2-1最后一个非叶子节点

    //   下面这个操作是建立最小堆

        for (int i=n/2-1; i>=0; i--) {

            heapMin(r, i, n);

        }

    //   一下for语句为输出堆顶元素，调整堆操作

        for (int j=n-1; j>=1; j--) {

    //   堆顶与堆尾交换

            int temp=r[0];

            r[0]=r[j];

            r[j]=temp;

            heapMin(r, 0, j);

        }

    //得到的就是降序序列

        for (int i=0; i<n; i++) {

            printf(" %d",r[i]);

        }

    }

4 归并排序（merge sort）

4.1两路归并排序

算法思路：它指的是将两个顺序序列合并成一个顺序序列的方法。如有数列｛6，202，100，301，38，8，1｝，第一次归并后变成了｛6，202｝，｛100，301｝，｛8，38｝，｛1｝；第二次归并后，｛6，100，202，301｝，｛1，8，38｝；第三次归并后｛1，6，8，38，100，202，301｝。

5 基数排序（radix sort）

算法思路：

基数排序可以采用LSD（Least significant digital）或者MSD（Most significant digital），LSD的排序由键值的最右边开始，MSD从最左边开始。

以LSD为例，假设原来有一串数值如下所示：

73, 22, 93, 43, 55, 14, 28, 65, 39, 81

第一步

首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：

0

1 81

2 22

3 73 93 43

4 14

5 55 65

6

7

8 28

9 39

第二步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

81, 22, 73, 93, 43, 14, 55, 65, 28, 39

接着再进行一次分配，这次是根据十位数来分配：

0

1 14

2 22 28

3 39

4 43

5 55

6 65

7 73

8 81

9 93

第三步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

14, 22, 28, 39, 43, 55, 65, 73, 81, 93

这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。

LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。