快速排序

1.指针交换法

package quickSort;

import java.util.Arrays;

public class QuickSort1 {
    public static void quickSort(int[] arr) {
        int startindex = 0;
        int endindex = arr.length-1;
        //递归结束标识
        if(startindex>=endindex) {
            return;
        }
        //得到基准元素位置
        int partitionindex = partition1( arr, startindex, endindex);
        //分治法递归数列两部分
        quickSort(arr,startindex,partitionindex-1);
        quickSort(arr,partitionindex+1,endindex);
    }
    public static void quickSort(int[] arr,int startindex,int endindex) {
        //递归结束标识
        if(startindex>=endindex) {
            return;
        }
        //得到基准元素位置
        int partitionindex = partition( arr, startindex, endindex);
        //分治法递归数列两部分
        quickSort(arr,startindex,partitionindex-1);
        quickSort(arr,partitionindex+1,endindex);
    }

    private static int partition1(int[] arr,int startindex,int endindex) {
        //取基准元素位置
        int pivot = arr[startindex];
        int left = startindex;
        int right = endindex;

        while(left<right) {
            //控制right指针左移
            while(left<right&&arr[right]>pivot) {
                right--;
            }
            //控制left指针右移
            while(left<right&&arr[left]<=pivot) {
                left++;
            }
            if(left<right) {
                arr[left] = arr[left]^arr[right];
                arr[right] = arr[left]^arr[right];
                arr[left] = arr[left]^arr[right];

            }
        }
        //控制重合点与pivot交换 
        arr[left] = arr[left]^arr[startindex];
        arr[startindex] = arr[left]^arr[startindex];
        arr[left] = arr[left]^arr[startindex];
        System.out.println(Arrays.toString(arr)+"--->"+right);
        return (right);
    }

    private static int partition(int[] arr,int startindex,int endindex) {
        //取基准元素位置
        int pivot = arr[startindex];
        int left = startindex;
        int right = endindex;

        while(left<right) {
            //控制right指针左移
            while(left<right&&arr[right]>pivot) {
                right--;
            }
            //控制left指针右移
            while(left<right&&arr[left]<=pivot) {
                left++;
            }
            if(left<right) {
                arr[left] = arr[left]^arr[right];
                arr[right] = arr[left]^arr[right];
                arr[left] = arr[left]^arr[right];

            }
        }
        //控制重合点与pivot交换 
        /*此处出现问题不知道什么原因，期待大神的指导=-=
        arr[left] = arr[left]^arr[startindex];
        arr[startindex] = arr[left]^arr[startindex];
        arr[left] = arr[left]^arr[startindex];*/
        int b = arr[startindex];
        arr[startindex] = arr[right];
        arr[right] = b;

        System.out.println(Arrays.toString(arr)+"--->"+right);
        return (right);
    }
    public static void main(String[] args) {
        int[] arr = {7,5,6,2,3,4,9,8};
        Arrays.sort(arr);
        //System.out.println(Arrays.toString(arr));
        int[] arr1 = {4,7,6,5,3,2,8,1};
        quickSort(arr1,0,arr.length-1);
        System.out.println(Arrays.toString(arr1));
        int[] arr2 = {4,7,6,5,3,2,8,1};
        quickSort(arr2);
        System.out.println(Arrays.toString(arr2));
    }
}

2.挖坑法

package quickSort;

import java.util.Arrays;

public class QuickSort {
    public static void quickSort(int[] arr,int startindex,int endindex) {
        //递归结束标识
        if(startindex>=endindex) {
            return;
        }
        //得到基准元素位置
        int partitionindex = partition( arr, startindex, endindex);
        //分治法递归数列两部分
        quickSort(arr,startindex,partitionindex-1);
        quickSort(arr,partitionindex+1,endindex);
    }
    private static int partition(int[] arr,int startindex,int endindex) {
        //取基准元素位置
        //int pivot = arr[(int) ((endindex-startindex)*Math.random())];
        int pivot = arr[startindex];
        int left = startindex;
        int right = endindex;

        //坑的位置，初始为pivot位置
        int index = Arrays.binarySearch(arr, pivot);
        while(left<=right) {

            //right指针从右往左进行比较
            while(left<=right) {
                if(arr[right]<=pivot) {
                    arr[left] = arr[right];
                    index = right;
                    left++;
                    break;
                }
                right--;
            }
            while(left<=right) {
                if(arr[left]>=pivot) {
                    arr[right] = arr[left];
                    index = left;
                    right--;
                    break;
                }
                left++;
            }
            //left指针从左往右进行比较
        }
        arr[index] = pivot;
        System.out.println(Arrays.toString(arr)+"--->"+index);
        return index;
    }
    public static void main(String[] args) {
        //int[] arr = {1,2,3,5,4,7,6,8};
        int[] arr = {4,5,7,6,3,2,9,8};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
    }
}