C-八大排序

马上就要考试了，考试的重点是八大排序算法，所以写这一篇来复习一下八大排序算法。
含完整的代码实现。
准备工作：

#ifndef DSSORT_H_INCLUDED
#define DSSORT_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
/*
*这一章是重点中的重点，主要来实现八大排序，必须烂熟于心！
*/
#define queueSize 10
typedef int ElemType;
#define arrSize 10
typedef struct _Array
{
    ElemType key;
}A,*Arr;
typedef struct _queue
{
    A arr[queueSize];
    int first, rear;
}Queue;

/*插入排序，1、直接插入排序*/
void InsertSort(Arr,int);
/*2、折半插入排序*/
void InsertSort_half(Arr,int);
/*希尔排序*/
void ShellSort(Arr,int);
/*
    第二大类：交换排序
*/
/*
    冒泡排序
*/
void BubbleSort(Arr,int);
/*
    快速排序
*/
void quickSort(Arr,int,int);
int Partition(Arr,int, int);
/*简单选择排序*/
void SelectSort(Arr, int);
/*重点来了：堆排序！*/
void buildMaxHeap(Arr, int);
void AdjustDown(Arr,int,int);
void HeapSort(Arr, int);
void AdjustUp(Arr, int);
//归并排序：
void Merge(Arr,int,int,int);
void mergeSort(Arr, int, int);
//基数排序 自己写：需要用到队列
void initQueue(Queue *);
void Enqueue(Queue *, A );
void Dequeue(Queue *, A *);
int  isEmpty(Queue *);
void radixSort(Arr, int);
#endif // DSSORT_H_INCLUDED

一：插入排序
1、直接插入排序，直接插入排序很好理解，涉及到查找插入位置和移位，将元素一个一个和前端部分已经有序的部分进行一个一个比较，查找到插入位置后，将其后所有元素后移，插入当前元素即可。代码如下

void InsertSort(Arr arr, int n)
{
    //这里我们需要设置一个“哨兵”也就是这个指针数组的0号元素留出来不存放任何值注意这点
    int i, j;
    for(i=2;i<=n;i++)
    {
        if(arr[i].key<arr[i-1].key)
        {
            arr[0] = arr[i];
            for(j=i-1;arr[0].key<arr[j].key;j--)
            {
                arr[j+1] = arr[j];
            }
            arr[j+1] = arr[0];     //arr[0].key现在大于arr[j]了循环退出，那么它该插入的位置就是arr[j+1]
        }
    }
}

直接插入排序算法分析：
空间效率：仅仅使用了常数个辅助空间，所以空间复杂度为O(1);
时间效率：在排序过程中，向有序子表中逐个插入元素的操作进行了n-1趟，每趟都分为比较关键字和移动元素，而这两者都取决于待排序表的初始状态：最好情况：已经有序，则每次插入一个元素都只需要比较一次而不用移动，因此时间复杂度为O(n)；最坏情况：表逆序，比较次数最大为2+3+4+…+n，总的移动次数也是最大，为3+4+…+n+1；平均情况：随机，取最好和最坏情况的平均复杂度，为O(n^2);是稳定的排序算法。

2、折半插入排序
折半插入排序仅仅是通过折半查找在已经有序的前半部分表中找出带插入元素的位置后，再进行后移和插入操作，不同于直接插入的边查找边移动，算法如下：

void InsertSort_half(Arr arr, int n)
{
    int i,j,low,high,mid;
    for(i=2;i<=n;i++)
    {
        arr[0] = arr[i];
        low = 0;high = i-1;
        while(low<=high)
        {
            mid = (low+high)>>1;                     //此处默认是递增有序的
            if(arr[mid].key>arr[0].key) high = mid-1;
            else low = mid+1;                        //注意，这里为什么如果相等也依然继续折半，我们考虑一个极端的情形，排十个‘1’，为了不破坏它的稳定性，不能增加一个相等直接插入后面，不然稳定性就被破坏了
        }
        for(j=i-1;j>=high+1;j--)                     //通过手动模拟，可以知道循环退出时high的值+1就是我们要插入元素的位置
        {
            arr[j+1]=arr[j];                         //high+1号就是我们要插入的元素
        }
        arr[high+1] = arr[0];
    }
}

