快速排序-----数据结构

快速排序

设计思路：

1.交换式-快速排序

        a）判断数组元素个数，如果数组元素个数小于等于1，无需对数组进行排序，直接返回；

        b）若数组元素个数大于1，将数组的最右边的元素作为本次排序的基准值；

        c）定义俩个下标值，一个为开始位置下标left，另一个为最终位置下标right；

        d）保证left<right的前提下，从前到后通过改变left值，查找一个大于基准值的元素 ，找到后停止本次查找 ；

        e）保证left<right的前提下，从后到前查找一个小于基准值的元素，找到后停止本次查找；

        f）若left的值不等于right的值，将两次查找的值进行交换；

        g）若left的值等于right的值，将基准值与left处的值进行交换，在分别对left的左右俩边进行上述操作；

        h）操作结束后，现数组就是一个有序数组。

2.挖坑式-快速排序

        a）判断数组元素个数，如果数组元素个数小于等于1，无需进行排序，直接返回；

        b）若数组元素个数大于1，将数组的最右边的元素作为本次排序的基准值；

        c）先定义一个value用来保存基准值；

        d）再定义两个下标，一个下标为left是指定数据的开始下标，另一个为right是指定数据的结束下标；

        e）在left<right的前提下，从前到后通过改变left值查找到一个大于基准值的元素，将该元素赋值于基准值所在下标所指元素；

        f）在left<right的前提下，从后到前通过改变right值找到一个小于基准值的元素，将该元素赋值于下标为left所指元素；

        g）反复执行e、f操作，直到left 值等于right值，将value值赋值于下标为left所指元素，对left左右两边的元素进行上述操作；

        h）操作结束，先数组就是一个有序数组。

3.非递归快速排序

本质上，非递归快速排序就是通过栈来代替递归所要完成的操作

        a）将传入数组的0值入栈，再将传入数组的size-1值入栈；

        b）进行循环，对栈进行取栈顶元素，如果栈顶元素为空，表示排序结束；

        c）若栈顶元素不为NULL，定义俩个变量beg与end，然后对连续取栈顶元素赋值与beg与end，调用交换式排序对所得数组进行排序，将返回值赋值与mid；

        d）将beg、mid、mid+1，end依次入站，本次循环结束，进入下一次循环，直到栈为空，数组就成为了一个有序数组。

交换式-快速函数程序代码：

int64_t Partion(int array[],int64_t beg,int64_t end){
    if(end - beg<=1){
        return beg;
    }
    int64_t left = beg;
    int64_t right = end -1;
    int key = array[right];
    while(left <right){
        while(left<right&&array[left] <key){
            ++left;
        }
        while(left<right&&array[right]>key){
            --right;
        }
        if(left<right){
            swap(&array[left],&array[right]);
        }
    }
    swap(&array[left],&key);
    return left;
}

void _QuickSort1(int array[],int64_t beg,int64_t end){
    if(end-beg <=1){
        return;
    }
    int64_t mid = Partion(array,beg,end);
    _QuickSort1(array,beg,mid);
    _QuickSort1(array,mid,end);
    return;
}

//交换法快速排序函数实现
void QuickSort1(int array[],int64_t size){
    _QuickSort1(array,0,size);
    return;

挖坑式-快速函数程序代码：

//QuickSort函数
void QuickSort(RecType arr[],int start,int tail){
    int i = start;
    int j = tail;
    RecType tmp = arr[i];
    if(i<j){
        while(i!=j){
            while(j>i&&arr[j] > tmp){//从右向左找到第一个小于tmp的值
                --j;
            }
            arr[i] = arr[j];
            while(i<j && arr[i] < tmp){//从左向右找到第一个大于tmp的值
                ++i;
            }
            arr[j] = arr[i];
        }
        arr[i] = tmp;
        QuickSort(arr,start,i-1);//对左区间递归排序
        QuickSort(arr,i+1,tail);//对右区间递归排序
    }
}

非递归版本-快速函数程序代码：

//非递归版本快速排序
void QuickSortByLoop(int array[],int64_t size){
    if(size<= 1){
        return;
    }
    SeqStack seq;
    SeqStackInit(&seq);
    int64_t beg = 0;
    int64_t end = size;
    SeqStackPush(&seq,beg);
    SeqStackPush(&seq,end);
    while(1){
        int ret = GetStackTop(&seq,&end);
        if(ret == 0){
            //栈为空
        return;
        }
        SeqStackPop(&seq,&end);
        GetStackTop(&seq,&beg);
        SeqStackPop(&seq,&beg);
        if(end - beg <= 1){
            continue;
        }
        int64_t mid = Partion(array,beg,end);
        SeqStackPush(&seq,beg);
        SeqStackPush(&seq,mid);
        SeqStackPush(&seq,mid+1);
        SeqStackPush(&seq,end);
    }
    return;
}

测试用例程序代码（仅显示交换式快速排序 的测试用例，其他俩种较为相似）：

//检测函数
void TestQuickSort(){
    int array[] = {1,3,9,2,6,4};
    int64_t size = sizeof(array)/sizeof(array[0]);
    int i = 0;
    for(;i<size;++i){
        printf("%d ",array[i]);
    }
    printf("\n");
    QuickSort1(array,size);
    i = 0;
    for(;i<size;++i){
        printf("%d ",array[i]);
    }
    printf("\n");
    return;
}

//主函数
int main(){
    TestQuickSort();
    return 0;
}

检测结果显示（仅对交换式-快速排序结果进行显示）：