2025年- G28-Lc102-973. K 个距离原点最近的点--java版

1.题目描述

给定一个点的列表 points，其中每个点的坐标表示为 [xi, yi]，以及一个整数 k，表示需要找到距离原点 (0,0) 最近的 k 个点。

2.思路

思路一:
首先输入是一个二维数组，然后开始计算二维数组忠每个元素（每一个点）与原点直接的距离（可以直接对每个点求勾股定理），最后输出是离原点距离最近的点（k代表返回的点的个数），按升序排序。

思路二：
用优先级队列[PiorityQueue默认是小根堆，但是可以改变比较器的规则（comparetor，让他变成大根堆）。]，把每个坐标的欧式距离入堆之后，用对象.size()的方法，列出总共的元素，根据题目要求要前k跟原点近的点的欧式距离，保留前k个，其他用对象.poll()按最大开始剔除，直到剩最小的k个，最后用一个二维数组输出。

在 PriorityQueue 中，标准的 poll() 方法并不接受任何参数。

3.代码实现

import java.util.PriorityQueue;

public class Solution06 {
    public int[][] kClosest(int[][] points, int k) {

        // 创建最大堆，按照 (x² + y²) 从大到小排序，创建和声明最大堆，此时堆是空的
        PriorityQueue<int[]> s1=new PriorityQueue<>(
                (a,b)->Integer.compare(distance(b),distance(a))
        );
        //遍历每个点，联系：一个求距离的算法。
        for(int[] point:points)
        {
            s1.offer(point);//加入堆
            if (s1.size()>k)
            {
                s1.poll();//只保留最近的 k 个点,也就是把大根堆大的点剔除掉，剩下k个小的元素
            }
        }
        //输出剩下的k个二维数组,有k个点，2代表每个坐标都有x，y，也就是两列
        int[][] reasult=new int[k][2];
        int index=0;
        for(int[] subpoint:s1)
        {
           reasult[index]=subpoint;
           index++;
        }
        return reasult;
//        int[][] result = new int[k][2];
//        for (int i = 0; i < k; i++) {
//            result[i] = s1.poll();
//        }
//        return result;
    }




    private static int distance(int[] point)
    {
        return point[0]*point[0]+point[1]*point[1];
    }


}

带main方法验证的代码：

import java.util.PriorityQueue;
import java.util.Arrays;
public class Solution06 {
    public int[][] kClosest(int[][] points, int k) {

        // 创建最大堆，按照 (x² + y²) 从大到小排序，创建和声明最大堆，此时堆是空的
        PriorityQueue<int[]> s1=new PriorityQueue<>(
                (a,b)->Integer.compare(distance(b),distance(a))
        );
        //遍历每个点，联系：一个求距离的算法。
        for(int[] point:points)
        {
            s1.offer(point);//加入堆
            if (s1.size()>k)
            {
                s1.poll();//只保留最近的 k 个点,也就是把大根堆大的点剔除掉，剩下k个小的元素
            }
        }
        //输出剩下的k个二维数组,有k个点，2代表每个坐标都有x，y，也就是两列
        int[][] reasult=new int[k][2];
        int index=0;
        for(int[] subpoint:s1)
        {
           reasult[index]=subpoint;
           index++;
        }
        return reasult;
//        int[][] result = new int[k][2];
//        for (int i = 0; i < k; i++) {
//            result[i] = s1.poll();
//        }
//        return result;
    }




    private static int distance(int[] point)
    {
        return point[0]*point[0]+point[1]*point[1];
    }

   public static void main(String args[])
   {
       Solution06 test=new Solution06();
       int[][] point1={{1, 3}, {-2, 2}};
       int k1=1;
       System.out.println("输出与原点最近的点：");
       printResult(test.kClosest(point1,k1));

   }
    // 打印二维数组的方法
    private static void printResult(int[][] result) {
//        for (int[] point : result) {
//            System.out.println(Arrays.toString(point));
//        }
//        System.out.println();
        for(int[] rePoint:result)
        {
            System.out.println(Arrays.toString(rePoint));
        }
    }

}

带main方法的测试代码：

import java.util.PriorityQueue;
import java.util.Arrays;
public class Solution06 {
    public int[][] kClosest(int[][] points, int k) {

        // 创建最大堆，按照 (x² + y²) 从大到小排序，创建和声明最大堆，此时堆是空的
        PriorityQueue<int[]> s1=new PriorityQueue<>(
                (a,b)->Integer.compare(distance(b),distance(a))
        );
        //遍历每个点，联系：一个求距离的算法。
        for(int[] point:points)
        {
            s1.offer(point);//加入堆
            if (s1.size()>k)
            {
                s1.poll();//只保留最近的 k 个点,也就是把大根堆大的点剔除掉，剩下k个小的元素
            }
        }
        //输出剩下的k个二维数组,有k个点，2代表每个坐标都有x，y，也就是两列
        int[][] reasult=new int[k][2];
        int index=0;
        for(int[] subpoint:s1)
        {
           reasult[index]=subpoint;
           index++;
        }
        return reasult;
//        int[][] result = new int[k][2];
//        for (int i = 0; i < k; i++) {
//            result[i] = s1.poll();
//        }
//        return result;
    }




    private static int distance(int[] point)
    {
        return point[0]*point[0]+point[1]*point[1];
    }

//   public static void main(String args[])
//   {
//       Solution06 test=new Solution06();
//       int[][] point1={{1, 3}, {-2, 2}};
//       int k1=1;
//       System.out.println("输出与原点最近的点：");
//       printResult(test.kClosest(point1,k1));
//
//   }
//    // 打印二维数组的方法
//    private static void printResult(int[][] result) {
        for (int[] point : result) {
            System.out.println(Arrays.toString(point));
        }
        System.out.println();
//        for(int[] rePoint:result)
//        {
//            System.out.println(Arrays.toString(rePoint));
//        }
//    }

    public static void main(String[] args) {
        Solution06 solution = new Solution06();

        int[][] points1 = {{1, 3}, {-2, 2}};
        int k1 = 1;
        System.out.println("Test Case 1:");
        int[][] result1 = solution.kClosest(points1, k1);
        for (int[] point : result1) {
            System.out.println(Arrays.toString(point));
        }
        System.out.println();

        int[][] points2 = {{3, 3}, {5, -1}, {-2, 4}};
        int k2 = 2;
        System.out.println("Test Case 2:");
        int[][] result2 = solution.kClosest(points2, k2);
        for (int[] point : result2) {
            System.out.println(Arrays.toString(point));
        }
        System.out.println();
    }

}