This problem addresses the challenge of recovering a Binary Search Tree (BST) where exactly two nodes have been inadvertently swapped, disrupting the BST's inherent ordering. The goal is to identify these two nodes and restore the BST to its correct structure without altering the overall tree topology.

The core idea revolves around leveraging the properties of an in-order traversal of a BST, where nodes are visited in ascending order. Any deviation from this ascending order signals a disruption caused by the swapped nodes. By identifying these out-of-order nodes, we can then swap their values to restore the BST's integrity.

Intuition:

Imagine walking through the BST in ascending order. If two nodes are swapped, you'll encounter a point where the order is violated. The first violation indicates the first swapped node (or a node involved in the swap), and the second violation helps identify the second swapped node (or the other node in the swap).

The `inorder` traversal ensures the nodes are visited in ascending order according to BST properties. When an out-of-order pair is detected, the algorithm stores these nodes. Ultimately, swapping the values of these identified nodes fixes the BST.

Step-by-step thinking:

Initialize `first`, `second`, and `prev` to `None`. `first` and `second` will store the two swapped nodes, and `prev` will keep track of the previously visited node during the in-order traversal.
Perform an in-order traversal of the BST. The `inorder` function recursively visits the left subtree, then the current node, and finally the right subtree.
During the traversal, compare the current node's value with the previous node's value. If `prev` exists and `prev.val > node.val`, it indicates an out-of-order condition.
If it's the first out-of-order condition encountered (`first` is still `None`), set `first` to `prev`. This marks the first node involved in the swap (or the first of the two out-of-order nodes).
Regardless of whether it's the first or subsequent out-of-order condition, set `second` to the current `node`. `second` always holds the second node involved in the swap or the most recent out-of-order node encountered.
Update `prev` to the current `node` to prepare for the next comparison in the in-order traversal.
After the in-order traversal completes, if `first` and `second` are not `None`, it means two swapped nodes were found. Swap their values to restore the BST property.

Time Complexity: O(N), where N is the number of nodes in the BST, due to the in-order traversal.
Space Complexity: O(H), where H is the height of the BST, due to the recursive call stack during in-order traversal. In the worst-case (skewed tree), H can be N, resulting in O(N) space complexity. In the best-case (balanced tree), H is log(N), resulting in O(log(N)) space complexity.
Learn Complexity

19. Recover BST

Example 1:

Example 2:

Constraints: