（LeetCode）973. 最接近原点的 K 个点——优先队列，自定义sort排序

我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。

（这里，平面上两点之间的距离是欧几里德距离。）

你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。

示例 1：

输入：points = [[1,3],[-2,2]], K = 1 输出：[[-2,2]] 解释： (1, 3) 和原点之间的距离为
sqrt(10)， (-2, 2) 和原点之间的距离为 sqrt(8)， 由于 sqrt(8) < sqrt(10)，(-2, 2)
离原点更近。 我们只需要距离原点最近的 K = 1 个点，所以答案就是 [[-2,2]]。
示例 2：

输入：points = [[3,3],[5,-1],[-2,4]], K = 2 输出：[[3,3],[-2,4]] （答案
[[-2,4],[3,3]] 也会被接受。）

提示：

1 <= K <= points.length <= 10000
-10000 < points[i][0] < 10000
-10000 < points[i][1] < 10000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/k-closest-points-to-origin
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

优先队列

i.小顶堆

public class Solution973 {
    public int[][] kClosest(int[][] points, int K) {
        PriorityQueue<point> queue = new PriorityQueue<>(new Comparator<point>() {
            @Override
            public int compare(point o1, point o2) {
                if(o1.distance < o2.distance){
                    return -1;
                }else if(o1.distance == o2.distance){
                    return 0;
                }else{
                    return 1;
                }
            }
        });
        for(int[] i : points){
            int distancePow = (int)Math.pow(i[0],2)+(int)Math.pow(i[1],2);
            queue.add(new point(i,distancePow));
        }
        int[][] array = new int[K][2];
        for(int i = 0;i < K;i++){
            array[i] = queue.poll().p;
        }
        return array;
    }
}

class point{
    int[] p = new int[2];
    int distance;
    public point(int[] p,int distance){
        this.p = p;
        this.distance = distance;
    }
}

ii.大顶堆（总感觉哪里不太对……

public class Solution973_3 {
    public int[][] kClosest(int[][] points, int K) {
        PriorityQueue<point> queue = new PriorityQueue<>(new Comparator<point>() {
            @Override
            public int compare(point o1, point o2) {
                if(o1.distance < o2.distance){
                    return 1;
                }else if(o1.distance == o2.distance){
                    return 0;
                }else{
                    return -1;
                }
            }
        });
        for(int i = 0;i < K;i++){
            queue.add(new point(points[i],(int)(Math.pow(points[i][0],2)+Math.pow(points[i][1],2))));
        }
        for(int i = K;i < points.length;i++){
            queue.add(new point(points[i],(int)(Math.pow(points[i][0],2)+Math.pow(points[i][1],2))));
            queue.poll();
        }
        int[][] array = new int[K][2];
        int i = 0;
        while(i<K){
            array[i] = queue.poll().p;
            i++;
        }
        return array;
    }
}

自定义sort排序

我原以为会比优先队列快，是我想多了……
还是得认真学一下时间复杂度……

i.

public class Solution973_2 {
    public int[][] kClosest(int[][] points, int K) {
        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                int dif = (int)Math.pow(o1[0],2)+(int)Math.pow(o1[1],2)-(int)Math.pow(o2[0],2)-(int)Math.pow(o2[1],2);
                if(dif < 0){
                    return -1;
                }else if(dif == 0){
                    return 0;
                }else{
                    return 1;
                }
            }
        });
        return Arrays.copyOf(points,K);
    }
}

ii.这个最后三组数据超时了orz

public class Solution973_1 {
    public int[][] kClosest(int[][] points, int K) {
        int[][] array = new int[K+1][2];
        for(int i = 0;i < K;i++){
            array[i] = points[i];
        }
        for(int i = K;i < points.length;i++){
            array[K] = points[i];
            Arrays.sort(array, new Comparator<int[]>() {
                @Override
                public int compare(int[] o1, int[] o2) {
                    int dif = (int)Math.pow(o1[0],2)+(int)Math.pow(o1[1],2)-(int)Math.pow(o2[0],2)-(int)Math.pow(o2[1],2);
                    if(dif < 0){
                        return -1;
                    }else if(dif == 0){
                        return 0;
                    }else{
                        return 1;
                    }
                }
            });
        }
        return Arrays.copyOf(array,K);
    }
}