1. 排序的概念及运用

🐶 排序的概念：

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

排序的稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

😼 排序运用：

排序在生活中随处可见，比如，商品的价格排序，中国各大高校的排名，福布斯2022全球富豪榜等等。

🐹 常见的排序算法：

2. 常见排序算法的实现

2.1 插入排序

插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

2.1.1 直接插入排序

🐶 排序思想：

直接插入排序的基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。

插入排序.gif

直接插入排序时间复杂度为O(logN)的算法，它有着稳定和速度快的优点，缺点是比较次数越少，插入点后的数据移动就越多，特别是数据庞大的时候就需要大量的移动数据。

🐱 代码实现：

void InsertSort(int* a, int n)
{
   
   
    for (int i = 0; i < n - 1; i++) {
   
   
        int end = i;
        int tmp = a[end + 1];
        while (end >= 0)
        {
   
   
            if (a[end] > tmp)
            {
   
   
                a[end + 1] = a[end];
                end--;
            }
            else
            {
   
   
                break;
            }
        }
        a[end + 1] = tmp;
    }
}

2.1.2 希尔排序

🐶 排序思想：

希尔排序法又称缩小增量法。是直接插入排序的改进版本，先选定一个整数gap，将其值赋为数据量的个数，然后将数据分为以gap为间隔的组先进行预排序。

预排序的规则和直接插入排序很相似，只不过直接插入排序是每次将相邻的两个数据进行比较并插入，而希尔排序则是每次将下标为n和n+gap的两个数据进行比较并插入，每一趟比较完成之后，gap变为gap/2或者gap/3+1，直到gap=1循环结束。

当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序了。最后一趟经过gap==1的直接插入排序后，数组就成功变成了有序。

希尔排序的时间复杂度并不是很好计算，因此有许多不同的书籍给出的结论都有所差异，大约在O(n^1.25)~O(1.6*n^1.25) 之间。这里我们就折中一下记作O(n^1.3) 。

🐱 代码实现：

