Convert Binary Search Tree to Sorted Doubly Linked List

Convert Binary Search Tree to Sorted Doubly Linked List - Problem

Transform a Binary Search Tree (BST) into a sorted circular doubly-linked list in place! 🔄

Imagine you have a BST where nodes are connected by left and right pointers. Your mission is to rewire these connections so that:

• The left pointer becomes the predecessor (previous node)
• The right pointer becomes the successor (next node)
• The list is circular: first node's left points to last, last node's right points to first
• The transformation must be done in place (no new nodes)

Since it's a BST, an in-order traversal gives us the sorted sequence. Your goal is to return the pointer to the smallest element (the head of our circular list).

Key Challenge: Maintain the sorted order while converting the tree structure into a doubly-linked list structure.

Input & Output

example_1.py — Basic BST

$ Input: root = [4,2,5,1,3]

› Output: Circular doubly linked list: 1<->2<->3<->4<->5<->1...

💡 Note: The BST is converted to a sorted circular doubly linked list. Node 1 (smallest) is returned as head. Each node's left points to predecessor, right to successor.

example_2.py — Single Node

$ Input: root = [2]

› Output: Circular doubly linked list: 2<->2 (points to itself)

💡 Note: Single node case: the node's left and right pointers both point to itself, forming a circular list of size 1.

example_3.py — Empty Tree

$ Input: root = []

› Output: null

💡 Note: Empty tree returns null as there are no nodes to form a doubly linked list.

Visualization

Tap to expand

Understanding the Visualization

Traverse In-Order

Visit nodes in sorted order: 1, 2, 3, 4, 5

Link as We Go

Connect each node to the previous one immediately

Complete the Circle

Connect first and last nodes to make it circular

Key Takeaway

🎯 Key Insight: In-order traversal of a BST naturally gives us nodes in sorted order, allowing us to build the doubly-linked list connections incrementally without extra storage!

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for in-order traversal + O(n) for reconstructing links = O(n) total

✓ Linear Growth

Space Complexity

O(n)

O(n) for storing all nodes in array + O(h) for recursion stack where h is tree height

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [0, 2000]
-1000 ≤ Node.val ≤ 1000
All the values of the tree are unique
The tree is guaranteed to be a valid Binary Search Tree

Asked in

G Google 45 f Facebook 38 ⊞ Microsoft 32 a Amazon 28

The optimal solution uses in-order traversal with pointer tracking to convert the BST to a circular doubly linked list in O(n) time and O(h) space. By maintaining references to the first and last nodes during traversal, we can build the doubly linked connections on-the-fly without requiring extra storage for collecting nodes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Collect and Reconstruct)	O(n)	O(n)	Collect all nodes in sorted order, then rebuild connections
In-Order Traversal with Pointer Tracking (Optimal)	O(n)	O(h)	Use in-order traversal to process nodes in sorted order while maintaining previous node reference

Brute Force (Collect and Reconstruct) — Algorithm Steps

Perform in-order traversal to collect all nodes in sorted order
Iterate through collected nodes array
For each node, set left pointer to previous node and right pointer to next node
Handle circular connections: first node's left = last node, last node's right = first node
Return the first node (smallest element)

Visualization

Tap to expand

Step-by-Step Walkthrough

In-order Traversal

Collect nodes: [1, 2, 3, 4, 5]

Rebuild Connections

Wire each node to its neighbors

Make Circular

Connect first and last nodes

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Definition for a Node.
struct Node {
    int val;
    struct Node* left;
    struct Node* right;
};

void inorder(struct Node* node, struct Node** nodes, int* count) {
    if (!node) return;
    inorder(node->left, nodes, count);
    nodes[(*count)++] = node;
    inorder(node->right, nodes, count);
}

struct Node* treeToDoublyList(struct Node* root) {
    if (!root) return NULL;
    
    // Step 1: Collect all nodes in sorted order
    struct Node* nodes[1000];  // Assuming max 1000 nodes
    int count = 0;
    inorder(root, nodes, &count);
    
    // Step 2: Rebuild connections
    for (int i = 0; i < count; i++) {
        nodes[i]->left = nodes[(i - 1 + count) % count];   // Previous node
        nodes[i]->right = nodes[(i + 1) % count];          // Next node
    }
    
    return nodes[0];  // Return smallest element
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for in-order traversal + O(n) for reconstructing links = O(n) total

✓ Linear Growth

Space Complexity

O(n)

O(n) for storing all nodes in array + O(h) for recursion stack where h is tree height

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [0, 2000]
-1000 ≤ Node.val ≤ 1000
All the values of the tree are unique
The tree is guaranteed to be a valid Binary Search Tree

89.4K Views

Medium-High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Collect and Reconstruct) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler