快排的三种最常用方法

1. Hover
2. 挖坑法
3. 前后指针（两个下标）

   #pragma once
   #include<stdio.h>

   void Swap(int array[], int i, int j){
       int t = array[i];
       array[i] = array[j];
       array[j] = t;
   }

4. //Hover法

5. 
   //快排
   //需要排序的空间是[low,high]
   int Partition_1(int array[], int low, int high){
       int begin = low;
       int end = high;
       int pivot = array[low];
       //(begin,end)的区间是没有被比较过的数据
       while (begin<end){
           while (begin<end && array[end]>=pivot){
               end--;
           }
           if (begin == end){
               break;
           }
           //array[end]比基准值小了
           while (begin<end && array[begin] <= pivot){
               begin++;
           }
           //array[begin]比基准值大了
           //交换begin和end 下标处的数据
           Swap(array, begin, end);
       }
       //low基准值
       //[low+1,begin]比基准值小
       //[begin+1,high]比基准值大
       //把基准值和比它小的最后一个数交换
       Swap(array, low, begin);
       return begin;
   }

6. //挖坑法

7. 
   int Partition_2(int array[], int low, int high){
       int begin = low;//从基准值位置开始
       int end = high;
       int pivot = array[low];// begin是坑的下标
       //(begin,end)的区间是没有被比较过的数据
       while (begin<end){
           //重点：如果基准值在左边，需要从右边开始走
           while (begin<end && array[end] >= pivot){
               end--;
           }
           if (begin == end){
               break;
           }
           //array[end]比基准值小了
           //坑的下标是begin
           array[begin] = array[end];
           //end是坑的下标

           while (begin<end && array[begin] <= pivot){
               begin++;
           }
           //array[begin]比基准值大了
           //坑的下标是end
           array[end] = array[begin];
           //begin变成坑的下标
       }
       //low基准值
       //[low+1,begin]比基准值小
       //[begin+1,high]比基准值大
       //把基准值和比它小的最后一个数交换
       array[begin] =array[end]= pivot;
       return begin;
   }

    

8. //前后下标，前后指针

9. int Partition_3(int array[], int low, int high){

10.     int d = low + 1;
        int i = low + 1;
        int pivot = array[low];
        while (i <= high){
            if (array[i] < pivot){
                Swap(array, d, i);
                d++;
            }
            i++;
        }
        Swap(array, d - 1, low);
        return d - 1;
    }

11. 
    void  _QuickSort(int array[], int low,int high){
        //直到区间为0
        if (low > high){
            return;
        }
        //或者区间为1，表示区间内的数已经有序
        if (low == high){
            return;
        }
        //1.找基准值，选最左边，基准值的下标是low
        //2.遍历整个区间，把小的放左，大的放右，返回基准值所在下标
        int pivotIdx = Partition_3(array, low, high);
        //3.区间被分为三部分
        //[low,pivotIdx-1] 小
        //[pivotIdx,pivotIdx]  有序
        //[pivotIdx+1,high]  大
        //分治算法，分别处理所有两个小区间
        _QuickSort(array, low, pivotIdx - 1);
        _QuickSort(array, pivotIdx + 1, high);
    }

    void QuickSort(int array[], int size){
        _QuickSort(array, 0, size - 1);
    }

    
    void test(){
        int array[] = { 3, 9, 1, 4, 7, 5, 2, 8, 0 ,10,6};
        int size = sizeof(array) / sizeof(int);
        PrintArray(array, size);
        QuickSort(array, size);
        PrintArray(array, size);
    }

12. 结果：

13. 3  9  1  4  7  5  2  8  0  10  6
    0  1  2  3  4  5  6  7  8  9  10
    请按任意键继续. . .