《大话数据结构》——排序

常用的排序算法

一.基本概率与分类

1. 排序的稳定性
   ri = rj，在排序前ri领先于rj，如果排序后ri仍然领先于rj，则称为所用的排序算法是稳定的；反之，若可能使得排序后rj领先于ri，则称为该排序算法是不稳定的。
2. 内排序和外排序
   内排序：排序的整个过程中，待排序的所有记录全部存放在内存中。常见的内排序算法有：冒泡排序、简单选择排序、直接插入排序、希尔排序、归并排序、堆排序、快排等。
   外排序：排序的记录数太多，不能同时放置在内存中，整个排序过程需要内外存多次交换数据才能进行。

二.代码实现

1 冒泡排序
冒泡排序是一种比较简单的排序算法。较小的数字如同气泡一样慢慢浮到上面，因此命名为冒泡算法。以下实现为冒泡排序的一种优化版，若后续序列已经有序，则就不需要再继续循环判断了

void BubbleSort(int a[], int n)
{
    bool flag = true;
    for (int i = 0; i < n - 1 && flag; i++)
    {
        flag = false;
        for (int j = n - 1; j > i; j--)
        {
            if (a[j] < a[j - 1])
            {
                swap(a, j, j - 1);
                flag = true;
            }
        }
    }
}

2 简单选择排序
选择排序的基本思想是每一趟在n-i+1个记录中选择最小的记录，作为有序序列的第i个记录，并和原先第i个记录交换

void SelectSort(int a[], int n)
{
    int min;
    for (int i = 0; i < n -1; i++)
    {
        min = i;
        for (int j = i + 1; j < n; j++)
        {
            if (a[j] < a[min])
                min = j;
        }

        if (i != min)
            swap(a, i, min);
    }
}

3 直接插入排序
直接插入排序的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的有序表。类似于抓扑克牌。右手抓牌，左手是已经排好序的牌：

void InsertSort(int a[], int n)
{
    int get;//右手拿到的牌
    int j;  //左手已经排序好的牌
    for (int i = 1; i < n; i++)//第一张牌不需要排序
    {
        get = a[i];//拿到的第i张牌
        j = i - 1; //已经排好序的右下标
        while (j > 0 && a[j] > get)
        {
            a[j+1] = a[j];//手牌比抓到的牌大，则右移
            j --;
        }
        a[j + 1] = get;//将拿到的牌，插入进去
    }
}

4 希尔排序
前面几种排序算法的复杂度基本上都是O(n²)，shell排序是突破这个时间复杂度的第一批算法之一。shell排序是基于直接插入排序的一种改进版本，它的基本思想是：对于n个待排序的数列，取一个小于n的整数increment（称为步长)将待排序元素分成若干个组子序列，所有距离为increment的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。然后减小increment的值，并重复执行上述的分组和排序。重复这样的操作，当increment=1时，整个数列就是有序的。

void ShellSort(int a[], int n)
{
    int increment = n;//增量
    int get,j;
    while (increment > 1){//增量为1时停止
        increment = increment / 3 + 1;//公式
        for (int i = increment; i < n; i++)
        {
            get = a[i];
            j = i - increment;//步长为increment
            while (j >= 0 && a[j] > get)
            {
                a[j + increment] = a[j];
                j -= increment;
            }
            a[j + increment] = get;
        }
    } 
}

5 堆排序
堆是完全二叉树的一种，其每个结点的值都大于等于左右孩子结点的值（大顶堆，反之为小顶堆），而堆排序就是利用堆进行排序的方法。基本思想是：将待排序列构造成一个大顶堆，堆顶的值就是最大值，将其与末尾元素互换，然后将剩余的序列重新构造成一个堆，如此反复就能得到一个有序序列。

