HashMap 数组应用面试题（Point）

今天看了一题面试题，以为很简单，不过自己写了遍，没有完全写出来：

题目是这样的：

给定一些 points 和一个 origin，从 points 中找到 k 个离 origin 最近的点。按照距离由小到大返回。如果两个点有相同距离，则按照x值来排序；若x值也相同，就再按照y值排序。

样例
　　给出 points = [[4,6],[4,7],[4,4],[2,5],[1,1]], origin = [0, 0], k = 3
　　返回 [[1,1],[2,5],[4,4]]

首先我们先创建一个Point类

package work;

public class Point {
    private int x;
    private int y;
    
    
    public Point(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    @Override
    public String toString() {
        return " [" + x +","+ y + "]";
    }
    
    public Point getPoint(Point x){
        return x;
    }
    
}

再创建一个main方法，用来调用函数和执行程序

public class Solution {

    public static void main(String[] args) {
        Point[] points = new Point[4];
        points[0] = new Point(5, 5);

        points[1] = new Point(7, 8);
        points[2] = new Point(2, 5);
        points[3] = new Point(4, 7);

        Point point = new Point(4, 4);

        Point[] s = kClosest(points, point, 3);
        for (Point p : s) {
            System.out.println(p);
        }

    }
｝

根据题目要求，我们可以封装一个求点点之间距离的方法，直接放在main方法下面

public static double lengths(Point points, Point origin) {

        return Math.sqrt(Math.pow(Math.abs(points.getX() - origin.getX()), 2)
                + Math.pow(Math.abs(points.getY() - origin.getY()), 2));
    }

最后就是我们的重点了，实现函数并返回一个point数组

public static Point[] kClosest(Point[] points, Point origin, int k) {
        if (k > points.length) {
            Point p = new Point(0, 0);
            Point[] arrLength = new Point[1];
            arrLength[0] = p;
            return arrLength;
        }
        Point[] arrLength = new Point[points.length];
        HashMap<Point, Double> allPoint = new HashMap<Point, Double>();
        for (int i = 0; i < points.length; i++) {
            double length1 = lengths(points[i], origin);
            allPoint.put(points[i], length1);
        }
        Set<Point> set = allPoint.keySet();

        Iterator<Point> ite = set.iterator();
        int count = 0;
        //循环迭代器
        while (ite.hasNext()) {
            //获取map中的key
            Point ts = ite.next();
            
            //下标为0的时候，把key赋值到arrLength数组
            Point s=null;
            if (count == 0) {
                
                arrLength[0] = ts.getPoint(ts);
                
            } else {
                //当前下标数组获取值
                arrLength[count]=ts.getPoint(ts);
                
                //当计数大于0的时候，进行循环判断
                for (int n = 0; n < count; n++) {
                    
                    //判断当前的L长度与数组里面所有L比较，判断大于L的n
                    
                    
                    boolean bl=allPoint.get(ts) < allPoint.get(arrLength[n]);
                    
                    if (bl) {
                        //获取下标n,将n后面的数组值后移一位
                        
                        for (int num = count; num > n; num--) {
                        
                            
                            arrLength[num] = arrLength[num-1];

                        }
                        arrLength[n]=ts.getPoint(ts);
                        
                        break;
                    }
                    
                }
            }
            count++;
            
        }
        

        Point[] arrLength1 = new Point[k];

        System.arraycopy(arrLength, 0, arrLength1, 0, k);

        return arrLength1;
    }

功能基本实现，由于个人比较懒惰，所以没有对相同距离x，y坐标的判断。

也是个人能力有限，很久没有接触这种纯面试题了，看来要好好学习，多操练操练。。。。

 

实现思路：

 

1.先把Point对象和对应到源点长度，前者作为key，后者作为value存在Hashmap里面，由于不考了会重复点，所以point是唯一的；

2.排序对应的value

　　2.1 使用迭代器，获取hashmap对应的key，并把key遍历放进新的数组arrLength；首先把第一个放进去

　　2.2 迭代获取第二个key，并获取value和第一个比较，如果value小于第一个，执行呼唤。

　　2.3 依次判断，每次循环前，数组都是已经从小到大排序，只需要找到第一个大于当前value的point，并把后面所有的Point在数组中下标后移一位。

3.通过K值，来截取数组，并生成新的数组，并return