常见的排序

一、排序的含义

将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。在一些官方商店排序是最常见的操作，类如淘宝点击按销量，就会按销量降序排列，排序的应用场景有很多​

二、常见排序

再写排序之前，先写一个交换函数，用于后面的排序使用，再写一个打印函数，用于调试

void Swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

1、插入排序

void InsertSort(int *a, int n)
{
  
    for (int i = 0; i < n - 1; i++)//控制比较次数
    {
        int end = i;
        int temp = a[end + 1];
        while (end >= 0)
        {
            if (temp > a[end])//依次比较
            {
                a[end + 1] = a[end];
                --end;
            }
            else
            {
                break;
            }
        }
        a[end + 1] = temp;
    }
}

2、冒泡排序

void BubbleSort(int *a, int n)
{
    for (int i = 0; i < n - 1; i++)//外面控制比较次数
    {
        for (int j = 0; j < n - i - 1; j++)//里面控制比较数值
        {
            if (a[j] < a[j + 1])
            {

                Swap(&a[j], &a[j + 1]);
            }
        }
    }
}

3、希尔排序

void ShellSort(int *a, int n)
{
     int gap = n;//gap用于控制排序间距
    while (gap > 1)
    {
        gap = gap / 3 + 1;//不断除以一个规律数据来减小间距，直到1就说明排序完成
        for (int i = 0; i < n - gap; i++)
        {
            int end = i;
            int temp = a[end + gap];//每次排序都是gap距离排序，最后到1时基本上有序
            while (end >= 0)
            {
                if (temp > a[end])//控制升降序
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else
                {
                    break;
                }
            }
            a[end + gap] = temp;
        }
    }
    }
}

4、选择排序

void SelectSort(int *a, int n)
{
    int begin = 0, end = n - 1;
    while (begin < end)
    {
        int max = begin, min = begin;//用于记录最大最小值，最大值在右边最小值在左边（升序)
        for (int i = begin + 1; i <= end; i++)//用begin做初始值就是不改变已经排好序的值
        {
            if (a[max] < a[i])
            {
                max = i;
            }
            if (a[min] > a[i])
            {
                min = i;
            }
        }
        Swap(&a[min], &a[begin]);
        if (max == begin)//这里使用一个判断是可能min和max同时发生改变，导致max被修改
        {
            max = min;
        }
        Swap(&a[max], &a[end]);
        begin++;
        end--;
    }
}

5、快排

快排是效率最快的排序之一，时间复杂度可以达到n*logn，有许多的应用场景，虽然效率快，但是也比较复杂，难理解，版本有很多，首先是开创者，霍尔版本。

int PartSort1(int *a, int begin, int end)
{
   // int midi = GetMidi(a, begin, end);
   // Swap(&a[begin], &a[midi]);
    int left = begin, right = end;
    int keyi = begin;
    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]);

    return left;
}

然后就是挖坑法

int PartSort2(int *a, int left, int right)
{
    int midi = GetMidi(a, left, right);
    Swap(&a[midi], &a[left]);
    int keyi = a[left];
    int hole = left;
    while (left < right)
    {
        while (left < right && a[right] >= keyi)
        {
            right--;
        }
        a[hole] = a[right];
        hole = right;
        while (left < right && a[left] <= keyi)
        {
            left++;
        }
        a[hole] = a[left];
        hole = left;
    }
    a[hole] = keyi;
    return hole;
}

在就是前后指针版本

int PartSort3(int *a, int left, int right)
{
    int midi = GetMidi(a, left, right);
    Swap(&a[left], &a[midi]);
    int keyi = left;
    int cur = left + 1;
    int prev = left;
    while (cur <= right)
    {
        if (a[cur] < a[keyi] && ++prev != cur)
            Swap(&a[prev], &a[cur]);

        cur++;
    }
    Swap(&a[keyi], &a[prev]);
    keyi = prev;
    return keyi;
}

调用三个版本进行切换 

void QuickSort(int *a, int left, int right)
{
    if (left >= right)
    {
        return;
    }
    int keyi = PartSort3(a, left, right);
    QuickSort(a, left, keyi - 1);
    QuickSort(a, keyi + 1, right);
}

尽管快排已经够快了，但是还可以提高一点，使用三数取中，意思就是从中间两边找出一个平均值，使得两边数据大小较有序一点。

6、归并排序

归并排序，先开辟一个数组大小的空间，就和二叉树中后序遍历一样递归，将数组内的元素分开，先是一个一组，比较大小拷贝到这个临时空间中，到最后两个、四个、八个……，到最后有序，在使用memcpy拷贝函数，注意这里拷贝的位置，+一个begin位置，而不是0，因为是递归函数，begin不一定是0开始位置。

void _MergeSort(int *a, int begin, int end, int *temp)
{
    if (begin >= end)
        return;
    int midi = (begin + end) / 2;
    _MergeSort(a, begin, midi, temp);
    _MergeSort(a, midi + 1, end, temp);
    int begin1 = begin, end1 = midi;
    int begin2 = midi + 1, end2 = end;
    int i = begin;
    while (begin1 <= end1 && begin2 <= end2)
    {
        if (a[begin1] > a[begin2])
        {
            temp[i++] = a[begin2++];
        }
        else
        {
            temp[i++] = a[begin1++];
        }
    }
    while (begin1 <= end1)
    {
        temp[i++] = a[begin1++];
    }
    while (begin2 <= end2)
    {
        temp[i++] = a[begin2++];
    }
    memcpy(a + begin, temp + begin, sizeof(int) * (end - begin + 1));
}   
void MergeSort(int *a, int n)
{
    int *temp = (int *)malloc(sizeof(int) * n);
    if (temp == NULL)
        return;
    _MergeSort(a, 0, n - 1, temp);//封装一个函数，用于递归调用
    free(temp);
}

三、总结

1. ‌插入排序‌：通过构建有序序列，逐步扩展已有序列的长度直至所有元素插入完毕。适用于数据规模较小的情况，时间复杂度为O(n^2)。

2. ‌选择排序‌：通过选择的方式，每次从未排序的元素中选择最小（或最大）的元素，与未排序序列的第一个元素交换位置，直到所有元素都排好序。时间复杂度为O(n^2)。

3. ‌冒泡排序‌：通过重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。适用于数据规模较小的情况，时间复杂度为O(n^2)。

4. ‌归并排序‌：采用分治的思想，将一个大序列分成两个小序列，对这两个小序列分别进行排序，然后将两个有序序列合并成一个有序序列。时间复杂度为O(nlogn)。

5. ‌快速排序‌：通过选择一个“基准”元素，将待排序序列分成两个子序列，一个包含比基准小的元素，另一个包含比基准大的元素，然后递归地对这两个子序列进行快速排序。时间复杂度平均为O(nlogn)。

6. ‌计数排序‌：假设输入是一组在某个小范围内的整数，我们可以利用“桶”的概念进行排序。适用于数据规模较小且数据范围有限的情况，时间复杂度为O(n+k)，其中k是整数的范围。

7. ‌基数排序‌：属于“分配式排序”算法的一种，将整数按位数切割成不同的数字，然后按每个位数分别比较。适用于数据规模较大且数据范围有限的情况，时间复杂度为O(d*(n+k))，其中d是数字的最大位数，k是数字的范围。