KD-Tree which nodes are visited when finding nearest neighbor - algorithm

Question

Given these points (7,3), (10,5), (9,0), (5,8), (3,2), (8,1), I need to create a balanced KD Tree such that the first level of the KD Tree is split along the x-axis, and when there are two medians we pick the “larger” one as the root of subtree. After building it I need to list the nodes that get visited when trying to find the nearest neighbor of the point (2,4). Here is the tree I built using given points above:
Here is the KD-Tree I've built
Im very confused about finding the nearest neighbor, And i have to list the nodes that get visited when the tree is finding the point (2,4). So far I think it visits (8,1) -> (7,3) -> (5,8). But what comes after that?? Which nodes get visited?

Answer 1

Your k-d tree is correct.
Nearest-neighbor algorithm
The k-d tree nearest-neighbor search traverses the tree by alternating between two phases:
Go-down phase:
Note the distance between your input point and the current node in the tree (the actual distance, not the distance on an axis).
Alternating between x-axis and y-axis, compare the axis-coordinate of your input point with the axis-coordinate of the current node in the tree to determine which sub-tree to go down to.
Repeat Go-down phase until you reached the bottom of the tree, then enter Go-back-up phase.
Go-back-up phase:
Go up one level. If you can't go up, you are done.
If you already did a Go-down phase on both sub-trees of the current node, repeat Go-back-up.
If the actual distance to the best neighbor you have found so far is closer than the axis-distance between your input node and the current node in the tree, repeat Go-back-up.
Otherwise, enter Go-down phase on the sub-tree opposite to the one from where you came.
Your example
Here is a sketch of your k-d tree to make it more clear:
Applying these steps on your example tree and input node (2,4):
Start with Go-down phase at the root node (8,1).
Distance between (8,1) and input node (2,4) is 6.708, so (8,1) is our currently known nearest neighbor. The current axis is x, so we compare 8 and 2 and we see we have to go to the left sub-tree.
Current node is (7,3). Distance between (7,3) and input node (2,4) is 5.099, which is better than the previous best-known distance, so (7,3) becomes our new nearest neighbor. The current axis is y, so we compare 3 and 4 and we see have to go to the right sub-tree.
Current node is (5,8). Distance between (5,8) and input node (2,4) is 5.000, which is smaller than the previous best-known distance, so (5,8) becomes our new nearest neighbor. Current axis is x, but we cannot go down any further, so we enter Go-back-up phase.
We go back up to (7,3). Current axis is y. The y-distance between (7,3) and the input node (2,4) is |3-4| = 1, which is smaller than 5, the distance to the currently known nearest neighbor. Therefore, we have to enter Go-back-down phase on the other sub-tree. You can see it in the picture: The distance between the input point (S) and (5,8) is greater than the distance between (S) and the separation line that goes through (7,3). This means there could be a nearer neighbor on the other side of the separation line.
Current node is (3,2). Distance between (3,2) and input node (2,4) is 2.236 which is better than the previously known best distance, so (3,2) becomes our currently known closest neighbor. The current axis is x, but we cannot go any further, so we enter Go-back-up phase.
We go back up to (7,3). Current axis is y. We visited both sub-trees of this node, so we repeat Go-back-up phase.
We go back up to (8,1). Current axis is x. The x-distance between (8,1) and the input node (2,4) is |8-2| = 6, which is larger than the distance to the currently known closest neighbor, so we repeat Go-back-up phase. You can again see it in the picture: The distance between the input point (S) and the current nearest neighbor (3,2) is smaller than the distance between (S) and the separation line that goes through (8,1). This means that there cannot be a nearer neighbor on the other side of the separation line.
We cannot go up any further, so we are done.
The nodes we visited were: (8,1), (7,3), (5,8), (7,3), (3,2), (7,3), (8,1). The nearest neighbor we found was (3,2) with distance 2.236.

Answer 2

I use this code in a similar issue, of course you should use x and y instead of lat and lon, I hope I could help.
class LocationKDTree {
private static final int K = 3; // 3-d tree
private final Node tree;
public LocationKDTree(#Nonnull final List<Location> locations) {
final List<Node> nodes = new ArrayList<>(locations.size());
for (final Location location : locations) {
nodes.add(new Node(location));
}
tree = buildTree(nodes, 0);
}
#Nullable
public Location findNearest(final double latitude, final double longitude) {
final Node node = findNearest(tree, new Node(latitude, longitude), 0);
return node == null ? null : node.location;
}
private static Node findNearest(final Node current, final Node target, final int depth) {
final int axis = depth % K;
final int direction = getComparator(axis).compare(target, current);
final Node next = (direction < 0) ? current.left : current.right;
final Node other = (direction < 0) ? current.right : current.left;
Node best = (next == null) ? current : findNearest(next, target, depth + 1);
if (current.euclideanDistance(target) < best.euclideanDistance(target)) {
best = current;
}
if (other != null) {
if (current.verticalDistance(target, axis) < best.euclideanDistance(target)) {
final Node possibleBest = findNearest(other, target, depth + 1);
if (possibleBest.euclideanDistance(target) < best.euclideanDistance(target)) {
best = possibleBest;
}
}
}
return best;
}
#Nullable
private static Node buildTree(final List<Node> items, final int depth) {
if (items.isEmpty()) {
return null;
}
Collections.sort(items, getComparator(depth % K));
final int index = items.size() / 2;
final Node root = items.get(index);
root.left = buildTree(items.subList(0, index), depth + 1);
root.right = buildTree(items.subList(index + 1, items.size()), depth + 1);
return root;
}
private static class Node {
Node left;
Node right;
Location location;
final double[] point = new double[K];
Node(final double latitude, final double longitude) {
point[0] = (double) (cos(toRadians(latitude)) * cos(toRadians(longitude)));
point[1] = (double) (cos(toRadians(latitude)) * sin(toRadians(longitude)));
point[2] = (double) (sin(toRadians(latitude)));
}
Node(final Location location) {
this(location.latitude, location.longitude);
this.location = location;
}
double euclideanDistance(final Node that) {
final double x = this.point[0] - that.point[0];
final double y = this.point[1] - that.point[1];
final double z = this.point[2] - that.point[2];
return x * x + y * y + z * z;
}
double verticalDistance(final Node that, final int axis) {
final double d = this.point[axis] - that.point[axis];
return d * d;
}
}
private static Comparator<Node> getComparator(final int i) {
return NodeComparator.values()[i];
}
private static enum NodeComparator implements Comparator<Node> {
x {
#Override
public int compare(final Node a, final Node b) {
return Double.compare(a.point[0], b.point[0]);
}
},
y {
#Override
public int compare(final Node a, final Node b) {
return Double.compare(a.point[1], b.point[1]);
}
},
z {
#Override
public int compare(final Node a, final Node b) {
return Double.compare(a.point[2], b.point[2]);
}
}
}
}
and location class :
class Location {
public double latitude;
public double longitude;
public String name;
}