排序算法汇总

排序算法有挺多的，小白根据自己的理解和网上整理的

①冒泡排序法

冒泡排序法应该是第一个接触的，主要的逻辑就是将一串数，相邻的两两进行比较，然后大的数不断往后放，在第一遍的比较结束以后，最大的数就会到达最后，然后将除了最大的数前面的所有的数又重新比较，又得到前面最大的在倒数第二位，以此类推，最后变成从小到大的序列。（想得到从大到小的数列，可以将从小到大的逆序输出就可以）

冒泡排序的意思，也就是最大的数像泡泡一样，不断往上冒直至水面。

void sort(int x[])/*数组或者指针*/
{
    int i,j;
    int temp;
    for(i=0;i<N-1;i++)/*N为数组的元素总数，如果有N个元素就有N-1次的数调换*/
    {
        for(j=0;j<N-1-j;j++)/*每一次的调换，让最大的到最后*/
        {
            if(x[j]<x[j+1])
            {
                temp=*(x+j);
                *(x+j)=*(x+j+1);
                *(x+j+1)=temp;
            }
        }
    }
}

②选择排序法

选择排序法的逻辑就是将一组已知的数，进行遍历寻找，找到最大的数以后，再将最大的数放到最后或者开始，然后在剩下的数内继续寻找，接着再放置，以此类推，相比于冒泡排序法，调换的次数少了，所以相对的时间复杂度也小了，效率更高。

void sort(char *name[],int n)/*名字排序的函数，用了指针数组，n为字符串的个数*/
{
    char *temp;
    int i,j,k;
    for(i=0;i<n-1;i++)/*n个数需要选择n-1次，外层*/
    {
        k=i;/*保存首地址，首地址不断递增*/
        for(j=i+1;j<n;j++)/
        {
            if(strcmp(name[j],name[k])<0)
            {
                k=j;/*找最小的*/
            }
            if(k!=i)/*交换最小值于首地址*/
            {
                temp=name[i];
                name[i]=name[k];
                name[k]=temp;
            }
        }
    }
}

③插入排序法

插入排序法的意思是将一组已知数，第一次把第一个数当做一组数，第二次前两个数当成一组数，并排列，第三次把第三个数按相应的规律插入第二组数中，以此类推，将一个个数不断插入上次排好的数列中，最后得到一个有序的序列。

void sort(int a[], int n)/*数组，以及数组的长度n*/
{
    for (int i = 1; i < n; i++)/*定义i=1，防止后面数据出错*/
    {
        int j;
        if (a[i] < a[i - 1])/*将数从小到大排序，新增的数比前面小就往前走*/
        {
            int temp = a[i];/*用temp保存这个新增值*/
            for (j = i - 1; j >= 0 && temp < a[j]; j--)
            {
                a[j + 1] = a[j];/*将尾端的数逐个往上复制，当找到比它小的跳出*/
            }
            a[j + 1] = temp;/*将新增值插入这个地方，完成排序*/
        }
    }
}
④希尔排序

④希尔排序

希尔排序是对插入排序的升级，它是将待排序的数组元素 按下标的一定增量分组 ，分成多个子序列，然后对各个子序列进行直接插入排序算法排序；然后依次缩减增量再进行排序，直到增量为1时，进行最后一次直接插入排序，排序结束。

排序：希尔排序（算法） - 简书 (jianshu.com)

 

void shell_sort(int arr[], int len) {
        int gap, i, j;
        int temp;
        for (gap = len >> 1; gap > 0; gap >>= 1)
        {        for (i = gap; i < len; i++) 
                {
                        temp = arr[i];
                        for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
                                arr[j + gap] = arr[j];
                        arr[j + gap] = temp;
                }
        }
}

⑤快速排序法

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。

(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。

(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。（百度）

个人感觉就是类似于二分法的折半查找，将它不断二分然后排序

void Qsort(int arr[], int low, int high){
    if (high <= low) return;
    int i = low;
    int j = high + 1;
    int key = arr[low];
    while (true)
    {
        /*从左向右找比key大的值*/
        while (arr[++i] < key)
        {
            if (i == high){
                break;
            }
        }
        /*从右向左找比key小的值*/
        while (arr[--j] > key)
        {
            if (j == low){
                break;
            }
        }
        if (i >= j) break;
        /*交换i,j对应的值*/
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    /*中枢值与j对应值交换*/
    arr[low] = arr[j];
    arr[j] = key;
    Qsort(arr, low, j - 1);
    Qsort(arr, j + 1, high);
}