算法分析：通过比较直接插入排序，不难发现我们仅仅是减少了比较元素的次数，约为O(nlog2(n))，该比较次数与与待排序表的初始状态无关，仅仅取决于元素个数n，而移动元素的次数并没有改变，所以时间复杂度依然为O(n^2)；空间复杂度依然也为O(1)，是稳定的排序方法。

3、希尔排序
希尔排序，基本思想：
先将待排序表分割成若干个形如L[i,i+d,i+2d,…i+kd]的“特殊”子表，分别进行直接插入排序，当整个表中元素
已经呈现出“基本有序”时，再对全体记录进行一次直接插入排序。
希尔排序的关键在与取这个步长，先把表中的记录分为d1各组，所有距离为d1的倍数的记录放在同一个组，在各组中进行直接插入排序
然后取第二个步长d2<d1，重复上述过程，直到最后dt=1；到目前为只，尚未求得一个最好的增量序列，希尔提出的方法是d1=n/2
d2=d1/2向下取整，并且最后一个增量等于1
增量序列最好选择互质的数字。
算法代码如下：

void ShellSort(Arr arr, int n)
{
    //对顺序表作希尔插入排序，本算法和直接插入排序相比做了以下修改
    //1、前后记录位置的增量是dk，不是1了
    //2、r[0]只是暂存单元，不是哨兵，当j<=0时，插入位置已到
    int dk;
    int i,j;
    for(dk = n/2; dk>=1; dk=dk/2)
    {
        for(i=dk+1;i<=n;i++)
        {
            if(arr[i].key<arr[i-dk].key)
            {
                arr[0] = arr[i];
                for(j=i-dk;j>0&&arr[0].key<arr[j].key;j-=dk)
                {
                    arr[j+dk] = arr[j];                        //记录后移，查找插入的位置
                }
                arr[j+dk] = arr[0];
            }
        }
    }
}

算法分析：希尔排序的空间效率：仅使用了常数个辅助单元，因而空间复杂度为O(1)
时间效率：由于希尔排序的时间复杂度依赖于增量序列的函数，这涉及数学上尚未解决的难题，所以其时间
复杂度分析比较困难。当n在某个特定范围时，希尔排序的时间复杂度约为O(n^1.3),最坏情况下是O(n*n)
希尔排序不是稳定的，因为相同关键字的记录被划分到不同的子表的时候，可能会发生位序上的变化
所以，其只试用于线性表为顺序存储的情况。

二：交换排序
1、冒泡排序：这个已经非常基础了，在此就略过了。

2、快速排序
是对冒泡法的一种改进，是基于“分治”思想的一种排序方法，具体来说取表中一个元素作为基准 pivot（中枢），然后比他小的元素放他的左边，比他大的元素放他的右边，此时pivot的位置就确定了，接下来递归的快速排序两个子表，直到最后所有元素都放在了其最终的位置上。
代码如下：

void quickSort(Arr arr, int low,int high)
{
    if(low<high)
    {
        int pivotpos = Partition(arr,low, high);
        quickSort(arr, low, pivotpos-1);
        quickSort(arr, pivotpos+1,high);
    }
}
int Partition(Arr arr, int low, int high)
{
    int pivot = arr[low].key;
    while(low<high)
    {
        while(low<high && arr[high].key>=pivot) high--;
        arr[low] = arr[high];
        while(low<high && arr[low].key<=pivot) low++;
        arr[high] = arr[low];
    }//当high=low的时候就推出了这个循环，不存在low比high大的情况！
    arr[low].key = pivot;
    return low;
}

算法分析： 快速排序的算法算是比较简单的了很好写
空间效率，由于快速排序是递归的，需要借助一个递归工作栈来保存每一层递归调用的必要信息，其容量应与递归调用的最大
深度一致。最好情况下为O(log2(n+1))向下取整，最坏情况下，因为要进行n-1次递归调用，所以栈的深度为O(n),平均情况下
栈的深度为O(log2(n))。因而空间复杂度在最坏情况下为O(n),平均情况下为O(log2(n));
时间效率：快排排序的运行时间与划分是否对称有关，而后者又与具体使用的划分算法有关，最坏情况发生在两个区域分别包含
n-1个元素和0个元素，这种最大成都的不对称性如果发生在每一层递归上，即对应与初始排序基本有序或者逆序时，就得到了最
坏情况下的时间复杂度O(n^2).
如果每一次划分都是完美划分，快速排序的运行效率大大提升，此时的时间复杂度为O(nlog2(n))，
！好在快速排序平均情况下运行时间与其最佳情况下的运行时间很接近，而不是接近其最坏情况下的运行时间。
快速排序是所有内部排序法中平均性能最优的排序算法。
快速排序是不稳定的
L=｛3,2,2｝的例子诠释