void Heapify(int a[], int i, int n)// 从a[i]向下进行堆调整
{
    int left = 2 * i + 1;           
    int right = 2 * i + 2;          
    int max = i;                   // 选出当前结点与其左右孩子三者之中的最大值
    if (left < n && a[left] > a[max])
        max = left;
    if (right < n && a[right] > a[max])
        max = right;
    if (max != i)                  //即孩子的值大
    {
        swap(a, i, max);           // 把当前结点和它的最大(直接)子节点进行交换
        Heapify(a, max, n);        // 递归调用，继续从当前结点向下进行堆调整
    }
}

void HeapSort(int a[], int n)
{
    for (int i = n / 2 - 1; i >= 0; i--) //建堆
        Heapify(a, i, n);

    while (n > 1) // 堆（无序区）元素个数大于1，未完成排序
    {
        // 将堆顶元素与堆的最后一个元素互换，并从堆中去掉最后一个元素
        // 此处交换操作很有可能把后面元素的稳定性打乱，所以堆排序是不稳定的排序算法
        swap(a, 0, --n);
        Heapify(a, 0, n);   // 从新的堆顶元素开始向下进行堆调整，时间复杂度O(logn)
    }
}

6 归并排序
利用归并的思想实现排序的方法。将长度为n的序列看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]个长度为2或者1的有序序列；然后再两两归并，…如此反复操作，直到得到一个长度为n的有序序列。

void Merge(int a[],int left,int mid,int right)
{
    int len = right - left + 1;//待排序序列长度
    int *temp = new int[len];//申请辅助空间o(n)
    int index = 0;
    int i = left;
    int j = mid + 1;
    while(i <= mid && j <= right)
    {
        temp[index++] = (a[i] <= a[j] ? a[i++] : a[j++]);//等号保持归并排序的稳定性
    }
    while (i <= mid)//剩余序列排序
    {
        temp[index++] = a[i++];
    }
    while (j <= right)//剩余序列排序
    {
        temp[index++] = a[j++];
    }

    for (int k = 0; k < len; k++)
    {
        a[left++] = temp[k];
    }
    delete temp;
}

void MSort_Recursion(int a[], int left, int right)//递归实现，自顶向下
{
    if (left == right)
    {
        return;
    }
    int mid = (left + right) / 2;
    MSort_Recursion(a, left, mid);
    MSort_Recursion(a, mid + 1, right);
    Merge(a,left,mid,right);
}

7 快排
快排的基本思想：通过一趟排序将待排记录分为两个部分，其中一部分记录的关键字比另外一部分记录的关键字小，然后分别对这两个部分继续进行排序，以达到整体有序的目的

int partition(int a[], int left, int right)
{
    int pivotkey = a[left];
    while (left < right)
    {
        while (left < right && a[right] >= pivotkey)
            right--;
        swap(a, left, right);
        while (left < right && a[left] <= pivotkey)
            left++;
        swap(a, left, right);
    }
    return left;
}

void QSort(int a[],int left,int right)
{
    int pivot;
    if (left < right)
    {
        pivot = partition(a, left, right);
        QSort(a, left, pivot - 1);
        QSort(a, pivot + 1, right);
    }
}

三.排序算法的选择

1 指标对比

（图片来自网上）
2 算法分类
简单算法：冒泡、简单选择、直接插入
改进算法：希尔、堆、归并、快排

3 对比分析
①从最好、最坏、平均情况分析：平均情况来看，三种改进算法要优于希尔排序，且远远胜过简单算法；从最好情况来看，冒泡和直接插入排序要更胜一筹；从最坏情况来看，堆和归并排序要优于快排以及其他简单算法；

②从空间复杂度分析：归并和快排有相应的空间要求，而堆排序只需要O(1);几种简单算法的要求均为O(1)

③从稳定性分析：归并排序独占鳌头；简单算法中冒泡以及直接插入排序也属于稳定算法

④从待排序列数量分析：待排序的个数n越小，采用简单算法越合适；反之，n越大，采用改进的排序算法越合适