1、算法外排序分类

 

              

2、冒泡排序

冒泡排序（Bubble Sort）属于交换排序，它的原理是：循环两两比较相邻的记录，如果反序则交换，直到没有反序的记录为止。

实现算法：

/**

 * 冒泡排序优化后的算法

 * 设置一个标记来标志一趟比较是否发生交换

 * 如果没有发生交换，则数组已经有序

 */

void bubbleSort(SqList *L){

    int i,j;    

    int flag = true;  // flag 用来作为标记

    for (i = 1; i < L->length && flag; i++) { 

  // 若flag为true 则说明数据交换过，否则没交换过(数组已经有序) 则停止循环

        flag = false;

        for (j = L->length - 1; j >= i; j--) {

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

                swap(L, j, j+1);

                flag = true;  // 如果有数据交换 flag为true

            }

        }

    }

}

3、简单选择排序

简单选择排序法(Simple Selection Sort)是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i(1<=i<=n)个记录交换。

原理是：每一次从无序数据组的数据元素中选出最小（或最大）的一个元素，存放在无序数组的开始位置，随着无序数组元素减少，有序组元素增加，直到全部待排序的数据元素完全排完。

/**

 * 简单选择排序算法

 */

void selectSort(SqList *L){

    int i, j, min;

    for (i = 1; i < L->length; i++) {

        min = i;    // 将当前下标定义为最小值下标

        for (j = i + 1; j <= L->length; j++) {

            if (L->r[min] > L->r[j])

                min = j;

        }

        

        if (i != min)  // 若min不等于 i 说明找到最小值， 交换

            swap(L, i, min);

    }

}

4、直接插入排序

直接插入排序(Straight Insertion Sort)的是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录增1的有序表。

原理：将一个记录插入到一个已经排序好的表中，得到一个记录增加1的有序表。并且它把当前元素大的记录都往后移动，用以腾出“自己”该插入的位置。当n-1趟插入完成后就是需要的有序序列。

/**

 *直接插入排序算法

 */

void InsertSort(SqList *L){

    int i, j;

    for (i = 2; i < L->length; i++) {        

        if (L->r[i] < L->r[i-1]) { // 需要将 L->r[i] 插入有序子表            

            L->r[0] = L->r[i]; // 设置哨兵

            for (j = i-1; L->r[j] > L->r[0]; j++)

                L->r[j+1] = L->r[i]; // 记录后移            

            L->r[j+1] = L->r[0]; // 插入到正确位置

        }

    }

}

5、希尔排序

希尔排序是对直接插入排序的改进排序算法。希尔排序又叫缩小增量排序。

原理：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。属于不稳定排序算法。

/**

 *  希尔排序算法

 */

void shellSort(SqList *L){    

    int i,j;

    

    int increment = L->length;  // 增量初始值等于排序记录

    

    do {

        increment = increment /3 +1;  // 增量序列

        

        for (i = increment + 1; i < L->length; i++) {

            

            if (L->r[i] < L->r[i-increment]) {  // 需要将 L->r[i] 插入有序增量子表

                

                L->r[0] = L->r[i];  // 用哨兵暂时存放 L->r[i]

                

                for (j = i - increment; i >0 && L->r[0] < L->r[j]; j -= increment)

                    L->r[j+increment] = L->r[j];  // 记录后移， 查找插入位置

                    

                L->r[j+increment] = L->r[0];  // 插入

            }

        }

    } while (increment > 1);  // 增量不大于 1 时停止循环

}

6、堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

算法过程描述

1、将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；

2、将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；

3、由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

 

堆排序是一种不稳定的排序方法。

 

/**

 * 已知 L->r[s..m] 中记录的关键字除L->r[s]之外均满足堆的定义

 * 该函数调整L->r[s] 的关键字，使L->r[s..m]成为一个大顶堆

 */

void HeadAdjust(SqList *L, int s, int m){

    int temp, j;

    temp = L->r[s];    

    for (j = 2 *s; j <= m; j *= 2) {  // 沿关键字较大的孩子结点向下筛选  这里循环的条件j从 2*s 开始是因为利用了二叉树的性质5：由于这颗是完全二叉树，当前节点序号是 s ，其左孩子的序号一定是 2s， 右孩子的序号一定是 2s+1，它们的孩子当然也是以 2 的位数序号增加，因此 j 变量才这样循环。        

        if (j < m && L->r[j] < L->r[j+1])  // 1. j < m 说明它不是最后一个节点  2. L->r[j] < L->r[j+1]) 说明左孩子小于右孩子

            j++;  // j 为关键字中较大的记录的下标        

        if (temp >= L->r[j])

            break;  // rc应插入在位置s上        

        L->r[s] = L->r[j];

        s = j;

    }    

    L->r[s] = temp;  // 插入

}

/**

 * 对顺序表L进行堆排序

 */

