数据结构——初学者学习笔记 【八】排序

排序算法介绍：

​ 排序是计算机程序设计过程中的重要操作，它的功能是将一个数据元素的任意序列，重新排列成一个按关键字有序的序列。

​ 它之所以重要是因为查找操作非常重要，而有序的顺序表可以采用效率较高二分查找（时间复杂度为O(logn)），而无序的顺序表只能进行顺序查找（时间复杂度为O(N) ），而创建二叉排序树、有序二叉树、堆的过程本身就是一个排序过程。

排序算法的稳定性：

​ 待排序的数据序列中可能存储两个或两个以上的关键字相等的数据，假设ki==kj且 i!=j，如果排序前i<j，排序后也肯定i<j，这种排序算法是稳定的排序，反之是不稳定的排序。

1、经典排序：

能够完成排序操作，但没有任何优化，数据的比较次数一次没少，数据的交换次数一次没少，没有任何优点，不能称得上是算法。

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

2、冒泡排序：

​ 排序过程像是水中的气泡上升，越大的气泡升的越快，所以叫冒泡排序，从第一个数据开始，让前后相邻的数据进行比较，如果Ki>Ki+1则交换它们，每一趟排序完成一个数据，反复这个过程，直接待排序的数据为1，则结束排序。

​ 和经典排序相比，冒泡排序对数据的有序性敏感，如果一趟排序没有发生交换，则说明所前面的数据都比它的后继数据要小，则可以立即停止，提前结束排序。

​ 注意：如果待排序的数据基本有序，则使用冒泡排序速度最快，因为它数据的有序性敏感可以提前结束。

// 最优时间复杂度：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; j<i; j++)
        {
            if(arr[j] > arr[j+1])
            {
                swap(arr[j],arr[j+1]);
                flag = true;
            }   
        }   
    }   
}

3、选择排序：

​ 从第i个待排序的数据开始，假定它是最小值，并用min记录它的下标，然后与用arr[min]与它后面的数据进行比较，如果有它还小的数据，则更新min的值，排序一趟后，如果min==i，则说明第一个数据是最小值，不需要交换，如果min!=i则交接第一个数据与arr[min]，然后i++，重复这个步骤直到待排序的数据为1（i=len-1），排序结束。

​ 和经典排序相比，它的数据比较次数没有减少，但是它的数据交换数次大大降低(O(N-1))，节约了很多数据交换的时间，虽然时间复杂度没有变化，排序效率比经典排序提高了很多。

​ 注意：选择排序最突出的特点是数据的交换次数最少，如果待排序的数据字节数较多，如：结构、类对象，则使用选择排序速度最快。

// 时间复杂度：O(N^2)，空间复杂度：O(1)，稳定性：不稳定
void select_sort(int* arr,size_t len)
{
    for(int i=0; i<len-1; i++)
    {
        int min = i;
        for(int j=i+1; j<len; j++)
        {
            if(arr[min] > arr[j])
                min = j;
        }
        if(min != i)
            swap(arr[min],arr[i]);
    }
}

4、插入排序：

​ 往有序的序列中添加新的数据，使序列继续保持有序，具体步骤是：假定新的数据存放在i=len位置，val与它前面的数据逐一进行比较val<arr[i-1]，如果前面的数据大于tmp大，则把前面数据的向后拷贝一下，然后i自减1重复以比较，直到arr[i-1]<=tmp或0==i，则位置i就是tmp应该存放的位置，新插入的数据就排序完成。

​ 可以使用以上方法对无序序列进行排序，把序列看作两个总分，已经有序的部分（数量为1）和待插入的部分（len-1），把待插入部分的数据逐个向前面有序部分插入，就完成了对无序序列进行排序。

​ 注意：顾名思义，插入排序算法适合往有序的序列中添加新的数据，优点是排序过程中没有进行数据交换，节约了大量时间。

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

