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