void HeapSort(SqList *L){

    int i;    

    for (i = L->length / 2; i>0; i--)   // 把L中的r构建成一个大顶堆

        HeadAdjust(L, i, L->length);    

    for (i = L->length; i > 1; i--) {

        swap(L, 1, i);  // 将堆顶记录和当前未经排序子序列的最后一个记录交换

        HeadAdjust(L, 1, i-1);  // 将L->r[1..i-1]重新调整为大顶堆

    }

}

7、归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

实现原理（递归实现）：

1、将序列平均分成两部分

2、分别对这两部分用递归来归并

3、将这两部分归并到一起

算法示例

#p.归并排序(递归实现)

/**

 * 将有序的 SR[i..m] 和 SR[m+1..n]归并为有序的 TR[i..n]

 */

void Merge(int SR[], int TR[], int i, int m, int n){

    

    int j, k, l;

    

    for (j = m+1, k = i; i <= m && j <= n; k++) { // 将SR中记录有小到大归并入TR

        

        if (SR[i] < SR[j])

            TR[k] = SR[i++];

        else

            TR[k] = SR[j++];

    }

    

    if (i <= m) {

        for (l=0; l <= m-i; l++)

            TR[k+l] = SR[i+l];  // 将剩余的SR[i..m]复制到TR

    }

    

    if (j <= n) {

        for (l=0; l <= n-j; l++)

            TR[k+l] = SR[j+l]; // 将剩余的SR[j..n]复制到TR

    }

}

 

/**

 *将SR[s..t]归并排序为TR1[s..t]

 */

void MSort(int SR[], int TR1[], int s, int t){

 

    int m;

    int TR2[MAXSIZE+1];

    

    if (s == t) {

        TR1[s] = SR[s];

    }else{

        m = (s+t)/2; // 将SR[s..t]平分为SR[s..m]和SR[m+1..t]

        MSort(SR, TR2, s, m);   // 递归将SR[s..m]归并为有序的TR2[s..m]

        MSort(SR, TR2, m+1, t); // 递归将SR[m+1..t]归并为有序的TR2[m+1..t]

        Merge(TR2, TR1, s, m, t); // 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]

    }

}

 

/**

 *  对顺序表L作归并排序

 */

void MergeSort(SqList *L){

    MSort(L->r, L->r, 1, L->length);

}

归并排序是一种比较占内存，但是效率高且稳定的算法。

 

 

8、快速排序

实现原理：

选取一个关键字，放到一个位置，使得它的左边的值都比它小，右边的值都比它大，这个关键字叫做枢轴（pivot)

然后分别对左边和右边进行排序。

#p快速排序

/**

 * 交换顺序表 L 中子表的记录，使轴记录到位，并返回其所在位置

 * 此时在它之前的记录均不大于它，在它之后的记录均不小于它

 */

int partition(SqList * L, int low, int high){    

    int pivotkey;

    pivotkey = L->r[low];  // 用子表的第一个记录作为枢轴记录    

    while (low < high) {  // 从表的两端交替地向中间扫描

        while (low < high && L->r[high] >= pivotkey)

            high --;

        swap(L, low, high);  // 将比枢轴小的记录交换到低端        

        while (low < high && L->r[low] <= pivotkey)

            high++;

        swap(L, low, high);  // 将比枢轴大的记录交换到高端

    }    

    return low;  // 返回枢轴所在位置

}

 

/**

 * 对顺序表 L 中的子序列 L->r[low..high] 作快速排序

 */

void QSort(SqList *L, int low, int high){    

    int pivot;

    if (low < high) {

        pivot = Partition(L, low, high);  // 将L->r[low..high]一分为二，算出枢轴值pivot

        QSort(L, low, pivot-1);  // 对 低子表递归排序

        QSort(L, pivot+1, high); // 对 高子表递归排序

    }

}

/**

 * 对顺序表 L 作快速排序

 */

void QuickSort(SqList *L){

    QSort(L, 1, L->length);

}

 

 

9、排序算法比较

              

10、排序算法总结

10.1 内部排序

1、排序的记录数量较少是，可以考虑插入排序和简短选择排序。如果记录本身信息量较大时，建议选用选择排序。

2、如果待排序记录按关键字基本有序，适合采用冒泡排序或直接插入排序

3、若 排序记录较大，可以选择快速排序、堆排序或归并排序。目前快速排序被认为最好的排序方法。

10.2 外部排序

外部排序就是针对大型文件的排序。常用的外部排序方法是归并排序。

 

IT技术分享社区

个人博客网站：https://programmerblog.xyz

文章推荐程序员效率：画流程图常用的工具程序员效率：整理常用的在线笔记软件远程办公：常用的远程协助软件，你都知道吗？51单片机程序下载、ISP及串口基础知识硬件：断路器、接触器、继电器基础知识