Cartesian Trees in Java

Data structures and algorithms are essential components of any software development project, and Java is a popular language for implementing them. One of the most important data structures is the Cartesian Tree, which can be used to store and access data quickly and efficiently. In this article, we’ll discuss the basics of the Cartesian Tree, how it works, its time and space complexities, and provide some example Java code and exercises to help you understand how to use it.

What is a Cartesian Tree?

A Cartesian Tree is a type of self-balancing binary search tree. It is named after the French mathematician Rene Descartes, who first proposed this type of data structure. It is especially useful for storing and retrieving data quickly, as it is able to maintain a balanced structure even when adding or deleting elements.

In a Cartesian Tree, each node is associated with a value, which is used to determine the order in which the nodes are arranged. The root node is associated with the lowest value, and the leaf nodes are associated with the highest values. The nodes are then arranged in an inverted tree structure in which the root node is at the top and the leaf nodes are at the bottom.

How Does a Cartesian Tree Work?

A Cartesian Tree is a self-balancing binary search tree. This means that it is able to maintain its balance even when adding or deleting elements. It does this by making sure that the number of elements on the left and right subtrees of each node is always the same, or as close to the same as possible.

When a new element is added to the tree, it is compared to the values of the existing elements. If the new element’s value is lower than the value of the root node, it is added as a new left child of the root node. If the new element’s value is higher than the value of the root node, it is added as a new right child of the root node. This process is repeated for each new element, ensuring that the tree remains balanced.

When an element is deleted from the tree, the tree is rebalanced to maintain its balance. This is done by replacing the deleted element with its in-order successor. This ensures that the tree remains balanced and that the order of the elements is preserved.

Time and Space Complexity

A Cartesian Tree has an average time complexity of O(log n) for access, search, insertion, and deletion. This means that it is able to perform these operations quickly, even when dealing with large datasets.

The worst-case time complexity of a Cartesian Tree is O(n). This is because the tree must be rebalanced after each insertion or deletion, and the time taken to do this increases as the number of elements in the tree increases.

The space complexity of a Cartesian Tree is O(n), as each element requires a space in memory.

Example Java Code

Now that we’ve discussed the basics of a Cartesian Tree, let’s look at some example Java code to help you understand how to use it.

First, we’ll create a class to represent a node in the tree. Each node will have a value and references to its left and right children.

public class Node { 
  public int value; 
  public Node left; 
  public Node right; 
  
  public Node(int value) { 
    this.value = value; 
    this.left = null; 
    this.right = null; 
  } 
}

Next, we’ll create a class to represent the tree. This class will have a reference to the root node, as well as methods to insert, search, and delete elements.

public class CartesianTree { 
  public Node root; 
  
  public CartesianTree() { 
    this.root = null; 
  } 
  
  public void insert(int value) { 
    // Insertion code goes here 
  } 
  
  public Node search(int value) { 
    // Search code goes here 
    return null; 
  } 
  
  public void delete(int value) { 
    // Deletion code goes here 
  } 
}

Finally, let’s look at the code for the insertion and deletion methods. The code for the search method is left as an exercise for the reader.

public void insert(int value) { 
  // Create a new node with the given value 
  Node newNode = new Node(value); 
  
  // If the tree is empty, set the root to the new node 
  if (root == null) { 
    root = newNode; 
    return; 
  } 
  
  // Find the proper place to insert the new node 
  Node current = root; 
  Node parent = null; 
  while (true) { 
    parent = current; 
    if (value < current.value) { 
      current = current.left; 
      if (current == null) { 
        parent.left = newNode; 
        return; 
      } 
    } else { 
      current = current.right; 
      if (current == null) { 
        parent.right = newNode; 
        return; 
      } 
    } 
  } 
} 

public void delete(int value) { 
  // Find the node to delete 
  Node current = root; 
  Node parent = null; 
  boolean isLeftChild = false; 
  while (current != null) { 
    if (current.value == value) { 
      break; 
    } else if (value < current.value) { 
      parent = current; 
      current = current.left; 
      isLeftChild = true; 
    } else { 
      parent = current; 
      current = current.right; 
      isLeftChild = false; 
    } 
  } 
  
  // If the node is not found, return 
  if (current == null) { 
    return; 
  } 
  
  // If the node has no children, just set the parent's child reference to null 
  if (current.left == null && current.right == null) { 
    if (isLeftChild) { 
      parent.left = null; 
    } else { 
      parent.right = null; 
    } 
    return; 
  } 
  
  // If the node has one child, set the parent's child reference to the child node 
  if (current.left == null) { 
    if (isLeftChild) { 
      parent.left = current.right; 
    } else { 
      parent.right = current.right; 
    } 
    return; 
  } else if (current.right == null) { 
    if (isLeftChild) { 
      parent.left = current.left; 
    } else { 
      parent.right = current.left; 
    } 
    return; 
  } 
  
  // If the node has two children, replace it with its in-order successor 
  Node successor = getInOrderSuccessor(current); 
  if (isLeftChild) { 
    parent.left = successor; 
  } else { 
    parent.right = successor; 
  } 
  successor.left = current.left; 
} 

