快速排序

原理:

   快速排序,说白了就是给基准数据找其正确索引位置的过程.
   如下图所示,假设最开始的基准数据为数组第一个元素23,则首先用一个临时变量去存储基准数据,即tmp=23;然后分别从数组的两端扫描数组，设两个指示标志:low指向起始位置，high指向末尾.

   首先从后半部分开始，如果扫描到的值大于基准数据就让high减1,如果发现有元素比该基准数据的值小(如上图中18<=tmp)，就将high位置的值赋值给low位置 ,结果如下:

然后开始从前往后扫描,如果扫描到的值小于基准数据就让low加1,如果发现有元素大于基准数据的值(如上图46=>tmp)，就再将low位置的值赋值给high位置的值,指针移动并且数据交换后的结果如下:

然后再开始从后向前扫描,原理同上,发现上图11<=tmp,则将low位置的值赋值给high位置的值 ,结果如下:
然后再开始从后向前扫描,原理同上,发现上图11<=tmp,则将high位置的值赋值给low位置的值,结果如下:

然后再开始从前往后遍历,直到low=high结束循环,此时low或high的下标就是基准数据23在该数组中的正确索引位置.如下图所示.

  这样一遍走下来,可以很清楚的知道,其实快速排序的本质就是把基准数大的都放在基准数的右边,把比基准数小的放在基准数的左边,这样就找到了该数据在数组中的正确位置.
  以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了

/*** 
 * @Description: one new start!
 * @version: 
 * @Author: MocWangYu
 * @Date: 2020-10-22 10:46:30
 * @LastEditors: MocWangYu
 * @LastEditTime: 2020-10-29 11:28:21
 */
#include<iostream>
using namespace std;

void disp(int a[],int n)//输出a[]
{
    int i;
    for(i=0;i<n;i++){
        cout<<a[i]<<" ";
    }cout<<endl;
}
int Partition(int a[],int low,int high)
{
    int i=low,j=high;
    int tmp=a[low];
    while(i!=j)
    {
        while (j>i&&a[j]>=tmp)
        {
            j--;
        }a[i]=a[j];
        while (i<j&&a[i]<=tmp)
        {
            i++;
        }a[j]=a[i];
    }a[i]=tmp;
    return i;
}
void QuickSort(int a[],int low,int high)
{
    if(low<high)
    {
        int i=Partition(a,low,high);
        QuickSort(a,low,i-1);
        QuickSort(a,i+1,high);
    }
}
int main()
{
    int a[]={23,16,0,8,11,18};
    int n=sizeof(a)/sizeof(a[0]);
    cout<<"排序前：";
    disp(a,n);
    QuickSort(a,0,n-1);
    cout<<"排序后：";
    disp(a,n);
    return 0;
}

 添加随机数的情况：

public class Quicksort {
    //快速排序
    public int Partition(int[] A, int low, int high,int randomizer){
        int length = A.length;
        int pivot = A[randomizer];  //枢纽值
        for (int i = 0; i < length; i++) {    //查找枢纽值下标，并与第一位交换
            if(A[i]==pivot){
                int j = A[low];
                A[low] = pivot;
                pivot = j;
            }
            else {
                break;
            }
        }
        pivot = A[low];        //将当前表中第一个元素设为枢轴，将表进行划分
        while (low<high)            //循环跳出条件
        {
            while (low<high&&A[high]>=pivot)
            {
                --high;
            }
            A[low]=A[high];          //将比枢轴小的元素移动到左端
            while (low<high&&A[low]<=pivot)
            {
                ++low;
            }
            A[high]=A[low];          //将比枢轴大的元素移动到右端
        }
        A[low] = pivot;        //将枢轴元素存放到最终位置
        return low;           //返回存放枢轴的最终位置
    }

    public void QuickSorts(int[] A,int low,int high,int r){
        Quicksort sort = new Quicksort();
        if(low<high){          //递归跳出的条件
            //Partition()就是划分操作，将表A[low...high]划分为满足上述条件的两个子表
            int pivotpos = Partition(A,low,high,r);      //划分
            QuickSorts(A,low,pivotpos-1,r);          //依次对两个子表进行递归排序
            QuickSorts(A,pivotpos+1,high,r);
        }
    }

    public static void main(String[] args) {
        int[] A = new int[]{1,6,7,4,10,3,45,9,5,100,5,4,34,56,66,99}; //创建数组
        Quicksort sort = new Quicksort();  
        int low = 0,high = A.length-1;  //low、high分别指向数组头和尾
        int r = (int) (Math.random()*(A.length-1));   //随机取数
        System.out.println("随机数："+r);
        sort.QuickSorts(A,low,high,r);
        for(int a:A){    //输出结果
            System.out.println(a);
        }
    }
}