排序——快速排序

快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

排序原理：

1、首先设定一个分界值，通过该分界值将数组分成左右两部分；
2、将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
3、然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4、重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

动画演示：

切分原理：

把一个数组切分成两个子数组的基本思想：
1、找一个基准值，用两个指针分别指向数组的头部和尾部；
2、先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；
3、再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
4、交换当前左边指针位置和右边指针位置的元素；
5、重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。

完整代码：

public class QuickSort {
  public static void main(String[] args) {
            int[] arr = {5,1,2,7,6,3,4,8};
            sort(arr);
            System.out.println(Arrays.toString(arr));

    }
    public static void sort(int[] arr){
        int min = 0;
        int max = arr.length-1;
        sort(arr,min,max);
    }

    private static void sort(int[] arr,int min,int max){
        if(min>=max){
            return;
        }
        //需要对数组中min——>max处的索引值进行分组（左子组，右子组）
        int partition = partition(arr, min, max);   //返回的是分组的分界值所在的索引，分界值位置变换后的索引
        //让左子组有序
        sort(arr, min, partition-1);
        //让右子组有序
        sort(arr, partition+1,max );
    }

    private static int  partition(int[] arr, int min, int max){
        //确定分界值
        int key = arr[min];
        //定义两个指针，分别指向待切元素的最小索引处和最大索引处的下一个位置
        int left = min;
        int right = max+1;

        //切分
        while(true){
            //先从右往左扫描，移动right指针，找到一个比分界值小的元素，停止
            while (key<arr[--right]){
                if(right==min){
                    break;
                }
            }
            //先从左往右扫描，移动left指针，找到一个比分界值大的元素，停止
            while (key>arr[++left]){
                if(left==max){
                    break;
                }
            }
            //判断left>=right，如果是，则证明扫描完毕，结束循环，如果不是交换元素
            if(left>=right){
                break;
            }else {
                //交换元素
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
            }

        }
        //交换分界值
        int temp = arr[min];
        arr[min] = arr[right];
        arr[right] = temp;

        return right;
   }
}

算法分析：

时间复杂度：

快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n),
但整个快速排序的时间复杂度和切分的次数相关。

• 最优情况：每一次切分选择的基准数字刚好将当前序列等分：
  如果我们把数组的切分看做是一个树，那么上图就是它的最优情况的图示，共切分了logn次，所以，最优情况下快速排序的时间复杂度为O(nlogn);
• 最坏情况：每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为O(n^2);
  

本文图片转自黑马程序员

• 平均情况：每一次切分选择的基准数字不是最大值和最小值，也不是中值，这种情况我们也可以用数学归纳法证明，快速排序的时间复杂度为O(nlogn)