数据准备

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;

//1.排序算法数据结构设计
//用于要排序数组个数最大值，可根据需要修改
#define MAXSIZE 10000
typedef struct
{
    //用于存储要排序数组，r[0]用作哨兵或临时变量
    int r[MAXSIZE+1];
    //用于记录顺序表的长度
    int length;
}SqList;


//2.排序常用交换函数实现
//交换L中数组r的下标为i和j的值
void swap(SqList *L,int i,int j)
{
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
}

//3.数组打印
void print(SqList L)
{
    int i;
    for(i=1;i<L.length;i++)
        printf("%d,",L.r[i]);
    printf("%d",L.r[i]);
    printf("\n");
}

归并排序

//归并排序一对顺序表L进行归并排序
//将有序的SR[i,mid]和SR[mid+1,n]归并为有序的TR[i,n]
void Merge(int SR[],int TR[],int i,int m,int n){
    int j,k,l;
    //1.将SR中记录由小到大并入TR
    for (j = m+1,k=i; i<=m && j<= n; k++) {
        if (SR[i] < SR[j]) {
            TR[k] = SR[i++];
        }else{
            TR[k] = SR[j++];
        }
    }

    //2.将剩余的SR[i,mid]复制到TR
    if (i<=m) {
        for (l=0; l<=m-i; l++) {
            TR[k+l] = SR[i+l];
        }
    }
    //3.将剩余的SR[j,n]复制到TR
    if (j<=n) {
        for (l=0; l<=n-j; l++) {
            TR[k+l] = SR[j+l];
        }

    }


}


//将SR[s,t]归并排序为 TR1[s,t]
void MSort(int SR[],int TR1[],int low,int hight){
    int mid;
    int TR2[MAXSIZE+1];
    if (low == hight) {
        TR1[low] = SR[low];
    }else{
        //1.将SR[low,hight]平分成SR[low,mid]和SR[mid+1,hight]
        mid = (low+hight)/2;
        //2.递归将SR[low,mid]归并为有序的TR2[low,mid]
        MSort(SR, TR2, low, mid);
        //3.递归将SR[mid+1,hight]归并为有序的TR2[mid+1,hight]
        MSort(SR, TR2, mid+1, hight);
        //4.将TR2[low,mid]和TR2[mid+1,hight]归并到TR1[low,hight]中
        Merge(TR2, TR1, low, mid, hight);
    }

}
//MARK:归并排序
void MergeSort(SqList *L){
    MSort(L->r, L->r, 1, L->length);
}

快速排序

//交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置
//此时在它之前(后)的记录均不大(小)于它
int Partition(SqList *L,int low,int high){
    int pivotkey;
    //保存子表中的第1个作为枢轴记录
    pivotkey = L->r[low];
    //从数组两端交替的向中间扫描
    while (low<high) {
        //从高位开始，找到比枢轴pivotkey更小的值的下标位置
        while (low<high && L->r[high] >= pivotkey) {
            high--;
        }
        //将比枢轴low小的值high进行交换，从而使得比枢轴小的值移动到低位，枢轴值移动到high位置
        swap(L, low, high);
        //从低位开始，找到比枢轴pivotkey更大的值的下标位置
        while (low<high && L->r[low] <= pivotkey) {
            low++;
        }
        //将比枢轴high大的值low进行交换，从而使得比枢轴大的值移动到高位，枢轴值移动到low位置
        swap(L, low, high);


    }

    //返回枢轴的位置
    return low;
}
//对顺序表L的子序列L-r[low,high]做快速排序
void QSort(SqList *L,int low,int high){
    int pivot;
    if (low<high) {
        //将L->[low,high]一分为二，算出中枢轴值的位置pivot
        pivot = Partition(L, low, high);
        printf("pivot = %d L->r[%d] = %d\n",pivot,pivot,L->r[pivot]);
        //对低子表进行递归排序
        QSort(L, low, pivot-1);
        //对高子表进行递归排序
        QSort(L, pivot+1, high);
    }

}
//MARK:快速排序
void QuickSort(SqList *L){
    QSort(L, 1, L->length);
}

调用

#define N 9
int main(int argc, const char * argv[]) {
    printf("Hello, 排序算法\n");
     
    int i;
    int d[N]={-7,1,5,8,3,7,4,6,2};
    //int d[N]={9,8,7,6,5,4,3,2,1};å
    //int d[N]={50,10,90,30,70,40,80,60,20};
    SqList l0,l1,l2,l3,l4,l5,l6,l7,l8,l9,l10;
    
    for(i=0;i<N;i++)
        l0.r[i+1]=d[i];
    
    l0.length=N;
    l1=l2=l3=l4=l5=l6=l7=l8=l9=l10=l0;
    
    printf("排序前:\n");
    print(l0);
    printf("\n");
//    归并排序(递归)
    printf("归并排序(递归):\n");
    MergeSort(&l7);
    print(l7);
    printf("\n");
    
    //10.快速排序
    printf("快速排序:\n");
    QuickSort(&l9);
    print(l9);
    printf("\n");
    return 0;
}