void insert_sort(int* arr,size_t len)
{
    for(int i=1; i<len; i++)
    {
        int tmp = arr[i], j = i;
        while(j-1>=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<len; i+=k)
        {
            int tmp = arr[i], j = i;
            while(j-k>=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)
{
    // 备份左右边界
    int l = left, r = right;
    // 把最右边的数据作为标杆，前记录标杆下标
    int pv = arr[left], pi = left;

    while(l<r)
    {
        // 从右向左寻找比标杆小的数据
        while(l<r && arr[r]>=pv) r--;
        // 找到比标杆小的数据
        if(l<r)
        {
            // 把它移动标杆的左边
            arr[pi] = arr[r];
            // 记录标杆的新位置
            pi = r;
        }
        // 从左向右寻找比标杆大的数据
        while(l<r && arr[l]<=pv) l++;
        // 打到比标杆大的数据
        if(l<r)
        {
            // 把它移动到标杆的右边
            arr[pi] = arr[l];
            // 记录标杆的新位置
            pi = l;
        }
    }
    // 把标杆的值存放到最新位置
    arr[pi] = pv;

    // 快速排序标杆左边的数据
    if(pi-left>1)
        _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+1<len)
    {
        // 假定左子树是左右子树中的最大值
        int max = root*2+1;
        // 判断右子树是否大于左子树，如果大于则更新最大值下标
        if(max+1<len && arr[max+1]>arr[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<len; k*=2)
    {
        // 以k为单位进行合并
        for(int i=0,j=i; i<len; i+=k*2)
        {
            // 计算出左边的起始位置和结束位置
            int l = i, le = i+k < len ? i+k : len;
            // 计算出右边的起始位置和结束位置
            int r = le, re = i+k*2 < len ? i+k*2 : len;
            // 左右两边的数据进行合并，谁小谁存储在dest里面,直到有一方结束
            while(l<le && r<re)
            {
                dest[j++] = src[l]<src[r] ? src[l++] : src[r++];
            }
            // 把左边剩余的数据拷贝到dest里面
            while(l<le)
                dest[j++] = src[l++];
            // 把右边剩余的数据拷贝到dest里面
            while(r<re)
                dest[j++] = src[r++];
        }
        // 合并完成后，dest中存储的就是下一次待合并的数据，所以两个指针交换
        swap(src,dest);
    }
    // 执行完swap(src,dest)后，src指向的是排序后的数据，如果src!=arr则说明排序后的数据存储在堆内在中，需要拷贝给arr
    if(src != arr)
    {
        memcpy(arr,src,sizeof(arr[0])*len);
        dest = src;
    }
    // 释放堆内存
    free(dest);
}

函数递归实现归并排序：

void __merge_sort(int* src,int* dest,int left,int p,int right)
{   
    int l = left, le = p, r = p, re = right, j=left;
    while(l<le && r<re)
    {
        dest[j++] = src[l]<=src[r]?src[l++]:src[r++];
    }
    while(l<le)
        dest[j++] = src[l++];
    while(r<re)
        dest[j++] = src[r++];
    memcpy(src+left,dest+left,sizeof(src[0])*(right-left));
}

void _merge_sort(int* src,int* dest,int left,int right)
{
    int p = (left + right) / 2;
    if(p-left>1)
        _merge_sort(src,dest,left,p);
    if(right-p>1)
        _merge_sort(src,dest,p,right);
    __merge_sort(src,dest,left,p,right);
}

void merge_sort(int* arr,size_t len)
{
    int* dest = malloc(sizeof(arr[0])*len);
    _merge_sort(arr,dest,0,len);
    free(dest);
}

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<len; i++)
    {   
        cnts[arr[i]]++;
    }

    int k = 0;
    for(int i=0; i<100; i++)
    {
        for(int j=0; j<cnts[i]; j++)
        {   
            arr[k++] = i;
        }
    }
}

不知道待排序的数据范围：

void count_sort(int* arr,size_t len)
{
    int max = arr[0], min = arr[0];
    for(int i=1; i<len; i++)
    {
        if(arr[i] > max)
            max = arr[i];
        if(arr[i] < min)
            min = arr[i];
    }

    int* cnts = calloc(max-min+1,sizeof(arr[0]));
    for(int i=0; i<len; i++)
    {
        cnts[arr[i]-min]++;
    }

    for(int i=min,k=0; i<=max; i++)
    {
        for(int j=0; j<cnts[i-min]; j++)
        {
            arr[k] = i;
        }
    }
    free(cnts);
}

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; i++)
        {
            int row = arr[i]%(exp*10)/exp;
            radix[row][++radix[row][0]] = arr[i];
        }
        exp *= 10;

        int index = 0, cnt = 0;
        for(int i=0; i<10; i++)
        {
            for(int j=1; j<=radix[i][0]; j++)
            {
                arr[index++] = radix[i][j];
                if(radix[i][j] <exp)
                    cnt++;
            }
            radix[i][0] = 0;
        }
        if(cnt >= (len-1))
            break;
    }
    free(radix);
}

11、桶排序

​ 桶排序就是把待排序的数据，根据值划分不同的范围存储到不同的"桶"中，然后再使用其它排序算法对桶中的数据进行排序，最终再合并桶中的数据达到排序的目的。

​ 之所以这样，是因为待排序的数据比较大时，会影响排序算法的性能，桶排序就是通过数据进行分类，降低数据的规模，从而提高排序算法的性能。

​ 注意：该算法代码简单，但实现难度很大，需要对数据有足够的了解，每个桶中数量要够均匀，才能达到预期效果。

// 时间复杂：O(n+k) 空间复杂度：O(n+k) 稳定性：未知
void bucket_sort(int* arr,size_t len)
{
    int bucket[3][len],i1=0,i2=0,i3=0;
    for(int i=0; i<len; i++)
    {
        if(arr[i] < 100)
            bucket[0][i1++] = arr[i];
        else if(arr[i] < 1000)
            bucket[1][i2++] = arr[i];
        else
            bucket[2][i3++] = arr[i];

    }
    quick_sort(bucket[0],i1);
    quick_sort(bucket[1],i2);
    quick_sort(bucket[2],i3);

    memcpy(arr,bucket[0],sizeof(arr[0])*i1);
    memcpy(arr+i1,bucket[1],sizeof(arr[0])*i2);
    memcpy(arr+i1+i2,bucket[2],sizeof(arr[0])*i3);
}