Find the Smallest K Elements in an Array

Given one point P0 on a 2-dimension space. There are n other points on the same space.

Try to find K points which are most closed to P0.

hint:

　　Part of Quick Sort. Just sort the useful part of the array.

public class findKPoints {
    class Point {
        int x;
        int y;
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    
    Point p0;
    ArrayList<Point> points = new ArrayList<Point>();
    int k;

    public void setSpace() {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Please set the position of p0 in format 'x,y':");
        try {
            String[] str = reader.readLine().split(",");
            this.p0 = new Point(Integer.parseInt(str[0]), Integer.parseInt(str[1]));
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
        System.out.println("Please set the position of other points in format 'x,y', type 'OK' when done:");
        try {
            String tmp = reader.readLine();
            while (!tmp.equals("OK")) {
                String[] str = tmp.split(",");
                this.points.add(new Point(Integer.parseInt(str[0]), Integer.parseInt(str[1])));
                tmp = reader.readLine();
            }
            if (this.points.size()==0) {
                System.err.print("no other points on the space");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("Please give the number of closest points you want to find:");
        try {
            this.k = Integer.parseInt(reader.readLine());
            if (k > points.size()) {
                System.err.println("not enough points");
                System.exit(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public void find() {
        int[][] dist = new int[points.size()][2];
        for (int i = 0; i < points.size(); i++) {
            dist[i][0] = calculateDis(p0, points.get(i));
            dist[i][1] = i;
        }
        sort(dist, k, 0, dist.length-1);
        for (int i = 0; i < k; i++) {
            int p = dist[i][1];
            System.out.print("("+points.get(p).x+", "+points.get(p).y+") ");
        }
        System.out.println();
    }
    
    public void sort(int[][] dist, int k, int start, int end) {
        int dis = dist[start][0];
        int p = dist[start][1];
        int i = start, j = end;
        while (i < j) {
            while (i < j && dist[j][0] >= dis) {
                j--;
            }
            dist[i][0] = dist[j][0]; 
            dist[i][1] = dist[j][1];
            while (i<j && dist[i][0] < dis) {
                i++;
            }
            dist[j][0] = dist[i][0]; 
            dist[j][1] = dist[i][1];
        }
        dist[i][0] = dis; 
        dist[i][1] = p;
        if (i-start == k-1) {
            return;
        } else if (i-start > k-1) {
            sort(dist, k, start, i);
        } else {
            sort(dist, k-(i-start+1), i+1, end);
        }
    }
    
    public int calculateDis(Point p1, Point p2) {
        return ((p1.x-p2.x)*(p1.x-p2.x) + (p1.y-p2.y)*(p1.y-p2.y));
    }
    
    public static void main(String[] args) {
        findKPoints kp = new findKPoints();
        kp.setSpace();
        kp.find();
    }
}

The execute of the program

Please set the position of p0 in format 'x,y':
0,0
Please set the position of other points in format 'x,y', type 'OK' when done:
1,1
1,3
-1,0
1,2
4,4
2,1
0,2
OK
Please give the number of closest points you want to find:
5
(-1, 0) (1, 1) (0, 2) (1, 2) (2, 1)