快速排序的三种实现方法

1. 快速排序的单趟排序

快速排序的单趟排序:是以一个数作为基准值，实现将数组中比基准数小的数放在基准值的左侧，比基准值大的数放在基准值的右侧。

方法一：霍尔法

霍尔法的由来：霍尔是一个人的名字，他是最初发现快速排序的人，所以，它使用的单趟排序算法被称为霍尔法。

1.基本思路：

​ 用key标记基准值的下标(数组下标0的元素)，使用两个指针left和right分别指向待排数组的最左侧和最右侧，right指针找比key基准值小的数，left指针找比key基准值大的数，找到后将两个数交换位置，同时实现大数右移和小数左移，直到left与right相遇则排序完成，最后将key基准值的下标返回，就完成了单趟排序。

package LiKou;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位        temp = arr[low];

        while (i=arr[i]&&i

方法二：挖坑法1.基本思路：挖坑法是将key基准值用变量单独保存，然后将key的位置空出来形成一个坑，left和right指针分别从左右两端向中心遍历，此时left先指向这个坑，从右边先开始，right找比key小的数，找到后将该数直接放进坑里，并将自己空出来的位置设置为坑，left找比key大的数，找到后将该数放进坑里，并将现在空出来的位置设置为坑，一直遍历，直到left与right相遇，相遇位置一定为坑(left和right必定有一个指向坑)，此时将key基准值放进坑内，并返回基准值下标完成单趟排序。

package LiKou;

public class QuickSort2 {
    public static void main(String[] args) {
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        Quick3(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void Quick2(int[] arr,int left,int right){
        if(left>right){
            return;
        }
        int key=arr[left];
        int pre=left;
        int cur=left+1;
        while(cur<=right){
            if(arr[cur]<=key && ++pre!=cur){
                int temp=arr[cur];
                arr[cur]=arr[pre];
                arr[pre]=temp;
            }
            cur++;
        }
        int temp=arr[left];
        arr[left]=arr[pre];
        arr[pre]=temp;
        Quick2(arr,pre+1,right);
        Quick2(arr,left,pre-1);
    }
    public static void Quick3(int[] arr,int left,int right){
        if(left>=right){
            return;
        }
        int key=arr[left];
        int i=left;
        int j=right;
        while(ii && arr[j]>=key){
                j--;
            }
            if(j>i){
                arr[i]=arr[j];
            }
            while(ii){
                arr[j]=arr[i];
            }
        }
        arr[i]=key;
        Quick3(arr,left,i-1);
        Quick3(arr,i+1,right);
    }
}

方法三：前后指针法

1.基本思路：

（1） 用key保存数组第一个元素作为基准值，定义前指针prev指向第一个数，后指针cur指向前指针的后一个位置。

（2） 由cur挨个遍历数组中的数据，如果cur寻找比key基准值小的数，则prev后移一个位置，并且交换cur和prev所对应的元素值，cur和prev位置不变。

（3） 依次类推直到cur完全遍历完数组，停止。

prev之前的值一定小于key基准值，而prev与cur之间的一定大于基准值

最后将prev处与key位置的元素交换，将基准值下标返回（此时基准值下标已经交换到prev位置）。则完成单趟排序。

package LiKou;

public class QuickSort2 {
    public static void main(String[] args) {
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        Quick2(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void Quick2(int[] arr,int left,int right){
        if(left>right){
            return;
        }
        int key=arr[left];
        int pre=left;
        int cur=left+1;
        while(cur<=right){
            if(arr[cur]<=key && ++pre!=cur){
                int temp=arr[cur];
                arr[cur]=arr[pre];
                arr[pre]=temp;
            }
            cur++;
        }
        int temp=arr[left];
        arr[left]=arr[pre];
        arr[pre]=temp;
        Quick2(arr,pre+1,right);
        Quick2(arr,left,pre-1);
    }
}