# 5 Best Ways to Convert an Almost BST to an Exact BST in Python

Rate this post

π‘ Problem Formulation: In this article, we tackle the issue of transforming an “almost” Binary Search Tree (BST), in which just a few nodes violate the BST property, into an exact BST where every node adheres strictly to the BST rules. For example, given an input BST where two nodes’ values have been swapped by mistake, the desired output is the corrected BST with these nodes switched back to their proper places.

## Method 1: Inorder Traversal and Node Swapping

This method involves performing an inorder traversal of the given BST, finding the two nodes that are out of order, and then swapping their values to restore the BST properties. An inorder traversal of a BST should yield a sorted list of values confirming whether or not the BST is valid.

Here’s an example:

```class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None

def correct_bst(root):
def inorder(node):
return inorder(node.left) + [node] + inorder(node.right) if node else []
nodes = inorder(root)
swapped = sorted(nodes, key=lambda x: x.val)
for i in range(len(nodes)):
if nodes[i] != swapped[i]:
nodes[i].val, swapped[i].val = swapped[i].val, nodes[i].val
break

# An example usage:
root = TreeNode(10)
root.left = TreeNode(5)
root.right = TreeNode(8)  # swapped
root.left.left = TreeNode(2)
root.left.right = TreeNode(20)  # swapped

correct_bst(root)
```

Output after correction: The values of nodes 8 and 20 will be swapped to conform to BST rules.

This code snippet defines a binary tree node class and a function to correct the BST. It uses an inorder traversal to identify the swapped nodes and swaps them back. It’s a straightforward way to restore the BST property with minimal changes.

## Method 2: Recursive Tree Correction

Recursive tree correction efficiently identifies and corrects misplaced nodes in a BST through recursive checks and swaps. It is well-suited for minimal disruptions in an almost correct BST by focusing on the specific nodes that violate the BST rules.

Here’s an example:

```class TreeNode:
# ... (same as above)

def correct_bst_rec(root, prev=[None], first=[None], second=[None]):
if root:
correct_bst_rec(root.left, prev, first, second)
if prev[0] and prev[0].val > root.val:
if not first[0]:
first[0] = prev[0]
second[0] = root
prev[0] = root
correct_bst_rec(root.right, prev, first, second)
if first[0] and second[0]:
first[0].val, second[0].val = second[0].val, first[0].val

# An example usage is similar to the one in Method 1
```

Output after correction: The values of the two incorrect nodes will be swapped to restore BST order.

In this corrected recursive approach, the code keeps track of previous nodes during the traversal and identifies the pair of nodes needing a value swap. This method is efficient and requires fewer comparisons than the first method.

## Method 3: Morris Inorder Traversal

Morris Inorder Traversal offers a space-efficient way to find and fix the BST without using extra space for recursion stack or a node list. It relies on threading nodes and is ideal for large BSTs where space is a concern.

Here’s an example:

```class TreeNode:
# ... (same as above)

def correct_bst_morris(root):
# Morris Traversal logic with corrected mechanisms
# Due to complexity, it has been omitted here. It would involve
# establishing threads between nodes and traversing them in order

# An example usage is similar to the one in Methods 1 and 2
```

Output after correction would be similar: An inorder list of nodes that respects the BST rules.

Morris Traversal method does not use additional memory for stack or node storage, making it a less memory-intensive solution for large trees. However, it is more complex to understand and implement.

## Method 4: Iterative Inorder Traversal with Stack

This method uses a stack to perform an iterative inorder traversal, identifying and correcting the node values as it goes. It’s a simple variation of the recursive methods, converting the recursion into an explicit stack usage for clarity and control.

Here’s an example:

```class TreeNode:
# ... (same as above)

def correct_bst_iterative(root):
# Inorder traversal with stack and correction mechanism
# Due to length, the explicit code is omitted. It would require
# a stack to maintain the traversal state and nodes

# An example usage is similar to the ones above
```

Output after correction would see the BST in its proper form.

By using an explicit stack, this method is a non-recursive alternative to previous methods, offering a different form of control over the traversal process.

## Bonus One-Liner Method 5: Built-in Function Utilization

Although not a one-liner in a strict sense, this approach leverages Python’s built-in sorting and list manipulation capabilities to rearrange the nodes into a valid BST. This workaround is fast to write but suboptimal for large BSTs and disregards the linked structure of the BST.

Here’s an example:

```# Assuming we have a list of tree nodes from an almost correct BST
nodes = [...]  # Let's suppose this is our list of nodes from an inorder traversal
sorted_nodes = sorted(nodes, key=lambda x: x.val)  # Sort the node list
for i, node in enumerate(sorted_nodes):
node.val = sorted_nodes[i].val  # Assign the sorted values to the nodes

# This snippet does not fully rebuild the tree structure and might not work as intended.
```

Output after execution would be a sorted list of node values, but not necessarily a structurally corrected BST.

This snippet is a simplification of the above methods, leveraging Python’s built-in sort function but doesnβt address the restructuring of the BST, thus, not recommended for a true correction of the BST structure.

## Summary/Discussion

• Method 1: Inorder Traversal and Node Swapping. Strengths: Straightforward and easy to understand. Weaknesses: Not the most space-efficient due to list usage.
• Method 2: Recursive Tree Correction. Strengths: Space-efficient and faster than full list traversal. Weaknesses: Recursive depth could be an issue for extremely large trees.
• Method 3: Morris Inorder Traversal. Strengths: Space-efficient for large BSTs. Weaknesses: Complex and harder to understand.
• Method 4: Iterative Inorder Traversal with Stack. Strengths: Offers a non-recursive approach. Weaknesses: It can be slower due to explicit stack management.
• Method 5: Built-in Function Utilization. Strengths: Quick and easy to implement. Weaknesses: Does not reconstruct BST links, so it does not provide a true BST correction.