Algorithms assignment5和recursive

这一次作业运用了recursive来写。

public class KdTree {
private static class Node {
private Point2D point;      // the point
private RectHV rect;    // the axis-aligned rectangle corresponding to this node
private Node left;        // the left/bottom subtree
private Node right;        // the right/top subtree
private boolean vertical;
public Node(Point2D p,Node left,Node right,boolean v,RectHV rect){
this.point=p;
this.left=left;
this.right=right;
this.vertical=v;
this.rect=rect;
}
}

private Node root;
private int size;
public KdTree(){                               // construct an empty set of points
root=null;
size=0;
}
public boolean isEmpty(){                        // is the set empty?
return size()==0;
}
public int size(){                               // number of points in the set
return size;
}

public void insert(Point2D p){                   // add the point p to the set (if it is not already in the set)
root=insert(root,p,true,0,0,1,1);
}
private Node insert(Node node, Point2D p, boolean v, double xmin, double ymin, double xmax, double ymax){
// if new node, create it
if(node==null){
size++;
return new Node(p,null,null,v,new RectHV(xmin,ymin,xmax,ymax));
}
// if already in, return it
if (node.point.x() == p.x() && node.point.y() == p.y()) return node;

// else, insert it where corresponds (left - right recursive call)
if (node.vertical){                    //if node is in vertical level or odd level
if(p.x() < node.point.x()){
node.left = insert(node.left, p, !node.vertical, node.rect.xmin(),node.rect.ymin(),node.point.x(),node.rect.ymax());
}else{
node.right = insert(node.right, p, !node.vertical, node.point.x(),node.rect.ymin(),node.rect.xmax(),node.rect.ymax());
}
}else{								   //if node is in horizontal level or even level
if(p.y() < node.point.y()){
node.left = insert(node.left, p, !node.vertical, node.rect.xmin(),node.rect.ymin(),node.rect.xmax(),node.point.y());
}else{
node.right = insert(node.right, p, !node.vertical, node.rect.xmin(),node.point.y(),node.rect.xmax(),node.rect.ymax());
}
}
return node;
}
public boolean contains(Point2D p){              // does the set contain the point p?
return contains(root, p.x(),p.y());
}
private boolean contains(Node node, double x, double y)
{
if (node == null) return false;
if (node.point.x() == x && node.point.y() == y) return true;

if (node.vertical && x < node.point.x() || !node.vertical && y < node.point.y())
return contains(node.left, x, y);
else
return contains(node.right, x, y);
}
public void draw(){                              // draw all of the points to standard draw
draw(root);
}
private void draw(Node node){
if(node==null) return;
// draw the point
StdDraw.setPenColor(StdDraw.BLACK);
StdDraw.setPenRadius(0.01);
node.point.draw();

Point2D min, max;
if (node.vertical) {
StdDraw.setPenColor(StdDraw.RED);
min = new Point2D(node.point.x(), node.rect.ymin());
max = new Point2D(node.point.x(), node.rect.ymax());
} else {
StdDraw.setPenColor(StdDraw.BLUE);
min = new Point2D(node.rect.xmin(), node.point.y());
max = new Point2D(node.rect.xmax(), node.point.y());
}

// draw that division line
StdDraw.setPenRadius();
min.drawTo(max);

// recursively draw children
draw(node.left);
draw(node.right);
}
public Iterable<Point2D> range(RectHV rect){     // all points in the set that are inside the rectangle
Stack<Point2D> s = new Stack<Point2D>();
range(rect, root, s);
return s;
}
private void range(RectHV rect, Node node, Stack<Point2D> s){
if(node==null) return;
if(node.rect.intersects(rect)){
if(rect.contains(node.point)){
s.push(node.point);
}
range(rect,node.left,s);
range(rect,node.right,s);
}
}
public Point2D nearest(Point2D p){               // a nearest neighbor in the set to p; null if set is empty
return nearest(root,p,null);
}
private Point2D nearest(Node x, Point2D p, Point2D candidate) {
if (x == null) return candidate;      // if empty or the tree is searched over, return null or the presently nearest one

if(candidate==null){               // if x equals root, the nearest point is root
candidate=x.point;
}

double nearestD = candidate.distanceSquaredTo(p);

double distanceToPoint = x.point.distanceSquaredTo(p);

if(nearestD>x.rect.distanceSquaredTo(p)){         // judge whether this node and its subtree need to be processed
if(distanceToPoint<nearestD){
candidate=x.point;
}
if (x.left != null && x.right != null && x.left.rect.distanceSquaredTo(p) < x.right.rect.distanceSquaredTo(p)) {
candidate=nearest(x.left, p, candidate);
candidate=nearest(x.right, p, candidate);
}else{
candidate=nearest(x.right, p, candidate);
candidate=nearest(x.left, p, candidate);
}
}
return candidate;
}

}

有疑问可以看《Algorithms 4th Edition》399页的BST写法来加深理解，399页的get，由于方便，加上要递归，本来的get只有要get的参数，没有从哪里开始搜索，所以要加上root，所以分两个get写。

如果两个都是return value，那么直接return。如果像put这样，写的是void，那么就是root=put(root, key, val) 仔细看书上recursive的运用。这次的作业就是照着BST的写法写，也可以看github别人写的：https://gist.github.com/agjacome/5246693#file-kdtree-java-L85