Find minimum in K Dimensional Tree

Last Updated : 23 Jul, 2025

We strongly recommend to refer below post as a prerequisite of this. K Dimensional Tree | Set 1 (Search and Insert) In this post find minimum is discussed. The operation is to find minimum in the given dimension. This is especially needed in delete operation. For example, consider below KD Tree, if given dimension is x, then output should be 5 and if given dimensions is y, then output should be 12.

In KD tree, points are divided dimension by dimension. For example, root divides keys by dimension 0, level next to root divides by dimension 1, next level by dimension 2 if k is more than 2 (else by dimension 0), and so on.

To find minimum we traverse nodes starting from root. If dimension of current level is same as given dimension, then required minimum lies on left side if there is left child. This is same as Binary Search Tree Minimum. Above is simple, what to do when current level's dimension is different. When dimension of current level is different, minimum may be either in left subtree or right subtree or current node may also be minimum. So we take minimum of three and return. This is different from Binary Search tree.

Below is C++ implementation of find minimum operation.

Cpp

// A C++ program to demonstrate find minimum on KD tree
#include <bits/stdc++.h>
using namespace std;

const int k = 2;

// A structure to represent node of kd tree
struct Node {
    int point[k]; // To store k dimensional point
    Node *left, *right;
};

// A method to create a node of K D tree
struct Node* newNode(int arr[])
{
    struct Node* temp = new Node;

    for (int i = 0; i < k; i++)
        temp->point[i] = arr[i];

    temp->left = temp->right = NULL;
    return temp;
}

// Inserts a new node and returns root of modified tree
// The parameter depth is used to decide axis of comparison
Node* insertRec(Node* root, int point[], unsigned depth)
{
    // Tree is empty?
    if (root == NULL)
        return newNode(point);

    // Calculate current dimension (cd) of comparison
    unsigned cd = depth % k;

    // Compare the new point with root on current dimension 'cd'
    // and decide the left or right subtree
    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;
}

// Function to insert a new point with given point in
// KD Tree and return new root. It mainly uses above recursive
// function "insertRec()"
Node* insert(Node* root, int point[])
{
    return insertRec(root, point, 0);
}

// A utility function to find minimum of three integers
int min(int x, int y, int z)
{
    return min(x, min(y, z));
}

// Recursively finds minimum of d'th dimension in KD tree
// The parameter depth is used to determine current axis.
int findMinRec(Node* root, int d, unsigned depth)
{
    // Base cases
    if (root == NULL)
        return INT_MAX;

    // Current dimension is computed using current depth and total
    // dimensions (k)
    unsigned cd = depth % k;

    // Compare point with root with respect to cd (Current dimension)
    if (cd == d) {
        if (root->left == NULL)
            return root->point[d];
        return min(root->point[d], findMinRec(root->left, d, depth + 1));
    }

    // If current dimension is different then minimum can be anywhere
    // in this subtree
    return min(root->point[d],
               findMinRec(root->left, d, depth + 1),
               findMinRec(root->right, d, depth + 1));
}

// A wrapper over findMinRec(). Returns minimum of d'th dimension
int findMin(Node* root, int d)
{
    // Pass current level or depth as 0
    return findMinRec(root, d, 0);
}

// Driver program to test above functions
int main()
{
    struct Node* root = NULL;
    int points[][k] = { { 30, 40 }, { 5, 25 },
       { 70, 70 }, { 10, 12 }, { 50, 30 }, { 35, 45 } };

    int n = sizeof(points) / sizeof(points[0]);

    for (int i = 0; i < n; i++)
        root = insert(root, points[i]);

    cout << "Minimum of 0'th dimension is " << findMin(root, 0) << endl;
    cout << "Minimum of 1'th dimension is " << findMin(root, 1) << endl;

    return 0;
}

Java

// A Java program to demonstrate find minimum on KD tree
import java.util.Arrays;

class Node {
  int[] point;
  Node left, right;

  Node(int[] point) {
    this.point = point;
    left = right = null;
  }
}

class KDTree {
  int k = 2;

  Node newNode(int[] point) {
    return new Node(point);
  }

  Node insertRec(Node root, int[] point, int depth) {
    if (root == null) {
      return newNode(point);
    }

    int 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;
  }

  Node insert(Node root, int[] point) {
    return insertRec(root, point, 0);
  }

  int min3(int x, int y, int z) {
    return Math.min(Math.min(x, y), z);
  }

  int findMinRec(Node root, int d, int depth) {
    if (root == null) {
      return Integer.MAX_VALUE;
    }

    int cd = depth % k;
    if (cd == d) {
      if (root.left == null) {
        return root.point[d];
      }
      return min3(root.point[d], findMinRec(root.left, d, depth + 1), findMinRec(root.right, d, depth + 1));
    }

    return min3(root.point[d], findMinRec(root.left, d, depth + 1), findMinRec(root.right, d, depth + 1));
  }

