剑指Offer-26——数组中出现次数超过一半的数据以及JDK1.7后默认排序算法DualPivotQuicksort

题目描述

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

思路解析

这个题吧。就很简单，也许是我的解法不是最优解。但是我觉得还是可以吧？
我的想法是：先排序，然后将最小的K个数装入返回的ArrayList里面。这个题，我这种方法解决的话，不论是你手写排序算法还是调用Arrays.sort()方法，肯定都不能用冒泡排序的。。。。。因为，面试最常手撕的就是快排了，你来个冒泡算什么事嘛。

代码

import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
          ArrayList<Integer> array = new ArrayList<Integer>();
        if(k>input.length){
            return array;
        }
        Arrays.sort(input);
        for(int i=0;i<k;i++)
            array.add(input[i]);
        return array;
    }
}

我这里使用的是，调用Arrays.sort()来解决的。看看它的源码用的什么排序方法：

  /**
     * Sorts the specified array into ascending numerical order.
     *
     * <p>Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
     * by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
     * offers O(n log(n)) performance on many data sets that cause other
     * quicksorts to degrade to quadratic performance, and is typically
     * faster than traditional (one-pivot) Quicksort implementations.
     *
     * @param a the array to be sorted
     */
    public static void sort(int[] a) {
        DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }

嗯，看到没有，现在Array.Sort()的排序算法不是快排了，而是一种叫DualPivotQuicksort。这是jdk1.7做出的改变，也就是说直到JDK1.6及其之前都是在用快排算法。也就是说，现在JDK里面内置的默认排序算法已经是这个排序算法咯。圈起来，面试可能会考，可能还会手撕。

两个算法的源码

DualPivotQuicksort是JDK1.7开始的采用的快速排序算法。
一般的快速排序采用一个枢轴来把一个数组划分成两半，然后递归之。
大量经验数据表面，采用两个枢轴来划分成3份的算法更高效，这就是DualPivotQuicksort。

快排（经常手撕，建议默写）

快排的详尽思路，前人已经造了很多大炮了，直接拉出来用吧：面试必备–八大排序算法

public class Test {
    public static void main(String[] args) {
        int[] array = new int[]{3,1,2,4,1,0,9,4,1,35,754};
        quickSort(array,0,array.length-1);
        System.out.println(Arrays.toString(array));
    }
    public static void quickSort(int[] array,int start,int end){
        //如果为空或只有一个元素，则直接停止
        if(start>=end) return;
          //选择第一个数作为基准数
        int key = array[start];
          int low = start;
          int high = end;
          while(low<high){
              //将high的指针向左移动，直到找到小于key的值
              while(array[high]>=key&&low<high){
                  high--;
              }
              //找到了小于key的值，将其进行左右的调换
              array[low] = array[high];
              //进low的指针向右移动，直到找到大于key的值
              while(array[low] <= key&&low<high){
                  low++;
              }
              //找到了大于key的值，将其换到high一边去
              array[high] = array[low];
          }
        //把标准数赋给低所在的位置的元素
        array[low]=key;
        //处理所有的小的数字
        quickSort(array, start, low);
        //处理所有的大的数字
        quickSort(array, low+1, end);
        }
    }

DualPivotQuicksort其中的对于int型数组排序源码

   /**
     * Sorts the specified array into ascending numerical order.
     *
     * <p>Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
     * by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
     * offers O(n log(n)) performance on many data sets that cause other
     * quicksorts to degrade to quadratic performance, and is typically
     * faster than traditional (one-pivot) Quicksort implementations.
     *
     * @param a the array to be sorted
     */
    public static void sort(int[] a) {
        DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
    }
    

至于具体的源码实现，挺多的。因此这里直接奉上别人已经写好的博客了
新的快速排序算法: 《Dual-Pivot QuickSort》阅读笔记