2022-08-29

十大经典排序算法
1.经典排序：时间复杂度O(N^2),空间复杂度：O(1)，稳定性:稳定

void classic_sort(int* arr,size_t len)
{
    for(int i = 0;iarr[j])
      swap(arr[i],arr[j]);
}
}
}

2.冒泡排序：最优时间复杂度：O(N),最差时间复杂度:O(N^2)，
平均时间复杂度:O(N^2),空间复杂度:O(1),稳定性：稳定

void bubble_sort(int* arr,size_t len)
{
    bool flag = true;
    for(int i=len-1;flag&&i>0;i--)
{
    flag = false;
    for(int j = 0;jarr[j+1])
{
    swap(arr[j],arr[j+1]);
    flag = true;
}
}
}
}

3.选择排序：时间复杂度O(N^2),时间复杂度：O(1)，稳定性：不稳定

void selsect_sort(int* arr,sieze_t len)
{
    for(int i =0;iarr[j])
        {
            min=j;
        }
      if(min != i)
      swap(arr[min],arr[j]);
    }
}
}

4.插入排序：
往有序的序列中添加新的数据，使序列继续保持有序，具体步骤是：假定新的数据存放在i=len位置，val与它前面的数据逐一进行比较val

// 时间复杂度：O(N^2)，空间复杂度：O(1)，稳定性：稳定
void insert_sort(int* arr,size_t len)
{
    for(int i=1; i=0 && arr[j-1]>tmp)
        {
            arr[j] = arr[j-1];
            j--;
        }
        arr[j] = tmp;
    }
}

5.、希尔排序：
设计该算法的作者叫希尔，所以叫希尔排序，它在插入排序的基础上引入了增量概念(数据在插入时，每次移动的距离)，插入排序默认一次只移动一个位置，当数据量比较大时，移动的速度比较慢，希尔排序先以数量的一半为移动增量，进行插入排序，对数据进行大致排序，然后再减小增量对数据进行微调，进而完成插入排序。

// 时间复杂度：O(NlogN)，空间复杂度：O(1)，稳定性：不稳定
void shell_sort(int* arr,size_t len)
{
    for(int k=len/2; k>0; k/=2)
    {
        for(int i=k; i=0 && arr[j-k]>tmp)
            {
                arr[j] = arr[j-k];
                j-=k;
            }
            arr[j] = tmp;
        }
    }
}

6.快速排序：
先在待排序的序列中找出一个标杆，然后与剩余的数据进行比较，比标杆小的数据放在标杆的左边，比标杆大的数据放在它右边，这样就做到以标杆为准的大致有序，然后再次同样的方法对标杆左边的数据进行排序、标杆右边的数据进行排序，直到整个序列完全有序。
注意：快速排序之所以叫快速排序，综合各种情况它的表示最好，速度最快，如果对待排序的数据不了解，建议优先选择快速排序。

// 时间复杂度：O(NlogN)，空间复杂度：O(1)，稳定性：不稳定
void _quick_sort(int* arr,int left,int right)
{123
    // 备份左右边界
    int l = left, r = right;
    // 把最左边的数据作为标杆，记录标杆下标
    int pv = arr[left], pi = left;

    while(l=pv) r--;
        // 找到比标杆小的数据
        if(l1)
        _quick_sort(arr,left,pi-1);
    // 快速排序标杆右边的数据
    if(right-pi>1)
        _quick_sort(arr,pi+1,right);
}
void quick_sort(int* arr,size_t len)
{
    _quick_sort(arr,0,len-1);
}

7.堆排序：
所谓堆排序就是把待排序的数据当作一个大根堆，然后逐步把堆顶的最大值弹出存储在序列的末尾，也就是借助大根堆这一数据结构完成的排序。

注意：理论上来说堆排序的速度不比快排序慢，但是对无序的序列排序需要先创建堆，时间复杂度是O(N)，然后再逐一出堆完成排序时间复杂度是O(NlogN)，所以对无序的序列排序快速排序比堆的速度要快，所以一般在实际应用中不使用堆排序，只活在教课书中。

// 时间复杂度：O(NlogN)，空间复杂度：O(1)，稳定性：不稳定
void _heap_sort(int* arr,int root,size_t len)
{
    while(root*2+1arr[max])
            max++;
        // 如果最大子树依然小于根，则结束
        if(arr[max] < arr[root])
            return;
        // 把最大子树与根交换
        swap(arr[max],arr[root]);
        root = max;
    }
}
void heap_sort(int* arr,size_t len)
{
    // 创建大根堆
    for(int i=len/2-1; i>=0; i--)
        _heap_sort(arr,i,len);

    for(int i=len-1; i>0; i--)
    {
        // 把堆的根与末尾的数据交换，数量减-1
        swap(arr[0],arr[i]);
        // 调整堆
        _heap_sort(arr,0,i);
    }
    printf("%s:",__func__);
}

8.归并排序：
把待排序的数据以k=2为单位进行分组，每组分为左右两部分，然后按从小到大的顺序合并到另一块空间，然后k*=2重复该过程，直到k/2>=len则排序完成。
归并排序需要一块额外的空间，用于存储合并的结果，它的时间复杂度与快速、堆相同，但是在排序过程中没有进行数据交换，而直接数据拷贝，因此节约了大量的数据交换的时间，但也耗费了额外的内存，所以它是一各典型的用空间换取时间的排序算法。
注意：如果用户对排序速度有很高的要求，但不在意内存的耗费，适合使用归并排序。

// 时间复杂度：O(NlogN)，空间复杂度：O(N)，稳定性：稳定
void merge_sort(int* arr,size_t len)
{
    // src指向的是待合并的数据，dest用于存储合并后的数据
    int *src = arr, *dest = malloc(sizeof(arr[0])*len);
    for(int k=1; k

9.计数排序：
首先定义一个计算数据出现的次数的数组cnts，并所有成员初始化0，然后使用数据的值作为数组的下标，然后统计每个数据出现的次数。
以i=[0,max]遍历cnts数组，当cnst[i]>0说明i出现过，然后把i往待排序的数组中存储cnts[i]个，然后排序完成。
注意：计算排序的局限比较大，它只能对整型数据进行排序，无法对浮点型、字符串型数据进行排序，待排序的数据重复性越高，差值越小，速度就越快，反之虽然也可以排，但得不尝失。

// 时间复杂度：O(N+K)，空间复杂度：O(K)，稳定性：稳定
void count_sort(int* arr,size_t len)
{
    int cnts[100] = {}; 
    for(int i=0; i

10.基数排序
先根据数据个位的大小对数据进行排序，然后再对排序结果的十位进行排序，然后百位、千位...，直到排序完成。
使用这种方式排序的优点是不需要对待排序的数据进行比较、交换，所以它的排序速度要比普通排序快的多，但局限性很大，只能对整型数据排序，还需要额外的内存空间。
注意：当数据的位数不多，并且差别不大，的整形数据适合使用基数排序。

// 时间复杂：O(n+k) 空间复杂度：O(n+k) 稳定性：稳定
void radix_sort(int* arr,size_t len)
{
    int (*radix)[len+1] = calloc(10,sizeof(arr[0])*(len+1));

    int exp = 1;
    while(exp < 1000000000)
    {
        for(int i=0; i= (len-1))
            break;
    }
    free(radix);
}