算法导论第四版学习——习题五Kd-Tree

题目正文：

http://coursera.cs.princeton.edu/algs4/assignments/kdtree.html

作业难点：

如何组织自己的数据结构是本道题的最难点，基本上有思路就肯定可以完成。题目一定要看仔细，基本上2dtree部分已经把实现原理说清楚了。

作业技巧：

1、逐步实现，实现完成后用insert、contain测试下，没问题再写draw，测试没问题再写其余的。

2、重复输入的问题不要忘了

3、range虽然api里写的是all point inside the rectangle，但是你必须把边界上的点也算进去

4、java不像C#可以传参数前面加ref或out，所以必须在递归的时候返回Point

5、比较容易疏忽的是子节点在分界线上部或者下部的处理是不一样的，你认为左边是右子树，上边是左子树都没关系。最后结果不会有问题

代码参考：

（这是我自己亲测100分的答案，不代表写得最好，请在自己实在完成不了的时候再看，不然的话做这个题目的意义一点都没有）

import edu.princeton.cs.algs4.Point2D;
import edu.princeton.cs.algs4.RectHV;
import edu.princeton.cs.algs4.SET;

import java.util.Stack;


public class PointSET {
    private SET<Point2D> pointSet;

    public PointSET() // construct an empty set of points 
     {
        pointSet = new SET<Point2D>();
    }

    private void checkNull(Object obj) {
        if (obj == null) {
            throw new NullPointerException();
        }
    }

    public boolean isEmpty() // is the set empty? 
     {
        return pointSet.isEmpty();
    }

    public int size() // number of points in the set 
     {
        return pointSet.size();
    }

    public void insert(Point2D p) // add the point to the set (if it is not already in the set)
     {
        checkNull(p);
        pointSet.add(p);
    }

    public boolean contains(Point2D p) // does the set contain point p? 
     {
        checkNull(p);

        return pointSet.contains(p);
    }

    public void draw() // draw all points to standard draw 
     {
        for (Point2D p : pointSet) {
            p.draw();
        }
    }

    public Iterable<Point2D> range(RectHV rect) // all points that are inside the rectangle 
     {
        checkNull(rect);

        Stack<Point2D> stack = new Stack<Point2D>();

        for (Point2D p : pointSet) {
            if ((p.x() >= rect.xmin()) && (p.x() <= rect.xmax()) &&
                    (p.y() >= rect.ymin()) && (p.y() <= rect.ymax())) {
                stack.push(p);
            }
        }

        return stack;
    }

    public Point2D nearest(Point2D p) // a nearest neighbor in the set to point p; null if the set is empty 
     {
        checkNull(p);

        Point2D point = null;

        for (Point2D setp : pointSet) {
            if ((point == null) ||
                    (p.distanceSquaredTo(point) > p.distanceSquaredTo(setp))) {
                point = setp;
            }
        }

        return point;
    }

    public static void main(String[] args) // unit testing of the methods (optional) 
     {
    }
}

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.Point2D;
import edu.princeton.cs.algs4.RectHV;
import edu.princeton.cs.algs4.StdDraw;
import edu.princeton.cs.algs4.StdOut;

import java.util.Stack;


public class KdTree {
    private PointNode root;
    private int pointCount;

    public KdTree() // construct an empty set of points 
     {
        root = null;
        pointCount = 0;
    }

    private void checkNull(Object obj) {
        if (obj == null) {
            throw new NullPointerException();
        }
    }

    public boolean isEmpty() // is the set empty? 
     {
        return root == null;
    }

    public int size() // number of points in the set 
     {
        return pointCount;
    }

    public void insert(Point2D p) // add the point to the set (if it is not already in the set)
     {
        checkNull(p);

        if (root == null) {
            root = new PointNode(p, null, false);
            pointCount++;
        } else {
            PointNode current = root;

            while (true) {
              if (current.value.compareTo(p) == 0) {
                return;
              }
                if (current.isAtLeftSideOfNode(p)) {
                    if (current.left == null) {
                        current.left = new PointNode(p, current, true);
                        pointCount++;
                        break;
                    } else {
                        current = current.left;
                    }
                } else {
                    if (current.right == null) {
                        current.right = new PointNode(p, current, false);
                        pointCount++;
                        break;
                    } else {
                        current = current.right;
                    }
                }
            }
        }
    }

    public boolean contains(Point2D p) // does the set contain point p? 
     {
        checkNull(p);

        PointNode current = root;

        while (current != null) {
            if (current.value.compareTo(p) == 0) {
                return true;
            } else if (current.isAtLeftSideOfNode(p)) {
                current = current.left;
            } else {
                current = current.right;
            }
        }

        return false;
    }

    public void draw() // draw all points to standard draw 
     {
        if (root != null) {
            root.draw(null, false);
        }
    }