  int findMin(Node root, int d) {
    return findMinRec(root, d, 0);
  }

  public static void main(String[] args) {
    KDTree tree = new KDTree();
    Node root = null;
    int[][] points = {{30, 40}, {5, 25}, {70, 70}, {10, 12}, {50, 30}, {35, 45}};

    for (int[] point : points) {
      root = tree.insert(root, point);
    }

    System.out.println("Minimum of 0'th dimension is " + tree.findMin(root, 0));
    System.out.println("Minimum of 1'th dimension is " + tree.findMin(root, 1));
  }
}

// This code is contributed y shivamsharma215

Python3

# A python program to demonstrate find minimum on KD tree

# Number of dimensions
k = 2

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

# A method to create a node of K D tree
def newNode(arr):
    temp = Node(arr)
    return temp

# Inserts a new node and returns root of modified tree
# The parameter depth is used to decide axis of comparison
def insertRec(root, point, depth):
    # Tree is empty?
    if root is None:
        return newNode(point)

    # Calculate current dimension (cd) of comparison
    cd = depth % k

    # Compare the new point with root on current dimension 'cd'
    # and decide the left or right subtree
    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

# Function to insert a new point with given point in
# KD Tree and return new root. It mainly uses above recursive
# function "insertRec()"
def insert(root, point):
    return insertRec(root, point, 0)

# A utility function to find minimum of three integers
def min_3(x, y, z):
    return min(x, y, z)

# Recursively finds minimum of d'th dimension in KD tree
# The parameter depth is used to determine current axis.
def findMinRec(root, d, depth):
    # Base cases
    if root is None:
        return float('inf')

    # Current dimension is computed using current depth and total
    # dimensions (k)
    cd = depth % k

    # Compare point with root with respect to cd (Current dimension)
    if cd == d:
        if root.left is None:
            return root.point[d]
        return min(root.point[d], findMinRec(root.left, d, depth + 1),findMinRec(root.right, d, depth + 1))

    # If current dimension is different then minimum can be anywhere
    # in this subtree
    return min_3(root.point[d], findMinRec(root.left, d, depth + 1), findMinRec(root.right, d, depth + 1))

# A wrapper over findMinRec(). Returns minimum of d'th dimension
def findMin(root, d):
    # Pass current level or depth as 0
    return findMinRec(root, d, 0)

# Driver program to test above functions
if __name__ == "__main__":
    root = None
    points = [ [30, 40], [5, 25], [70, 70], [10, 12], [50, 30], [35, 45] ]

    n = len(points)

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

    print("Minimum of 0'th dimension is", findMin(root, 0))
    print("Minimum of 1'th dimension is", findMin(root, 1))
    
# This code is contributed by Vikram_Shirsat

using System;
public class Node
{
  public int[] Point { get; set; }
  public Node Left { get; set; }
  public Node Right { get; set; }

  public Node(int[] point)
  {
    Point = point;
    Left = null;
    Right = null;
  }
}

class Program
{
  const int k = 2;

  // A structure to represent node of kd tree
  class Node
  {
    public int[] point = new int[k]; // To store k dimensional point
    public Node left, right;
  };

  // A method to create a node of K D tree
  static Node NewNode(int[] arr)
  {
    Node temp = new Node();

    for (int i = 0; i < k; i++)
      temp.point[i] = arr[i];

    temp.left = temp.right = null;
    return temp;
  }

  // Inserts a new node and returns root of modified tree
  // The parameter depth is used to decide axis of comparison
  static Node InsertRec(Node root, int[] point, uint depth)
  {
    // Tree is empty?
    if (root == null)
      return NewNode(point);

    // Calculate current dimension (cd) of comparison
    uint cd = depth % k;

    // Compare the new point with root on current dimension 'cd'
    // and decide the left or right subtree
    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;
  }

  // Function to insert a new point with given point in
  // KD Tree and return new root. It mainly uses above recursive
  // function "InsertRec()"
  static Node Insert(Node root, int[] point)
  {
    return InsertRec(root, point, 0);
  }

  // A utility function to find minimum of three integers
  static int Min(int x, int y, int z)
  {
    return Math.Min(x, Math.Min(y, z));
  }

  // Recursively finds minimum of d'th dimension in KD tree
  // The parameter depth is used to determine current axis.
  static int FindMinRec(Node root, int d, uint depth)
  {
    // Base cases
    if (root == null)
      return int.MaxValue;

    // Current dimension is computed using current depth and total
    // dimensions (k)
    uint cd = depth % k;

    // Compare point with root with respect to cd (Current dimension)
    if (cd == d)
    {
      if (root.left == null)
        return root.point[d];
      return Math.Min(root.point[d], FindMinRec(root.left, d, depth + 1));
    }

    // If current dimension is different then minimum can be anywhere
    // in this subtree
    return Min(root.point[d],
               FindMinRec(root.left, d, depth + 1),
               FindMinRec(root.right, d, depth + 1));
  }

