K-D Tree in Data Structures

Introduction

The K-D tree, also known as the K dimension tree, serves as a prominent data structure for the organization of points in multidimensional space, often when K represents a considerably high number. The allure of these structures lies in their ability to facilitate diverse methods of searching in the realm of multidimensional spaces, including range and nearest-neighbor searches.

K-D Trees: The Framework

Every node within a binary tree is a manifestation of a "K-D Tree" and corresponds to a point in the K-dimensional space. The space itself is divided into two realms through the hyperplanes, which each non-leaf node in the tree embodies. The chosen axis, corresponding to one of the K dimensions, aligns itself parallel to these hyperplanes.

The selection of an axis can be approached through various methodologies, though the most conventional approach entails cycling sequentially through each of the K dimensions before defining a midpoint to enact the division of the space.

Unlocking the Mechanics of a K-D Tree

At its heart, the K-D tree operates as a binary tree, with each node representing a k-dimensional point, thereby bifurcating the space into two distinct half-spaces. Here's a closer examination of the process:

Dimension Selection: The initial step revolves around the selection of a dimension. In a 2D K-D tree, a toggling process ensues between the x and y dimensions, while in higher dimensions, it cycles through the coordinates.
Discovering the Median: Within the dimension selected, the median point is unveiled by assessing the values within that specific dimension. This median point subsequently takes the throne as the root node of the tree.
Dividing the Territory: The dataset gets segmented into two subsets, with one being home to the points residing on one side of the median and the other harboring points on the opposing side. These subsets establish connections with the left and right subtrees of the root node.
Recursive Unfolding: Steps 1 through 3 enter a realm of recursion, as each of the subtrees undergoes a repetition of the process. The outcome is a tree structure where every node embodies a median point within a distinct dimension.

The Blueprint for Constructing a K-D Tree

The construction of a K-D Tree hinges on the recursive division of points within space to yield a binary tree. The journey commences by selecting an axis. Subsequently, the remaining points are partitioned into two subsets based on their location concerning the partitioning hyperplane. This partitioning involves the selection of the midpoint along the axis.

Algorithm 1: Creating a K-D Tree

Function kdtree (pointList, depth):
	Input: a list of points, pointList, and an integer, depth;
	Output: a k-d tree rooted at the median point of pointList: 
	/* Select axis based on depth so that axis cycles through all valid values */
	let axis: =depth mod k;
	/* Sort point list and choose median as pivot element  */
	select median by aris from point List;
	/* Create node and construct subtree */
	let node.location:= median;
	let node.leftChild: kdtree(points in pointList before median,
	depth + 1):
	let node.rightChild: kdtree(points in pointList after median,
	depth + 1);
	return node;

When correctly executed, the resulting tree maintains balance, with every leaf node residing at an approximate equidistance from the root. To achieve this equilibrium, it is imperative to consistently opt for the median point. Additionally, it's noteworthy that pinpointing the median introduces complexity, necessitating the employment of a distinct algorithm. Failure to select the median point may result in an imbalanced tree. To address this, one approach involves employing a sorting algorithm to arrange points along the chosen axis and leveraging the median of these points as the splitting plane.

Code:

import sys
import networkx as nx
import matplotlib.pyplot as plt

k = 2

class Node:
    def __init__(self, point):
        self.point = point
        self.left = None
        self.right = None

def newNode(point):
    return Node(point)

def insertRec(root, point, depth):
    if not root:
        return newNode(point)
    cd = depth % k
    if point[cd] < root.point[cd]:
        root.left = insertRec(root.left, point, depth + 1)
    else:
        root.right = insertRec(root.right, point, depth + 1)
    return root

def insert(root, point):
    return insertRec(root, point, 0)

def arePointsSame(point1, point2):
    for i in range(k):
        if point1[i] != point2[i]:
            return False
    return True

def searchRec(root, point, depth):
    if not root:
        return False
    if arePointsSame(root.point, point):
        return True
    cd = depth % k
    if point[cd] < root.point[cd]:
        return searchRec(root.left, point, depth + 1)
    return searchRec(root.right, point, depth + 1)

def search(root, point):
    return searchRec(root, point, 0)

def visualize_kd_tree(root, graph=None, parent=None):
    if graph is None:
        graph = nx.Graph()
    if root:
        point = tuple(root.point)
        graph.add_node(point)
        if parent:
            parent_point = tuple(parent.point)
            graph.add_edge(parent_point, point)
        visualize_kd_tree(root.left, graph, root)
        visualize_kd_tree(root.right, graph, root)
    return graph

if __name__ == '__main__':
    root = None
    points = [[3, 6], [17, 15], [13, 15], [6, 12], [9, 1], [2, 7], [10, 19]]
    n = len(points)

    for i in range(n):
        root = insert(root, points[i])
    G = visualize_kd_tree(root)

    pos = nx.spring_layout(G)
    nx.draw(G, pos, with_labels=False, node_size=100, node_color='lightblue', font_color='black')
    plt.show()
    point1 = [10, 19]
    if search(root, point1):
        print("Point found")
    else:
        print("Point not found")
    point2 = [12, 19]
    if search(root, point2):
        print("Point found")
    else:
        print("Point not found")

Output:

Point found
Point not found

In the presented code, a KD tree (K-dimensional tree) is brought into action to conduct operations such as insertion and the quest for points within the realm of K-dimensional space.

Next TopicKnapsack Problem in Data Structure

← prev next →