    private void addToStack(Stack<Point2D> stack, PointNode current, RectHV rect) {
        
        if (!rect.intersects(current.rect)) {
            return;
        }

        if ((current.value.x() >= rect.xmin()) &&
                (current.value.x() <= rect.xmax()) &&
                (current.value.y() >= rect.ymin()) &&
                (current.value.y() <= rect.ymax())) {
            stack.push(current.value);
        }

        if (current.left != null) {
            addToStack(stack, current.left, rect);
        }

        if (current.right != null) {
            addToStack(stack, current.right, rect);
        }
    }

    private Point2D searchNode(Point2D toSearch, PointNode current,
        Point2D nearestPoint) {
        if (nearestPoint == null) {
            nearestPoint = current.value;
        }

        double distance = nearestPoint.distanceSquaredTo(toSearch);
        double newdistance = current.value.distanceSquaredTo(toSearch);

        if ((distance >= current.rect.distanceSquaredTo(toSearch)) ||
                (distance >= newdistance)) {
            if (distance > newdistance) {
                nearestPoint = current.value;
            }

            if ((current.isH && (toSearch.y() > current.value.y())) ||
                    (!current.isH && (toSearch.x() < current.value.x()))) {
                if (current.left != null) {
                    nearestPoint = searchNode(toSearch, current.left,
                            nearestPoint);
                }

                if (current.right != null) {
                    nearestPoint = searchNode(toSearch, current.right,
                            nearestPoint);
                }
            } else {
                if (current.right != null) {
                    nearestPoint = searchNode(toSearch, current.right,
                            nearestPoint);
                }

                if (current.left != null) {
                    nearestPoint = searchNode(toSearch, current.left,
                            nearestPoint);
                }
            }
        }

        return nearestPoint;
    }

    public Iterable<Point2D> range(RectHV rect) // all points that are inside the rectangle 
     {
        checkNull(rect);

        Stack<Point2D> stack = new Stack<Point2D>();
        if (root != null)
          addToStack(stack, root, rect);

        return stack;
    }

    public Point2D nearest(Point2D p) // a nearest neighbor in the set to point p; null if the set is empty 
     {
        checkNull(p);

        Point2D point = null;
        if (root != null)
          point = searchNode(p, root, point);

        return point;
    }

    public static void main(String[] args) // unit testing of the methods (optional) 
     {
        String filename = args[0];
        In in = new In(filename);

        KdTree kdtree = new KdTree();

        while (!in.isEmpty()) {
            double x = in.readDouble();
            double y = in.readDouble();
            Point2D p = new Point2D(x, y);
            kdtree.insert(p);
        }

        kdtree.draw();
    }

    private static class PointNode {
        private PointNode left;
        private PointNode right;
        private RectHV rect;
        private Point2D value;
        private boolean isH;

        public PointNode(Point2D p, PointNode parent, boolean isLeftUp) {
            value = p;
            left = null;
            right = null;
            if (parent == null) {
                isH = false;
                rect = new RectHV(0, 0, 1, 1);
            } else {
                isH = !parent.isH;

                if (isH) {
                    if (isLeftUp) {
                        rect = new RectHV(parent.rect.xmin(),
                                parent.rect.ymin(), parent.value.x(),
                                parent.rect.ymax());
                    } else {
                        rect = new RectHV(parent.value.x(), parent.rect.ymin(),
                                parent.rect.xmax(), parent.rect.ymax());
                    }
                } else {
                    if (isLeftUp) {
                        rect = new RectHV(parent.rect.xmin(), parent.value.y(),
                                parent.rect.xmax(), parent.rect.ymax());
                    } else {
                        rect = new RectHV(parent.rect.xmin(),
                                parent.rect.ymin(), parent.rect.xmax(),
                                parent.value.y());
                    }
                }
            }
        }

        public void draw(PointNode parent, boolean isLeftUp) {
            StdOut.println(isLeftUp ? "leftup" : "rightdown");
            StdDraw.setPenColor(StdDraw.BLACK);
            StdDraw.setPenRadius(0.01);
            value.draw();
            StdDraw.setPenRadius();

            if (parent == null) {
                StdDraw.setPenColor(StdDraw.RED);
                new Point2D(value.x(), 1).drawTo(new Point2D(value.x(), 0));
            } else {
                StdOut.println(value);
                StdOut.println(parent.rect);

                if (parent.isH) {
                    StdDraw.setPenColor(StdDraw.RED);
                    new Point2D(value.x(), rect.ymin()).drawTo(new Point2D(
                            value.x(), rect.ymax()));
                } else {
                    StdDraw.setPenColor(StdDraw.BLUE);
                    new Point2D(rect.xmax(), value.y()).drawTo(new Point2D(
                            rect.xmin(), value.y()));
                }
            }

            StdDraw.pause(100);

            if (left != null) {
                left.draw(this, true);
            }

            if (right != null) {
                right.draw(this, false);
            }
        }

        public boolean isAtLeftSideOfNode(Point2D p) {
            if (isH) {
                return p.y() > value.y();
            } else {
                return p.x() < value.x();
            }
        }
    }
}