void ShellSort(int* a, int n)
{
   
   
    int gap = n;
    while (gap > 1)
    {
   
   
        gap = gap / 3 + 1;
        for (int i = 0; i < n - gap; i++)
        {
   
   
            int end = i;
            int tmp = a[end + gap];
            while (end >= 0)
            {
   
   
                if (a[end] > tmp)
                {
   
   
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else
                {
   
   
                    break;
                }
            }
            a[end + gap] = tmp;
        }
    }
}

2.2 选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

2.2.1 直接选择排序

🐶 排序思想：

直接选择排序思想是对每个下标i,从i后面的元素中选择最小的那个和s[i]交换。

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。这里我们每次都选择出一个最大值和最小值，每次将最大值与待排序的区间的最前面的位置交换，将最小值与待排序的区间的最后面的位置交换。

这里我们需要注意的是：如果已经将最小值和待排序区间最前面的位置交换后，发现最前面的位置和最大值的位置发生了冲突，需要特殊判断并处理一下。

选择排序.gif

直接选择排序的时间复杂度是O(N^2),它的思考非常好理解，但是效率不是很好。所以实际中很少使用。

🐱 代码实现：

void SelectSort(int* a, int n)
{
   
   
    int begin = 0, end = n - 1;
    while (begin < end)
    {
   
   
        int maxi = begin;
        int mini = begin;
        for (int i = begin+1; i <= end; i++)
        {
   
   
            if (a[i] < a[mini])
            {
   
   
                mini = i;
            }
            if (a[i] > a[maxi])
            {
   
   
                maxi = i;
            }
        }
        Swap(&a[mini], &a[begin]);
        if (begin == maxi)
             maxi = mini;
        Swap(&a[maxi], &a[end]);
        begin++;
        end--;
    }
}

2.2.2 堆排序

🐶 排序思想：

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

由于博主在之前的博客中已经详细介绍过了堆排序，所以在这里就不再仔细分析建堆的过程了，如果有需请参考：二叉树&&优先级队列——堆

这里我们简单来分析一下堆排序的思路，每次取堆顶数据和最后一个数据进行交换，然后再将除了最后一个元素外的所有元素进行向下调整使其再次成为一个堆。直到待调整的堆中的元素个数为0。

堆排序.gif

堆排序使用了堆来选数。效率高了很多，它的时间复杂度为O(N*logN)

🐱 代码实现：

//交换函数
void Swap(int* a, int* b)
{
   
   
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
//向下调整建大堆
void AjustDown(int* a, int parent, int n)
{
   
   
    int child = parent * 2 + 1;
    while (child < n)
    {
   
   
        if (child + 1 < n && a[child + 1] > a[child])
            child++;
        if (a[parent] < a[child])
        {
   
   
            Swap(&a[parent], &a[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
   
   
            break;
        }
    }
}
//堆排序
void HeapSort(int* a, int n)
{
   
   
    //先建堆
    for (int i = (n - 2) >> 1; i >= 0; i--)
    {
   
   
        AjustDown(a, i, n);
    }
    //堆排序
    int size = n - 1;
    while (size > 0)
    {
   
   
        Swap(&a[0], &a[size]);
        AjustDown(a, 0, size);
        size--;
    }
}

2.3 交换排序

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

2.3.1 冒泡排序

🐶 排序思想：

冒泡排序是交换排序中的一种简单的排序方法，他的思想是对所有相邻记录的关键值进行比较，如果是逆序（a[j]>a[j+1]）就将其交换，最终达到有序化。

每经一趟冒泡排序，都使无序区中关键值最大的记录进入有序区，对于由n个记录组成的记录序列，最多经过n-1趟冒泡排序，就可以将这n个记录重新按照关键字顺序排列。

冒泡排序.gif

在冒泡排序中，第1轮需要比较n-1次，第2轮需要比较n-2次……第n-1轮需要比较1次。因此，总的比较次数为（n-1）+（n-2）+…+1≈n2/2。所以冒泡排序的时间复杂度是O(n^2)。

🐱 代码实现：

void BubbleSort(int* a, int n)
{
   
   
    for (int i = 0; i < n-1; i++)
    {
   
   
        int flag = 0;
        for (int j = 0; j < n-i-1; j++)
        {
   
   
            if (a[j + 1] < a[j]) {
   
   
                Swap(&a[j + 1], &a[j]);
                flag = 1;
            }
        }
        if (flag == 0)
            break;
    }
}

2.3.1 快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

这里我们先来写一下非递归版本的整体代码框架，然后再来写单趟排序。

void QuickSort(int* a, int begin, int end)
{
   
   
    if (begin >= end)
        return;
    int keyi = PartSort1(a, begin, end);
    QuickSort(a, begin, keyi - 1);
    QuickSort(a, keyi + 1, end);
}

小区间优化

🐶 小区间优化：

如果数据量特别大的时候，那么快排的递归调用次数将会非常的多，为了解决这个问题，我们可以使用小区间优化的方式，就是如果发现待排序区间的元素个数<=10时，我们可以使用直接插入排序来进行排序。这样就可以减少很多次递归调用来提升程序的性能。

🐱 三数取中：

如果我们每次都取最左边的元素作为key值，如果要是待排序的数有序或者接近有序的时候，那么我们每次递归左区间的长度为0，右区间的长度为n-1，这样的话递归的深度就极有可能变为n。但如果要是数据量过大的话递归深度太深就容器造成栈溢出。这里使用一种三数取中的方法进行优化。

//三数取中的代码
int GetMidIndex(int* a, int begin, int end)
{
   
   
    int mid = (begin + end) >> 1;
    if (a[begin] < a[mid])//a[begin]<a[mid]
    {
   
   
        if (a[mid] < a[end])
            return mid;
        else if (a[end] < a[begin])
            return begin;
        else
            return end;
    }
    else//a[begin]>a[mid]
    {
   
   
        if (a[mid] > a[end])
            return mid;
        else if (a[end] > a[begin])
            return begin;
        else
            return end;
    }
}

//小区间优化
void QuickSort(int* a, int left, int right)
{
   
   

     if (right <= left)
      return;

     //小区间优化——当递归到元素个数小于等于10的区间时，为了提高效率直接使用插入排序
     if ((right - left) + 1 <= 10)  
     {
   
   
          InsertSort(a + left, right - left + 1);
     }
     else
     {
   
   
          int keyi = PartSort1(a, left, right);
          //递归左区间
          QuickSort(a, left, keyi - 1);
          //递归右区间
          QuickSort(a, keyi + 1, right);
     }
}

hoare版本

🐶 排序思想：

hoare版本的思想：取最左边的元素作为key，这里我们用a[keyi]表示，定义左指针和右指针分别指向待排序区间的左端点和右端点，然后右指针先走，找比key小的值，找到后左指针开始走，找比key大的值，找到后停下来，然后交换左右指针位置的值。

然后右指针继续往左走找小，左指针继续往右走找大，这个过程反复进行，当左指针的值小于右指针时，循环会一直进行，当左指针和右指针相遇时，循环结束，然后交换key和左右指针相遇的位置的值，自此，单趟排序结束，
然后将左右指针相遇的位置返回，分割出左右子区间，分别进行左右子区间的递归单趟过程。

快排hoare版本.gif

快速排序的最好的时间复杂度为O(NlogN)，最坏的时间复杂度为O(N^2)，平均时间复杂度为O(NlogN)，快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序。

🐱 代码实现：

int PartSort1(int *a,int begin,int end)//Hoare版本
{
   
   
    int mid = GetMidIndex(a, begin, end);
    Swap(&a[begin], &a[end]);
    int left = begin;
    int right = end;
    int keyi = left;
    while (left < right)
    {
   
   
        while (left < right && a[right] >= a[keyi])
        {
   
   
            right--;
        }
        while (left < right && a[left] <= a[keyi])
        {
   
   
            left++;
        }
        Swap(&a[left], &a[right]);
    }
    Swap(&a[left], &a[keyi]);
    keyi = left;
    return keyi;
}

挖坑法

🐶 思路：

挖坑法是快排的第二种写法，在这里我们需要注意的是：使用挖坑法时，必须多定义一个变量hole来记录坑的位置。同时，与hoare不同的是：挖坑法中直接使用key表示key值，而不是用下标的方法。

还是一样，取最左边的元素作为key，然后先定义坑hole的位置为left的位置，然后right先走，找到比key小的数后停下来，然后将a[right]填到坑里，也就是，a[hole] = a[right]，然后再将right位置变成新的坑，hole = right，然后左指针left开始向右边走找比key大的数，找到后，将a[right]填到坑里，a[hole] = a[right]，然后将left的位置变成新的坑，hole = left，和上面一样，只要left<right，循环此过程，当left和right相遇时，跳出循环，将key填到新的坑的位置（也就是left和right相遇的位置），最后返回坑hole的下标。

快排挖坑法.gif

🐱 代码实现：

//挖坑法
int PartSort2(int* a, int begin, int end)
{
   
   
    int mid = GetMidIndex(a, begin, end);
    Swap(&a[begin], &a[end]);
    int left = begin;
    int right = end;
    int key = a[left];
    int hole = left;
    while (left < right)
    {
   
   
        while (left < right && a[right] >= key)
        {
   
   
            right--;
        }
        a[hole] = a[right];
        hole = right;
        while (left < right && a[left] <= key)
        {
   
   
            left++;
        }
        a[hole] = a[left];
        hole = left;
    }
    a[hole] = key;
    return hole;
}

前后指针法

🐶 思路：

快排最后一种写法是前后指针法，这里我们需要定义三个变量：keyi = left、prev = left 和 cur = left+1。

其中的 keyi 代表 key 值所在的下标，而 prev 和 cur 。我们让 cur 先走，当找到小于 a[keyi] 的元素时停下来，然后先让 prev++，再判断 prev 是否等于 cur，如果不等于就交换二者对应元素的值，然后重复前面的步骤，直到 cur > right；最后交换 a[keyi] 和 a[prev] 。

快排前后指针法.gif

🐱 代码实现：

int PartSort3(int* a, int begin, int end)
{
   
   
    int mid = GetMidIndex(a, begin, end);
    Swap(&a[begin], &a[end]);
    int keyi = begin;
    int prev = begin, cur = begin + 1;
    while (cur <= end)
    {
   
   
        if (a[cur] < a[keyi] && ++prev != cur)
            Swap(&a[cur], &a[prev]);
        cur++;
    }
    Swap(&a[prev], &a[keyi]);
    keyi = prev;
    return keyi;
}

2.3.2 快排非递归

🐶 思路：

我们知道，任何一个算法只要它可以递归肯定是也可以进行非递归的，当我们把快排的递归版本写完后，接下来让我们看一下它的非递归版本：
这里我们需要借助一个栈来完成非递归的实现。

🐱 代码实现：

void QuickSortNonR(int* a, int begin, int end)
{
   
   
    ST st;
    StackInit(&st);
    StackPush(&st, begin);
    StackPush(&st, end);

    while (!StackEmpty(&st))
    {
   
   
        int right = StackTop(&st);
        StackPop(&st);
        int left = StackTop(&st);
        StackPop(&st);

        int keyi = PartSort3(a, left, right);
        // [left, keyi-1] keyi [keyi+1, right]
        if (keyi + 1 < right)
        {
   
   
            StackPush(&st, keyi + 1);
            StackPush(&st, right);
        }

        if (left < keyi - 1)
        {
   
   
            StackPush(&st, left);
            StackPush(&st, keyi - 1);
        }
    }
    StackDestroy(&st);
}

2.4 归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。例如将两个有序表合并成一个有序表，称为二路归并。

2.4.1 归并排序递归

🐶 排序思想：

归并排序中，我们先找到数组的中间下标mid，然后以这个mid为中心，对两边分别进行排序，之后我们再根据两边已排好序的子数组，重新开一块空间进行合并，合并完成后在将新的空间中已经排好的数据拷贝回原数组。当然我们需要借助递归的思想，不断分割左右区间并进行上面的操做，直到左右区间不能再分割了为止，然后就开始了归并并回退继续归并的操作。

归并排序.gif

归并排序无论在什么情况下的时间复杂度都是O(N*logN)，它的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

🐱 代码实现：

//归并排序子函数
void _MergeSort(int* a, int begin, int end, int* tmp)
{
   
   
    if (begin >= end)
        return;
    int mid = begin + end >> 1;
    //递归左右子区间
    _MergeSort(a, begin, mid, tmp);
    _MergeSort(a, mid + 1, end, tmp);

    //归并过程
    int begin1 = begin, end1 = mid;
    int begin2 = mid + 1, end2 = end;
    int i = begin;
    while (begin1 <= end1 && begin2 <= end2)
    {
   
   
        if (a[begin1] < a[begin2])
        {
   
   
            tmp[i++] = a[begin1++];
        }
        else
        {
   
   
            tmp[i++] = a[begin2++];
        }
    }
    while (begin1 <= end1) tmp[i++] = a[begin1++];
    while (begin2 <= end2) tmp[i++] = a[begin2++];
    memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
//归并排序
void MergeSort(int* a, int n)
{
   
   
    int* tmp = (int *)malloc(sizeof(int) * n);
    if (!tmp) {
   
   
        perror("malloc fail;;");
        exit(-1);
    }
    _MergeSort(a, 0, n - 1, tmp);
    free(tmp);
    tmp = NULL;
}

2.4.1 归并排序非递归

🐶 排序思想：

归并排序非递归的实现需要借助递归版本归并的逆过程，大概思路就是这样的：我们先让序列中的两个为一组的相邻的元素有序，也就是两两归并，然后四个四个归并，八个八个归并，最后直至所有的元素都有序为止，虽然这个思路听起来很容易但是代码却不是很好写，因为可能在两两归并，四四归并...的过程中左右区间可能会出现越界的情况，这就需要我们自己在写代码的过程中进行特判设置跳出循环或者修正区间来进行避免这种情况的发生。

🐱 代码实现：

void MergeSortNonR2(int* a, int n)
{
   
   
    int* tmp = (int*)malloc(sizeof(int) * n);
    if (!tmp) {
   
   
        perror("malloc fail::");
        exit(-1);
    }
    int rangeN = 1;
    // 归并每组数据个数，从1开始，因为1个认为是有序的，可以直接归并
    while (rangeN < n)
    {
   
   
        for (int i = 0; i < n; i += 2 * rangeN)
        {
   
   
            int begin1 = i, end1 = i + rangeN - 1;
            int begin2 = i + rangeN, end2 = i + 2 * rangeN - 1;
            int j = i;
            //区间越界直接跳出循环
            if (end1 >= n)
                break;
            else if (begin2 >= n)
                break;
            else if (end2 >= n)
                end2 = n - 1;
            printf("[%d,%d][%d,%d]\n", begin1, end1, begin2, end2);
            while (begin1 <= end1 && begin2 <= end2)
            {
   
   
                if (a[begin1] < a[begin2])
                {
   
   
                    tmp[j++] = a[begin1++];
                }
                else
                {
   
   
                    tmp[j++] = a[begin2++];
                }
            }
            while (begin1 <= end1) tmp[j++] = a[begin1++];
            while (begin2 <= end2) tmp[j++] = a[begin2++];
            memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
        }
        rangeN *= 2;
    }
    free(tmp);
    tmp = NULL;
}

2.5 非比较排序

计数排序

计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。操作步骤：

1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中

🐶 排序思想：

开一个额外的数组来统计原来数组中每个数字出现的次数，新开的数组的下标使用原数组的值，遍历原数组，数组中每个元素出现了几次，就在对应下标的位置++。

遍历原来的数组，当原数组遍历一遍后就将元素组中每个数字出现的次数一一映射到了新开的数组中。

遍历新数组，找出其中元素值大于0的元素，将其对应的索引作为元素值填充到原数组中去，每处理一次，新数组中的该元素值减1，直到该元素值不大于0，依次处理新数组中剩下的元素。最后将新开辟的数组释放掉即可。

这里我们可以优化一下使用相对位置作为映射的方式，这样可以相对节省空间，先遍历一边数组，然后找到最大值和最小值，开辟空间的大小为最大-最小+1的空间。计数的时候用该元素-最小值作为映射的下标，第二次排序的时候下标+最小值就是原来数组中的元素。

计数排序的时间复杂度为O(MAX(N,范围))，计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。仅仅适用于整形数据的排列。

🐱 代码实现：

void CountSort(int* a, int n)
{
   
   
    int max = a[0];
    int min = a[0];
    for (int i = 0; i < n; i++)
    {
   
   
        if (a[i] > max)
            max = a[i];
        if (a[i] < min)
            min = a[i];
    }
    int* count = (int*)calloc(max - min + 1, sizeof(int));
    if (!count)
    {
   
   
        perror("calloc fail::");
        exit(-1);
    }
    for (int i = 0; i < n; i++)
        count[a[i] - min]++;
    int index = 0;
    for (int i = 0; i < max-min+1; i++)
    {
   
   
        while (count[i]--)
        {
   
   
            a[index++] = i + min;
        }
    }
}

【数据结构】排序算法大总结

1. 排序的概念及运用

2. 常见排序算法的实现

2.1 插入排序

2.1.1 直接插入排序

2.1.2 希尔排序

2.2 选择排序

2.2.1 直接选择排序

2.2.2 堆排序

2.3 交换排序

2.3.1 冒泡排序

2.3.1 快速排序

小区间优化

hoare版本

挖坑法

前后指针法

2.3.2 快排非递归

2.4 归并排序

2.4.1 归并排序递归

2.4.1 归并排序非递归

2.5 非比较排序

计数排序

3. 排序算法复杂度及稳定性分析

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【数据结构】排序算法大总结

1. 排序的概念及运用

2. 常见排序算法的实现

2.1 插入排序

2.1.1 直接插入排序

2.1.2 希尔排序

2.2 选择排序

2.2.1 直接选择排序

2.2.2 堆排序

2.3 交换排序

2.3.1 冒泡排序

2.3.1 快速排序

小区间优化

hoare版本

挖坑法

前后指针法

2.3.2 快排非递归

2.4 归并排序

2.4.1 归并排序递归

2.4.1 归并排序非递归

2.5 非比较排序

计数排序

3. 排序算法复杂度及稳定性分析

热门文章

最新文章

相关课程

相关电子书

相关实验场景