算法学习:快速排序算法学习

快速排序算法：每次排序时将第一个元素作为哨兵元素提取出来（空出第一个位置），尾指针从数组后方向前移动，如果指针所指的元素比哨兵元素小，则将元素提取出来放到前面的空位置中，移动后，移动头指针向后移动，如果头指针指向的元素比哨兵元素小则移动到尾指针指向的空位置，循环移动，直到头尾指针相遇，将哨兵元素放到头尾指针相遇的位置，并将数组由哨兵位置分开成两个小数组继续进行快速排序算法。具体实现过程如下图：

具体实现代码如下：（过程可能有些复杂，如有可以优化的地方，请各位大佬指出）

import java.util.Arrays;
import java.util.Random;

public class QuickSort {
    public static void main(String[] args) {
        Random random = new Random();
        int[] arr = new int[]{random.nextInt(100), random.nextInt(100), random.nextInt(100)
                , random.nextInt(100), random.nextInt(100),
                random.nextInt(100), random.nextInt(100), random.nextInt(100)
                , random.nextInt(100)};
//        int []arr=new int[]{30  ,83 , 96 , 37 , 62 , 56 , 93  ,45  ,12 };
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
        arr=quickSort(arr);
        System.out.println();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
    }

    private  static int[] quickSort(int[] arr){
        if (arr.length>1){
//            取出第一个元素位哨兵元素,让第一个位置空出来
            int sentry =arr[0];
            arr[0]=0;
//            定义头尾指针
            int headPoint=0;
            int lastPoint=arr.length;
//           定义一个执行次数方便控制循环的指针
            int count =0;
            while(headPoint<lastPoint){
//               循环一次移动尾指针后，一次移动头指针
                if (count%2==0){
                    for (lastPoint=lastPoint-1 ;lastPoint>headPoint;lastPoint--){
//                        如果后方存在比哨兵元素小的的元素则放到前面的空位置中
                        if (arr[lastPoint]<sentry){
                            int temp=arr[lastPoint];
                            arr[lastPoint]=arr[headPoint];
                            arr[headPoint]=temp;
                            count++;
                            break;
                        }
                    }
                }else {
                    for (headPoint=headPoint+1;headPoint<lastPoint;headPoint++){
//                        如果前面的元素比哨兵元素大则放到哨兵元素的后方空位置中
                        if (arr[headPoint]>sentry){
                            int temp=arr[lastPoint];
                            arr[lastPoint]=arr[headPoint];
                            arr[headPoint]=temp;
                            count++;
                            break;
                        }
                    }
                }
            }
//            循环后头尾指针相遇;将哨兵元素放入指针位置
            arr[headPoint]=sentry;
//            将哨兵元素前边数组再次进行快排
            int[] arr1=Arrays.copyOfRange(arr,0,headPoint);
            arr1=quickSort(arr1);
//            将哨兵元素后边数组进行快排
            int[] arr2=Arrays.copyOfRange(arr,headPoint+1== arr.length-1? arr.length-1:headPoint+1,arr.length);
            arr2=quickSort(arr2);
//          将数组重写组合
            arr = merge(arr1, arr2, sentry);
        }
        return arr;
    }
    private static   int[]  merge(int[]headArr,int[]lastArr,int mid){
        int[] newArr=new int[headArr.length+lastArr.length+1];
        for (int i = 0; i < headArr.length; i++) {
            newArr[i]=headArr[i];
        }
        newArr[headArr.length]=mid;
        for (int i =0; i < lastArr.length ; i++) {
            newArr[i+headArr.length+1]=lastArr[i];
        }
        return newArr;
    }
}

运行效果如图：