三：选择排序

1、简单选择排序：
每一趟扫描中确定一个元素的最终位置，因为其思想比较简单，这里直接给出代码：

void SelectSort(Arr arr, int n)
{
    //对arr进行简单选择排序，arr从1开始存放元素，对应起来，arr[0]始终是空
    int i,j;
    int min;
    A temp;
    for(i=1;i<=n-1;i++)
    {
        min = i;
        for(j=i+1;j<=n;j++)
        {
            if(arr[j].key<arr[min].key) min = j;
        }
        if(min!=i)
        {
            temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
}

简单快速排序的空间效率：O(1);
时间效率：从上面的代码不难看出，元素移动的次数很少，不会超过3(n-1)次,最好的情况是移动0次，此时对应的表已经有序
但是元素之间的比较次数与序列的初始状态无关，始终是n（n-1）/2次，所以时间复杂度始终是O(n^2)。
不稳定！

2、堆排序

堆排序比较有意思了，利用了堆的思想，首先通过算法把待排序的数列变成一个大顶堆或者小顶堆，假设为大顶堆，我们每次从堆顶（堆顶此时就为最大元素）然后将堆顶元素与最后一个元素交换，然后再递归这个过程，直到剩下最后一个元素，此时表已经有序。
算法代码如下：

void buildMaxHeap(Arr arr, int len)
{
    for(int i=len/2;i>0;i--)
    {
        AdjustDown(arr,i,len);
    }
}
void AdjustDown(Arr arr, int k,int len)
{
    //函数adjustDown将元素k向下调整
    arr[0] = arr[k];
    for(int i=2*k;i<=len;i*=2)
    {
        if(i<len && arr[i].key<arr[i+1].key) i++;
        if(arr[i].key <= arr[0].key) break;
        else
        {
            arr[k] = arr[i];                 //将arr[i]调整到双亲节点上
            k=i;                             //修改k值，以便继续向下筛选
        }
    }
    arr[k] = arr[0];
}
void HeapSort(Arr arr, int len)
{
    buildMaxHeap(arr, len);
    A temp;
    for(int i=len;i>1;i--)
    {
        temp = arr[1];
        arr[1] = arr[i];
        arr[i] = temp;
        AdjustDown(arr,1,i-1);
    }
}

void AdjustUp(Arr arr, int k)
{
    //参数k为向上调整的结点，也为堆的元素个数
    arr[0] = arr[k];
    int i=k/2;                  //若结点值大于双亲结点，则将双亲结点下调，并继续向上比较
    while(i>0 && arr[i].key<arr[0].key)           //这里是i>0吗？ 好像没什么关系啊
    {
        arr[k] = arr[i];
        k = i;
        i = k/2;
    }
    arr[k] = arr[0];
}

堆排序算法的性能分析：
空间效率：仅使用了常数个辅助单元 arr[0] ，所以空间复杂度为O(1);
时间效率，建堆时间为O(n)，之后有n-1次向下调整操作，每次调整的时间复杂度为O(h)h是树高，所以在最好以及最坏和平均情况下，堆排序的时间复杂度为O(nlog2(n))。
堆排序是不稳定的排序方法！

四：归并排序和基数排序

1、归并排序：
我认为归并排序是最好理解的，先需要一个辅助数组，然后分别把原数组复制到B中，分别递归的进行左右两侧子序列递归排序，最后逐个归并，最后的数组就是有序的了。
算法代码如下：

void Merge(Arr arr, int low,int mid,int high)
{
    A arr1[arrSize+1];
    int i,j,k;
    for(int k=1;k<=10;k++)
    {
        arr1[k] = arr[k];
    }
    for(i=low,j=mid+1,k=i; i<=mid && j<=high;)
    {
        if(arr1[i].key<=arr1[j].key) arr[k++] = arr1[i++];
        else arr[k++] = arr1[j++];
    }
    while(i<=mid) arr[k++] = arr1[i++];
    while(j<high) arr[k++] = arr1[j++];
}

void mergeSort(Arr arr, int low, int high)
{
    int mid;
    if(low<high)
    {
        mid = (low+high)/2;
        mergeSort(arr, low, mid);
        mergeSort(arr, mid+1, high);
        Merge(arr, low, mid, high);
    }
}

算法分析：
2-路归并排序算法的性能分析如下：
空间效率，可以看到，辅助空间刚好要占用n个单元，所以归并排序的空间复杂度为O(n)。
时间效率：每一躺归并排序的时间复杂度是O(n),总共需要进行log2(n)向上取整，所以算法的时间复杂度为O(nlog2(n))
稳定性：不会改变相同关键字的相对次序。

2、基数排序：
基数排序非常有意思，是一种特别的排序算法，根据关键字每一位来进行排序，这个算法也算是非常有意思了，但是它的适用性比较有限，对于数字排序，就需要构造十个”桶“来分别装下待排序的元素，接着”收集“，再根据下一位进行排序，再收集，如此知道序列最终有序。
根据这个思想，考虑到数字的特殊性，我自己将基数排序算法修改如下：

void initQueue(Queue *Q)
{
    Q->rear = Q->first = 0;
    printf("initializing success!\n");
}
void Enqueue(Queue *Q, A arr)
{
    Q->arr[Q->rear] = arr;
    Q->rear = (Q->rear+1)%queueSize;
}
void Dequeue(Queue *Q, A *arr)
{
    *arr = Q->arr[Q->first];
    Q->first = (Q->first+1)%queueSize;
}
int isEmpty(Queue *Q)
{
    if(Q->first != Q->rear) return 0;
    else return 1;
}
void radixSort(Arr arr, int len)
{
    int number=0;
    int k = 1;
    int MaxDigitNumber = 1;
    int controlNumber = 1;
    Queue Q[queueSize];
    for(int i=0;i<10;i++)
    {
        initQueue(&Q[i]);
    }
    //加个大循环！
    for(int i=1; i<=len;i++)
    {
        int digitFlag = (int)floor(log10(arr[i].key))+1;
        if(MaxDigitNumber<digitFlag) MaxDigitNumber = digitFlag;
    }
    for(int i=0;i<MaxDigitNumber;i++)
    {

        for(int i=1;i<=len;i++)
        {
            number = ((arr[i].key)/controlNumber)%10;
            //printf("%d ", arr[i].key);
            // printf("%d ",number);
            if(number<1)
            {
                Enqueue(&Q[0],arr[i]);
            }
            else
            {
                Enqueue(&Q[number], arr[i]);
            }
        }
        for(int i = 0;i<len; i++)
        {
            while(!isEmpty(&Q[i]))
            {
                Dequeue(&Q[i],&arr[k]);
                k++;
            }
        }
        k = 1;
        controlNumber = controlNumber*10;
    }
}

其实算法本身没有什么难度，无非是控制好逻辑结构就行。
算法分析：
基数排序是一种很特别的排序方法；借助“分配”和“收集”来对逻辑关键字进行排序
其空间效率，需要借助r个队列（关键字个数r）比如如果要排序数字的话就必须是0-9九个队列，但可以重复使用（如上构造了一个循环队列）
所以基数排序的空间复杂度为O（r）;
时间效率，根据需要进行d趟分配和收集，一趟分配需要O(n),一趟收集需要O®;所以基数排序的时间复杂度为O(d(n+r))，它与序列的初始状态无关！
最重要一点，它是稳定的！

接下来给出测试主函数：各位看官可以自己运行一下进行逐步调试，具体看看是如何执行的，相当于手动模拟：

#include <stdio.h>
#include <stdlib.h>
#include "DSsort.h"

int main()
{
    Arr arr1 = (Arr)malloc(sizeof(struct _Array)*11);
    A arr[arrSize+1]={0,202020202,3,2,55,888,88,8,8,7,8};                        
    SelectSort(arr,10);                                    //可以在这里调用你想用的排序方式
    for(int i=1;i<=10;i++)
    {
        printf("%d\n", arr[i].key);
    }
    return 0;
}