Conclusion

In conclusion, the Cartesian Tree is a self-balancing binary search tree that is very useful for quickly storing and retrieving data. It has an average time complexity of O(log n) for access, search, insertion, and deletion, and a worst-case time complexity of O(n). Its space complexity is O(n) as each element requires a space in memory.

We’ve also looked at some example Java code to help you understand how to use a Cartesian Tree. With this knowledge, you should be able to start using Cartesian Trees in your own projects.

Exercises

public Node search(int value) { 
  // Start at the root node 
  Node current = root; 
  
  // Loop until the value is found or the tree is exhausted 
  while (current != null) { 
    // Check if the current node has the value 
    if (current.value == value) { 
      // If the value is found, return the node 
      return current; 
    } 
    
    // If the value is less than the current node's value, go left 
    if (value < current.value) { 
      current = current.left; 
    } else { 
      // Otherwise, go right 
      current = current.right; 
    } 
  } 
  
  // If the value is not found, return null 
  return null; 
}

public void delete(Node node) { 
  // If the node is the root, just set root to null 
  if (node == root) { 
    root = null; 
    return; 
  } 
  
  // Find the parent node of the node to be deleted 
  Node parent = null; 
  Node current = root; 
  boolean isLeftChild = false; 
  while (current != node) { 
    parent = current; 
    if (node.value < current.value) { 
      current = current.left; 
      isLeftChild = true; 
    } else { 
      current = current.right; 
      isLeftChild = false; 
    } 
  } 
  
  // If the node has no children, just set the parent's child reference to null 
  if (node.left == null && node.right == null) { 
    if (isLeftChild) { 
      parent.left = null; 
    } else { 
      parent.right = null; 
    } 
    return; 
  } 
  
  // If the node has one child, set the parent's child reference to the child node 
  if (node.left == null) { 
    if (isLeftChild) { 
      parent.left = node.right; 
    } else { 
      parent.right = node.right; 
    } 
    return; 
  } else if (node.right == null) { 
    if (isLeftChild) { 
      parent.left = node.left; 
    } else { 
      parent.right = node.left; 
    } 
    return; 
  } 
  
  // If the node has two children, replace it with its in-order successor 
  Node successor = getInOrderSuccessor(node); 
  if (isLeftChild) { 
    parent.left = successor; 
  } else { 
    parent.right = successor; 
  } 
  successor.left = node.left; 
}

public int height() { 
  // If the tree is empty, the height is 0 
  if (root == null) { 
    return 0; 
  } 
  
  // Calculate the height of the left and right subtrees 
  int leftHeight = height(root.left); 
  int rightHeight = height(root.right); 
  
  // Return the maximum of the two subtree heights plus 1 
  return Math.max(leftHeight, rightHeight) + 1; 
} 

private int height(Node node) { 
  // If the node is null, the height is 0 
  if (node == null) { 
    return 0; 
  } 
  
  // Calculate the height of the left and right subtrees 
  int leftHeight = height(node.left); 
  int rightHeight = height(node.right); 
  
  // Return the maximum of the two subtree heights plus 1 
  return Math.max(leftHeight, rightHeight) + 1; 
}

public int size() { 
  // If the tree is empty, the size is 0 
  if (root == null) { 
    return 0; 
  } 
  
  // Calculate the size of the left and right subtrees 
  int leftSize = size(root.left); 
  int rightSize = size(root.right); 
  
  // Return the sum of the two subtree sizes plus 1 
  return leftSize + rightSize + 1; 
} 

private int size(Node node) { 
  // If the node is null, the size is 0 
  if (node == null) { 
    return 0; 
  } 
  
  // Calculate the size of the left and right subtrees 
  int leftSize = size(node.left); 
  int rightSize = size(node.right); 
  
  // Return the sum of the two subtree sizes plus 1 
  return leftSize + rightSize + 1; 
}

public int depth(Node node) { 
  // If the node is the root, the depth is 0 
  if (node == root) { 
    return 0; 
  } 
  
  // Find the parent node of the given node 
  Node parent = null; 
  Node current = root; 
  while (current != node) { 
    parent = current; 
    if (node.value < current.value) { 
      current = current.left; 
    } else { 
      current = current.right; 
    } 
  } 
  
  // Recursively calculate the depth of the parent node 
  return depth(parent) + 1; 
}