寻找最大的K个数（二）：快排优化和二分搜索

（总要更好的，等你去发现）

 

若是对技术不感兴趣的，能够直接跳转到最后的题外话。写了一点点，支离破碎。也是从这个程序想到的一点点。

 

今天继续和你们聊寻找最大的K个数。

 

先来熟悉一下问题：

有不少个无序的数（咱们这里假设为正整数），并且各不相等，怎么选出最大的K个数。

 

例如：2，5，7，1，3，9，3，6，7，8，5

最大的5个数为：7，9，6，7，8

 

昨天咱们给出了两个解法：

快速排序和选择排序，文章详情：寻找最大的K个数：快排和选择（一）

 

今天咱们继续。

 

回想一下快速排序，每次作完一次快速排序，数组S都会被分红两部分Sa和Sb。Sb的每个数都大于Sa的每个数。这时候会出现两种状况：

 

第一：Sb.length >= K，这时候咱们只须要关心Sb数组便可，由于前K个最大的数都在Sb中。

第二：Sb.length < K，这时候前K个最大的数为Sb加上Sa数组中前K-Sb.length个数。

 

 

下面这段代码，是在前面快速排序的基础上修改的。主要是一次快速排序后比较K和

Sb数组的长度。

 

具体代码以下：

 

package com.xylx.utils.selectK;

/**

 * 优化快速排序，查找最大的Ｋ个输

 */

public class OptQuickSortSelectK {

    public static void main(String[] args) {

        int[] arr = Constans.getLengthArr(100);

        System.out.println("排序前：");

        Constans.printArr(arr);

        optQuickSort(arr, 0, arr.length-1, Constans.K);

        System.out.println("排序后:");

        Constans.printArr(arr);

        System.out.println("排序是否正确: "+Constans.isOk(arr));

        Constans.selectK(arr);

    }

 

    public static void optQuickSort(int[] arr, int start, int end, int k) {

        int left = start;

        int right = end;

        int key = arr[left];

        while (left < right) {

            while (left<right && arr[right] > key) {

                right --;

            }

            if (left < right) {

                int tmp = arr[left];

                arr[left] = arr[right];

                arr[right] = tmp;

                left ++;

            }

            while (left<right && arr[left] < key) {

                left ++;

            }

            if (left < right) {

                int tmp = arr[right];

                arr[right] = arr[left];

                arr[left] = tmp;

                right--;

            }

        }

        if (start < left-1) {

            int rightLength = end - right + 1;

            System.out.println("rightLength="+rightLength+"  k="+k);

            if (rightLength < k) { //右边数组小于须要的Ｋ数

                optQuickSort(arr, start, left-1, k-rightLength); //须要左边数组k-rightLength个最大的数

            }

        }

 

        if (right + 1 < end) {

            int rightLength = end - right + 1;

            if (rightLength > k) {

                optQuickSort(arr, right+1, end, k);

            }

        }

    }

}

上面这段代码能大大下降排序的次数。

 

============分割线============

 

寻找前K个最大数，也就是选择第K大的数。

 

若是数组S的中最大值为max，最小值为min。那么第K大的值Vk必定知足下面的关系：

 

min<=Vk<=max。

 

咱们从中间值开始找起，mid=(min+max)/2。查找数组S中全部>=mid的数的个数total。这时候也会出现两种状况：

 

第一：total>=K, 证实查找出来的数比K多，咱们须要增长mid的值，也就是min=mid。

 

第二：total<K，证实查找出来的数比K少，咱们须要减小max的值，也就是max=mid。

 

这样不断循环，直到max-min <= 1。

 

代码以下：

package com.xylx.utils.selectK;

import java.util.ArrayList;

import java.util.List;

/**

 */

public class BinSearchSelectK {

    public static void main(String[] args) {

        int[] arr = Constans.getLengthArr(100);

        Constans.printArr(arr);

        selectK(arr);

    }

 

    public static void selectK(int[] arr) {

        List<Integer> result = getMaxMin(arr);

        int max = result.get(0);

        int min = result.get(1);

        while (max - min > 1) {

            int mid = (max + min)/2;

            int total = getGTTotal(arr, mid);

            if (total >= Constans.K) {

                min = mid;

            } else {

                max = mid;

            }

        }

        System.out.println("min="+min+"  max="+max);

        printK(arr, min);

    }

 

    private static void printK(int[] arr, int min) {

        int index = 0;

        System.out.println("最大的K个数:");

        for (int i=0; i<arr.length; i++) {

            if (arr[i] > min) {

                System.out.print(arr[i]+"    ");

                index++;

            }

        }

        for (int i=0; i<(Constans.K-index); i++) {

            System.out.print(min+"    ");

        }

    }

 

    /**

     * 查找数组中大于等于mid值大的数的个数

     * @param arr

     * @param mid

     * @return

     */

    public static int getGTTotal(int[] arr, int mid) {

        int total = 0;

        for (int i=0; i<arr.length; i++) {

            if (arr[i] >= mid) {

                total++;

            }

        }

        return total;

    }

 

    /**

     * 寻找数组中最大值和最小值

     * @param arr

     * @return 0:最大　1:最小

     */

    public static List<Integer> getMaxMin(int[] arr) {

        List<Integer> result = new ArrayList<Integer>();

        if (arr == null || arr.length < 1) {

            return result;

        }

        int max = Integer.MIN_VALUE;

        int min = Integer.MAX_VALUE;

        for (int i=0; i<arr.length; i++) {

            if (arr[i] > max) {

                max = arr[i];

            }

            if (arr[i] < min) {

                min = arr[i];

            }

        }

        result.add(max);

        result.add(min);

        return result;

    }

}

当循环结束以后，你会获得一个区间min和max。min就是查找的第K大的数。这里须要注意一下，min可能会有多个，不是全部的min都符合要求，因此咱们应该先查找比min大的数，查找到的数不够K个，就用min来补齐。

 

题外话：

总有最好的，等你去发现。就像这个程序，寻找一下仍是有更好解法的。

 

有时候，坑你的不是别人，而是本身。当咱们解决一个问题以后，每每都会停留下来，不多可以主动想想还有没有更好的方法。也就是最近比较流行的：呆在本身的温馨区。

 

本身给本身挖坑每每是最隐秘的。咱们或多或少都在本身挖的坑里，有的舒服，有的痛苦。

 

舒服的一方就像温水煮蛙里那只还很舒服的青蛙。痛苦的是那只已经快被煮熟的青蛙。

 

一个问题，一般都会有好多个解法，而咱们老是浅尝辄止。一份工做一般都有更优的解法，而咱们老是去选择忽略。

 

因此，没事别忘了虐一虐本身，问一问本身：

 

是否在本身的温馨区呆过久了！！！

 

那些年虐咱们的面试题：

寻找最大的K个数：快排和选择（一）

靠谱的TCP：三次握手和四次挥手

CDN知道为何是你？

DNS域名解析

喜欢聊技术或者聊观点，能够加入公号：【花生读书汇】

一块儿：励志，成长，学习，分享。