LeetCode - 215. Kth Largest Element in an Array(6种写法(包括BFPRT算法))

LeetCode - 215. Kth Largest Element in an Array(6种写法(包括BFPRT算法))

• 最小堆(非递归调整)
• 最小堆(递归调整)
• 最大堆
• Hash思想
• 分治解法(利用快排的partition过程)
• BFPRT算法

---

题目链接

题意

在未排序的数组中找到第k个最大的元素。注意这个和找第K小的数，以及求出最小(大)的k个数是一样的，包括剑指Offer里面的找第K小的数。

最小堆(非递归调整)

最小堆的方法就是先用K个数建成一个堆，然后后面的数和堆顶(最小的数)比较，如果大于堆顶，就替换这个堆顶，然后调整堆，最后，堆顶就是答案。这个方法可以达到O(N*logK)的时间复杂度

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0) return Integer.MAX_VALUE;
        int[] KHeap = new int[k]; //建成一个有K个数的堆
        for (int i = 0; i < k; i++) {
            heapInsert(KHeap, nums[i], i);
        }
        //后面的数如果
        for (int i = k; i < nums.length; i++) {
            if (nums[i] > KHeap[0]) {
                KHeap[0] = nums[i];
                siftDown(KHeap, 0, k); //调整从0到k
            }
        }
        return KHeap[0];
    }

    //插入数一直往上面调整的过程
    private void heapInsert(int[] KHeap, int num, int i) {
        KHeap[i] = num;
        while (KHeap[i] < KHeap[(i - 1) / 2]) {
            swap(KHeap, i, (i - 1) / 2);
            i = (i - 1) / 2;
        }
    }

    //这个函数就是一个数变大了，往下沉的函数,改变的数为index  目前的自己指定的堆的大小为heapSize
    private void siftDown(int[] kHeap, int i, int heapSize) {
        int L = 2 * i + 1;
        while (L < heapSize) {
            int maxIndex = L + 1 < heapSize && kHeap[L + 1] < kHeap[L] ? L + 1 : L;
            maxIndex = kHeap[i] < kHeap[maxIndex] ? i : maxIndex;
            if (maxIndex == i) break; //自己就是最大的不用往下面沉
            swap(kHeap, i, maxIndex);
            i = maxIndex;
            L = 2 * i + 1;
        }
    }

    private void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}  

---

最小堆(递归调整)

这里只是把上面调整堆的过程改成递归写一下。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0) return Integer.MAX_VALUE;
        int[] KHeap = new int[k]; //建成一个有K个数的堆
        for (int i = 0; i < k; i++) {
            heapInsert(KHeap, nums[i], i);
        }
        //后面的数如果
        for (int i = k; i < nums.length; i++) {
            if (nums[i] > KHeap[0]) {
                KHeap[0] = nums[i];
                siftDown(KHeap, 0, k); //调整从0到k
            }
        }
        return KHeap[0];
    }

    private void heapInsert(int[] KHeap, int num, int i) {
        KHeap[i] = num;
        while (KHeap[i] < KHeap[(i - 1) / 2]) {
            swap(KHeap, i, (i - 1) / 2);
            i = (i - 1) / 2;
        }
    }

    public void siftDown(int[] data, int i, int size) { //从A[i] 开始往下调整
        int L = 2 * i + 1;   //左孩子的下标
        int R = 2 * i + 2;   //右孩子的下标
        int maxi = i;
        if (L < size && data[L] < data[maxi]) maxi = L;
        if (R < size && data[R] < data[maxi]) maxi = R;
        if (maxi != i) {
            swap(data, i, maxi);  //把当前结点和它的最大(直接)子节点进行交换
            siftDown(data, maxi, size);  //继续调整它的孩子
        }
    }

    private void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

---

最大堆

最大堆的做法和最小堆有点不同，一开始将整个数组中的元素构成一个最大堆，这时堆顶元素是最大的，连续将堆顶元素弹出k-1次(每次弹出后都要调整)后堆顶元素就是第k大的数了。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0) return Integer.MAX_VALUE;
        int[] KHeap = new int[nums.length]; //建成一个有K个数的堆
        for (int i = 0; i < nums.length; i++) {
            heapInsert(KHeap, nums[i], i);
        }
        int size = nums.length;
        for (int i = 0; i < k - 1; i++) { //弹出k个
            swap(KHeap, 0, size - 1);
            size--;
            siftDown(KHeap, 0, size);
        }
        return KHeap[0];
    }


    //插入数一直往上面调整的过程
    private void heapInsert(int[] KHeap, int num, int i) {
        KHeap[i] = num;
        while (KHeap[i] > KHeap[(i - 1) / 2]) {
            swap(KHeap, i, (i - 1) / 2);
            i = (i - 1) / 2;
        }
    }

    //这个函数就是一个数变大了，往下沉的函数,改变的数为index  目前的自己指定的堆的大小为heapSize
    private void siftDown(int[] kHeap, int i, int heapSize) {
        int L = 2 * i + 1;
        while (L < heapSize) {
            int maxIndex = L + 1 < heapSize && kHeap[L + 1] > kHeap[L] ? L + 1 : L;
            maxIndex = kHeap[i] > kHeap[maxIndex] ? i : maxIndex;
            if (maxIndex == i) break; //自己就是最大的不用往下面沉
            swap(kHeap, i, maxIndex);
            i = maxIndex;
            L = 2 * i + 1;
        }
    }

    private void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

---

Hash思想

这个是提交的时候，点击了最快的那个解答看了一下，觉得有点厉害。

