LeetCode 378：有序矩阵中第k小的元素_leetcode378完整代码

题目描述

给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第k小的元素。
请注意，它是排序后的第k小元素，而不是第k个元素。

示例:

matrix = [
[ 1, 5, 9],
[10, 11, 13],
[12, 13, 15]
],
k = 8,

返回 13。
说明:
你可以假设 k 的值永远是有效的, 1 ≤ k ≤ n2 。

解题思路

第一种方法：借助堆无脑将所有矩阵元素全部遍历一遍，在堆中元素小于k时，一直添加，在size大于等于k时，比较大顶堆堆顶元素的值和遍历元素的大小，如果堆顶元素更大，则弹出堆顶，然后将遍历元素加入，这种效率较低，思路也很简单。
第二种方法比较好，思路其实也较为清晰：利用二分法的思想，因为是有序矩阵，我们可以得出矩阵的最大最小值，从而求出中间值。如果中间值数量还小于k，那么第k个一定在右半部分，我们对右半部分继续二分。同理，如果中间值的数量大于k，那么第k个一定在左半部分，我们对左半部分继续二分，对于数量的统计方法，因为矩阵每行每列都是升序，我们以列为单位遍历，从第一列开始，每一列从最后一个元素开始，如果每列最后一个元素都小于中间值，那么这一列的元素都算作所求的count值，否则，继续向该列上面移动（每列元素从下至上递减）。直到遍历完整个矩阵，即可统计出数量。

代码实现

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

import java.util.Comparator;
import java.util.PriorityQueue;

public class KthSmallestEle {
    //有序矩阵中第k小的元素
    public int kthSmallest(int[][] matrix,int k){ //acc:25ms 28%
        PriorityQueue<Integer> heap=new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });

        for (int i=0;i<matrix.length;i++){
            for (int j=0;j<matrix[0].length;j++){
                if (heap.size()>=k){
                    if (matrix[i][j]<heap.peek()){
                        heap.add(matrix[i][j]);
                        heap.poll();
                    }
                }else {
                    heap.add(matrix[i][j]);
                }
            }
        }
        return heap.peek();
    }

    public int kthSmallest_1(int[][] matrix, int k) { //acc:1ms 88%
        int row = matrix.length;
        int col = matrix[0].length;
        int left = matrix[0][0];
        int right = matrix[row - 1][col - 1];
        while (left < right) {
            // 每次循环都保证第K小的数在start~end之间，当start==end，第k小的数就是start
            int mid = (left + right) / 2;
            // 找二维矩阵中<=mid的元素总个数
            int count = findNotBiggerThanMid(matrix, mid, row, col);
            if (count < k) {
                // 第k小的数在右半部分，且不包含mid
                left = mid + 1;
            } else {
                // 第k小的数在左半部分，可能包含mid
                right = mid;
            }
        }
        return right;
    }

    private int findNotBiggerThanMid(int[][] matrix, int mid, int row, int col) {
        // 以列为单位找，找到每一列最后一个<=mid的数即知道每一列有多少个数<=mid
        int i = row - 1;
        int j = 0;
        int count = 0;
        while (i >= 0 && j < col) {
            if (matrix[i][j] <= mid) {
                // 第j列有i+1个元素<=mid
                count += i + 1;
                j++;
            } else {
                // 第j列目前的数大于mid，需要继续在当前列往上找
                i--;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        KthSmallestEle test=new KthSmallestEle();
        int[][] matrix={{1,5,9},{10,11,13},{12,13,15}};
        int num=test.kthSmallest_1(matrix,8);
        System.out.println(num);
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

总结

本题来源于Leetcode中 归属于堆类型题目。
同许多在算法道路上不断前行的人一样，不断练习，修炼自己！
如有博客中存在的疑问或者建议，可以在下方留言一起交流，感谢各位！

觉得本博客有用的客官，可以给个赞鼓励下！ 嘿嘿