快速排序算法(五)

1.什么是快速排序：
快速排序习惯性被称为快排，快排利用的是分治思想。其是快排是对冒泡排序的一种改进。其核心思想，通过一趟排序将要排序的数据分割 成独立的两部分，其中一部分的所有数据比另一部分的数据要小，再按这种方法对这两部分数据分别进行快速排序，整个排序过程可以使用递归进行，使整个数据变成有序序列。
2.快速排序原理：
如果要排序数组中下标从left到right之间的的数据，我们选择Left到right之间的任意一个数据作为分区点。我们遍历left到right之间的数据，将小于分区点的放到其左边，将大于分区点的放到其右边，将分区点值放到中间。经过这一步骤，数组left到right之间的数据就被分成三部分。根据分治，递归的处理思想，我们可以利用递归排序下标把其两端的区间之间数据缩小为1，就说明所有数据都有序。
算法分析参考
3.算法详分析：
(1) 我们从待排序的记录序列中选取一个记录(通常第一个)作为基准元素(称为key)key=arr[left]，然后设置两个变量，left指向数列的最左部，right指向数据的最右部。

(2) key首先与arr[right]进行比较，如果arr[right]<key，则arr[left]=arr[right]将这个比key小的数放到左边去，如果arr[right]>key则我们只需要将right–，right–之后，再拿arr[right]与key进行比较，直到arr[right]<key交换元素为止。

(3) 如果右边存在arr[right]<key的情况，将arr[left]=arr[right]，接下来，将转向left端，拿arr[left ]与key进行比较，如果arr[left]>key,则将arr[right]=arr[left]，如果arr[left]<key，则只需要将left++,然后再进行arr[left]与key的比较。

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

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

代码实现一.：

package data.Sort;
 public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[]{11,41,4,5,6,7,11,9};
        quickSort(arr);
        arrPrint(arr);
    }
    public static void quickSort(int[] data){
     int n=data.length;
     if(n<=1){
         return ;
     }else
         quickSortInternal(data,0,n-1);
    }
    public static void quickSortInternal(int[] data,int left,int right){
        if(left>=right){
            return;
        }else{
       //获取分区点
            int mid=partition(data,left,right);
            quickSortInternal(data,left,mid-1);
            quickSortInternal(data,mid+1,right);
        }
    }
    public static int partition(int[] data,int left,int right){
        int v=data[left];//默认比较元素为待排序数组的第一个元素
        int j=left;
        int i=left+1;
        for(;i<=right;i++) {
            if (data[i] <= v) {   
             //每当碰到小于比较元素的值与j+1位置交换，小于区间长度加一
                swap(data, j + 1, i);
                j++;
            }
        }
        //当for循环走完只需要将data[left]的位置与data[j]位置交换即可保证索引小于j的元素均小于v
        //索引大于j的元素均大于j
        swap(data,left,j);
        return j;
    }
    //交换数组中两个索引下标的元素
    public static void swap(int[] data,int index1,int index2){
        if(index1!=index2) {
            data[index1] = data[index2] + data[index1];
            data[index2] = data[index1] - data[index2];
            data[index1] = data[index1] - data[index2];
        }
      }
    public static void arrPrint(int data[]){
        for(int i=0;i<data.length;i++){
            System.out.print(data[i]+" ");
        }
    }
}

代码实现二：

package data.Sort;

import java.util.Arrays;

public class QuickSort1 {
    public static void quickSort(int [] arr,int left,int right) {
        int pivot=0;
        if(left<right) {
            pivot=partition(arr,left,right);
            quickSort(arr,left,pivot-1);
            quickSort(arr,pivot+1,right);
        }
    }
    private static int partition(int[] arr,int left,int right) {
        int key=arr[left];
        while(left<right) {
            while(left<right && arr[right]>=key) {
                right--;
            }
            arr[left]=arr[right];
            while(left<right && arr[left]<=key) {
                left++;
            }
            arr[right]=arr[left];
        }
        arr[left]=key;
        return left;
    }
    public static void main(String[] args) {
        int arr[]= {75,48,95,10,71,62,13,16,78,23,55};
        System.out.println("排序前："+Arrays.toString(arr));
        quickSort(arr,0,arr.length-1);
        System.out.println("排序后："+Arrays.toString(arr));
    }
}

4.快速排序算法性能分析：
最坏的时间复杂度：O(n^2)
平均时间复杂度：O(nlogn)
空间复杂度：O(logn)
快速排序是一个不稳定的排序算法，快速排序基本被认为是相同数量级的所有排序算法中，平均性能最好的。

5.算法优化

• 三中取中法：由于每次选择第一个，容易造成移动次数偏多，时间复杂度趋向于O(n^2),所以我们要找到中间位置的值，我们希望基准值能够接近中间位置的值，所以在待排的区间可以把头部，尾部，中间值取中间值作为基准值。
• 根据规模大小改变算法： 由于快速排序在数据量较小的情况下，排序性能并莫有其他算法好，我们可以在代排序的数列分区小于某个值后，采用其他算法进行排序，而不是继续使用快速排序。一般这个值可以为15左右吧。
• 其他分区方案考虑：可以分三个分区，除了小于基准值或大于基准值还有一个等于基准值的区间，这样我们在递归比较时，可以不考虑基准数区间了。