快速排序算法是冒泡排序的一种改进，快速排序也是通过逐渐消除待排序的无序序列中逆序元素来实现排序的
    算法思想：
    (1) 我们从待排序的记录序列中选取一个记录(通常第一个)作为基准元素(称为key)key=arr[left]，然后设置两个变量，left指向数列的最左部，right指向数据的最右部。

    image.png
    (2) key首先与arr[right]进行比较，如果arr[right]key则我们只需要将right—，right—之后，再拿arr[right]与key进行比较，直到arr[right]<key交换元素为止。

    image.png


    (3) 如果右边存在arr[right]key,则将arr[right]=arr[left]，如果arr[left]image.png

    (4) 然后再移动right重复上述步骤
    image.png

    (5) 最后得到 {23 58 13 10 57 62} 65 {106 78 95 85}，再对左子数列与右子数列进行同样的操作。最终得到一个有序的数列。

    {23 58 13 10 57 62} 65 {106 78 95 85}
    {10 13} 23 {58 57 62} 65 {85 78 95} 106
    10 13 23 57 58 62 65 78 85 95 106

    算法实现：

    1. public class QuickSort {
    3.    public static void quickSort(int [] arr,int left,int right) {
    4.       int pivot=0;
    5.       if(left<right) {
    6.          pivot=partition(arr,left,right);
    7.          quickSort(arr,left,pivot-1);
    8.          quickSort(arr,pivot+1,right);
    9.       }
    10.    }
    12.    private static int partition(int[] arr,int left,int right) {
    13.       int key=arr[left];
    14.       while(left<right) {
    15.          while(left<right && arr[right]>=key) {
    16.             right--;
    17.          }
    18.          arr[left]=arr[right];
    19.          while(left<right && arr[left]<=key) {
    20.             left++;
    21.          }
    22.          arr[right]=arr[left];
    23.       }
    24.       arr[left]=key;
    25.       return left;
    26.    }
    28.    public static void main(String[] args) {
    29.       int arr[]= {65,58,95,10,57,62,13,106,78,23,85};
    30.       System.out.println("排序前："+Arrays.toString(arr));
    31.       quickSort(arr,0,arr.length-1);
    32.       System.out.println("排序后："+Arrays.toString(arr));
    33.    }
    34. }

    排序前：[65, 58, 95, 10, 57, 62, 13, 106, 78, 23, 85]
    排序后：[10, 13, 23, 57, 58, 62, 65, 78, 85, 95, 106]