sort – Find all k points closest to the origin

We have a list of points in the plane. Find K points closest to
the origin (0, 0).

(Here, the distance between two points on a plane is the Euclidean distance
distance.)

You can return the answer in any order. The answer is guaranteed to
to be unique (except in the order in which it is)

Example 1

Entry: points = [[1,3],[-2,2]], K = 1
Exit:[[[[[-2,2]]Explanation:
The distance between (1, 3) and the origin is sqrt (10).
The distance between (-2, 2) and the origin is sqrt (8).
Since sqrt (8) <sqrt (10), (-2, 2) is closer to the origin.
We only want the K = 1 points closest to the origin, so the answer is just[[[[[-2,2]].

Example 2

Entry: points = [[3,3],[5,-1],[-2,4]], K = 2

Exit: [[3,3],[-2,4]](The answer[[[[[-2,4],[3,3]]would also be accepted.)

Note:

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

Also note that there may be a situation where the distance of 2 nodes is equal and can therefore print any node.

=======================================

Here is my approach.

  1. Map of trees taken (so that I can get all sorted distance)
  2. Start filling in the tree map for all points
  3. Finally took the first element k.

    Public class KClosestPointsToOrigin {
    
    public int[][]    kClosest (int[][]    points, int K) {
    
    int ranks = points.length;
    
    
    SortedMap <Double, List> distanceToPoint = new TreeMap <> ();
    
    for (int i = 0; i <lines; i ++) {
    double distance = getDistance (points[i])
    if (Objects.nonNull (distanceToPoint.get (distance)))) {
    listing CoordinatorPointList = distanceToPoint.get (distance);
    CoordinatePointList.add (new CoordinatePoint (points[i][0]points[i][1]));
    } other {
    listing coordinPoints = new ArrayList <> ();
    CoordinatedPoints.add (new CoordinatePoint (points[i][0]points[i][1]));
    distanceToPoint.put (distance, coordinatesPoints); // x and y coordinates.
    }
    }
    
    int[][]    arrayToReturn = new int[K][2];
    int counter = 0;
    for (Double key: distanceToPoint.keySet ()) {
    listing CoordinatedPoints = distanceToPoint.get (key);
    Iterator iterator1 = CoordinatedPoints.iterator ();
    while (iterator1.hasNext () && counter <K) {
    CoordinatePoint coordinPoint = (CoordinatePoint) iterator1.next ();
    arrayToReturn[counter][0]    = coordinPoint.x;
    arrayToReturn[counter][1]    = coordinPoint.y;
    counter ++;
    }
    }
    
    return arrayToReturn;
    }
    
    private double getDistance (int[] point)
    int x = point[0];
    int y = point[1];
    
    int x2 = Math.abs (x) * Math.abs (x);
    int y2 = Math.abs (y) * Math.abs (y);
    
    return Math.sqrt (x2 + y2);
    }
    

    }

    CoordinatePoint {class
    int x;
    int y;

    public CoordinatePoint (int x, int y) {
    this.x = x;
    this.y = y;
    }
    

    }

However, this solution is not effective because the execution and the memory used are important. Can you please help me optimize the solution.