class Solution {
    /** Hash思想 */
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0) return Integer.MAX_VALUE;
        int max = nums[0], min = nums[0];
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > max) max = nums[i];
            if (nums[i] < min) min = nums[i];
        }
        int[] arr = new int[max - min + 1];
        for (int n : nums) arr[max - n]++;
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
            if (sum >= k) {
                return max - i;
            }
        }
        return 0;
    }
}

---

分治解法(利用快排的partition过程)

这个方法就是利用快排的partition将数组分成左边部分大于某个数，中间部分等于某个数，右边部分小于某个数(如果是求第k小的就是左边小于某个数，中间等于某个数，右边大于某个数),然后我们每次划分之后，递归的从左边或者从右边去找第K大的数，直到找到在等于部分的。

class Solution {
    /** 分治 */
    public int findKthLargest(int[] nums, int k) {
        if (nums == null || nums.length == 0) return Integer.MAX_VALUE;
        return process(nums, 0, nums.length - 1, k - 1); //一定要注意这里是k-1
    }

    public int process(int[] arr, int L, int R, int k) {
        if (L == R) return arr[L];
        int[] p = partition(arr, L, R, arr[L + (int) (Math.random() * (R - L + 1))]); //随机选一个数划分
        if (k >= p[0] && k <= p[1])
            return arr[k];
        else if (k < p[0])
            return process(arr, L, p[0] - 1, k);
        else 
            return process(arr, p[1] + 1, R, k);
    }

    //划分函数 左边的都比num大，右边的都比num小  用一个数组来记录和num相等的下标的下限和上限
    public int[] partition(int[] arr, int L, int R, int num) {
        int less = L - 1; //小于部分的最后一个数
        int more = R + 1;
        int cur = L;
        while (cur < more) {
            if (arr[cur] > num) {
                swap(arr, ++less, cur++); //把这个比num大的数放到大于区域的下一个，并且把小于区域扩大一个单位
            } else if (arr[cur] < num) {
                swap(arr, --more, cur); //把这个比num小的数放到小于去余的下一个，并且把小于区域扩大一个单位
                //同时，因为从小于区域拿过来的数是未知的，所以不能cur++ 还要再次判断一下arr[cur]
            } else {
                cur++;
            }
        }
        return new int[]{less + 1, more - 1};  //返回的是等于区域的两个下标
    }

    private void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

---

BFPRT算法

这个方法其实是在上面的分治方法上面的改进，唯一的不同就是寻找那个划分的数的不同，上面的数是随机生成的数，而BFPRT算法能找到那样一个数，使得划分的时候左右两边相对均匀，看下面的具体的求解过程:

看下面的一个例子：

class Solution {

    public int findKthLargest(int[] arr, int K) {
        int[] copyArr = copyArray(arr); //不改变原来的数组
        return select(copyArr, 0, copyArr.length - 1, K - 1);
    }

    public int[] copyArray(int[] arr) {
        int[] res = new int[arr.length];
        for (int i = 0; i != res.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    public int select(int[] arr, int L, int R, int k) {
        if (L == R) {
            return arr[L];
        }
        int pivot = medianOfMedians(arr, L, R); //获得这个划分的标准
        int[] p = partition(arr, L, R, pivot);
        if (k >= p[0] && k <= p[1])
            return arr[k];
        else if (k < p[0])
            return select(arr, L, p[0] - 1, k);
        else
            return select(arr, p[1] + 1, R, k);
    }

    //划分函数 左边的都比num大，右边的都比num小  用一个数组来记录和num相等的下标的下限和上限
    public int[] partition(int[] arr, int L, int R, int num) {
        int less = L - 1; //小于部分的最后一个数
        int more = R + 1;
        int cur = L;
        while (cur < more) {
            if (arr[cur] > num)
                swap(arr, ++less, cur++); //把这个比num大的数放到大于区域的下一个，并且把小于区域扩大一个单位
            else if (arr[cur] < num)
                swap(arr, --more, cur); //把这个比num小的数放到小于去余的下一个，并且把小于区域扩大一个单位
                //同时，因为从小于区域拿过来的数是未知的，所以不能cur++ 还要再次判断一下arr[cur]
            else
                cur++;
            
        }
        return new int[]{less + 1, more - 1};  //返回的是等于区域的两个下标
    }

    //划分成5组，取出每一组中的中位数，组成一个中位数组
    public int medianOfMedians(int[] arr, int L, int R) {
        int num = R - L + 1;
        int offset = num % 5 == 0 ? 0 : 1;
        int[] mArr = new int[num / 5 + offset];
        for (int i = 0; i < mArr.length; i++) {
            int beginI = L + i * 5;
            int endI = beginI + 4;
            mArr[i] = getMedian(arr, beginI, Math.min(R, endI));
        }
        return select(mArr, 0, mArr.length - 1, mArr.length / 2);
    }


    //得到中位数
    public int getMedian(int[] arr, int L, int R) {
        insertionSort(arr, L, R);
        int sum = L + R;
        int mid = (sum / 2) + (sum % 2);
        return arr[mid];
    }

    //插入排序
    public void insertionSort(int[] arr, int L, int R) {
        for (int i = L + 1; i <= R; i++) {
            for (int j = i; j > L && arr[j] < arr[j - 1]; j--)
                swap(arr, j, j - 1);
        }
    }

    private void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

只要得到了第K(小/大)的数，要得到最小(大)的K个数，就很简单了，再遍历一遍就可以了，如下面的函数，得到最小的K个数:

    public int[] getMinKNums(int[] arr, int k) {
        if (k < 1 || k > arr.length) {
            return arr;
        }
        int minKth = findKthLargest(arr, k);
        int[] res = new int[k];
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < minKth) {
                res[index++] = arr[i];
            }
        }
        for (; index < res.length; index++) {
            res[index] = minKth;
        }
        return res;
    }