  // A wrapper over FindMinRec(). Returns minimum of d'th dimension
  static int FindMin(Node root, int d)
  {
    // Pass current level or depth as 0
    return FindMinRec(root, d, 0);
  }


  static void Main(string[] args)
  {
    Node root = null;
    int[][] points = new int[][] { new int[] { 30, 40 }, new int[] { 5, 25 },
                                  new int[] { 70, 70 }, new int[] { 10, 12 }, new int[] { 50, 30 }, new int[] { 35, 45 } };

    int n = points.Length;

    for (int i = 0; i < n; i++)
      root = Insert(root, points[i]);

    Console.WriteLine("Minimum of 0'th dimension is " + FindMin(root, 0));
    Console.WriteLine("Minimum of 1'th dimension is " + FindMin(root, 1));

    Console.ReadLine();
  }
}

// This code is contributed by ratiagrawal.

JavaScript

// A Javascript program to demonstrate find minimum on KD tree

// Number of dimensions
let k = 2;

class Node {
constructor(point) {
this.point = point;
this.left = null;
this.right = null;
}
}

// A method to create a node of K D tree
function newNode(arr) {
let temp = new Node(arr);
return temp;
}

// Inserts a new node and returns root of modified tree
// The parameter depth is used to decide axis of comparison
function insertRec(root, point, depth) {
// Tree is empty?
if (root == null) {
return newNode(point);
}
// Calculate current dimension (cd) of comparison
let cd = depth % k;

// Compare the new point with root on current dimension 'cd'
// and decide the left or right subtree
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;
}

// Function to insert a new point with given point in
// KD Tree and return new root. It mainly uses above recursive
// function "insertRec()"
function insert(root, point) {
return insertRec(root, point, 0);
}

// A utility function to find minimum of three integers
function min_3(x, y, z) {
return Math.min(x, y, z);
}

// Recursively finds minimum of d'th dimension in KD tree
// The parameter depth is used to determine current axis.
function findMinRec(root, d, depth) {
// Base cases
if (root == null) {
return Number.POSITIVE_INFINITY;
}
// Current dimension is computed using current depth and total
// dimensions (k)
let cd = depth % k;

// Compare point with root with respect to cd (Current dimension)
if (cd == d) {
    if (root.left == null) {
        return root.point[d];
    }
    return min_3(root.point[d], findMinRec(root.left, d, depth + 1), findMinRec(root.right, d, depth + 1));
}

// If current dimension is different then minimum can be anywhere
// in this subtree
return min_3(root.point[d], findMinRec(root.left, d, depth + 1), findMinRec(root.right, d, depth + 1));
}

// A wrapper over findMinRec(). Returns minimum of d'th dimension
function findMin(root, d) {
// Pass current level or depth as 0
return findMinRec(root, d, 0);
}

// Driver program to test above functions
if (true) {
let root = null;
let points = [[30, 40], [5, 25], [70, 70], [10, 12], [50, 30], [35, 45]];
let n = points.length;

for (let i = 0; i < n; i++) {
    root = insert(root, points[i]);
}

console.log("Minimum of 0'th dimension is", findMin(root, 0));
console.log("Minimum of 1'th dimension is", findMin(root, 1));
}

//This code is contributed by shivamsharma215

Output:

Minimum of 0'th dimension is 5
Minimum of 1'th dimension is 12

Time complexity- The time complexity of inserting a point into a k-dimensional tree is O(k log n), where n is the number of points already in the tree. This is because at each level of the tree, we compare the point to be inserted with the current node and recursively move down the left or right subtree based on the comparison. We stop when we reach a null node, and create a new node for the point to be inserted.

The time complexity of finding the minimum value in a given dimension of the k-dimensional tree is O(log n), as we start at the root of the tree and recursively move down the left or right subtree based on the comparison of the given dimension of the point with the current node. We stop when we reach a leaf node or a node with a null subtree.

Space complexity - The space complexity of the k-dimensional tree is O(n), where n is the number of points in the tree. This is because we store a Node structure for each point in the tree, which contains the k-dimensional point and pointers to its left and right subtrees.

Source: https://www.cs.umd.edu/class/spring2008/cmsc420/L19.kd-trees.pdf

K-Dimensional Tree [Find Minimum]

Analysis of Algorithms

kartik

Improve

Article Tags :

Practice Tags :

Advanced Data Structure

Find minimum in K Dimensional Tree

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?