Flatten Binary Tree to Linked List - Practice Coding Problems

Flatten Binary Tree to Linked List - Problem

Transform a Binary Tree into a Flattened Linked List

Given the root of a binary tree, your task is to flatten the tree into a "linked list" structure. This isn't a traditional linked list - instead, you'll modify the existing tree nodes to form a right-skewed tree that resembles a linked list.

Requirements:
• Use the same TreeNode class (no new data structure)
• Set all left child pointers to null
• Use right child pointers to connect to the next node
• Follow pre-order traversal order (root → left subtree → right subtree)

Example: A tree like [1,2,5,3,4,null,6] becomes a right-skewed "linked list": 1→2→3→4→5→6

This problem tests your understanding of tree traversal, in-place modification, and space optimization techniques.

Input & Output

example_1.py — Basic Binary Tree

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

› Output: [1,null,2,null,3,null,4,null,5,null,6]

💡 Note: The original tree has root 1 with left child 2 and right child 5. Node 2 has children 3 and 4, node 5 has child 6. After flattening in pre-order (1→2→3→4→5→6), all nodes are connected via right pointers forming a right-skewed tree.

example_2.py — Single Node

$ Input: root = [0]

› Output: [0]

💡 Note: A tree with only one node remains unchanged after flattening, as there are no other nodes to connect.

example_3.py — Empty Tree

$ Input: root = []

› Output: []

💡 Note: An empty tree (null root) remains empty after the flattening operation.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is pushed and popped from stack exactly once, making it linear time

✓ Linear Growth

Space Complexity

O(h)

Stack space proportional to tree height: O(log n) for balanced trees, O(n) worst case for skewed trees

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 2000]
-100 ≤ Node.val ≤ 100
Follow up: Can you flatten the tree in-place (with O(1) extra space)?

Asked in

The optimal solution uses an iterative approach with a stack to simulate pre-order traversal while flattening in-place. Key insight: push right child before left child to ensure correct processing order. Time complexity: O(n), Space complexity: O(h) where h is tree height. The Morris-like recursive approach processes nodes in reverse pre-order for true O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive In-Place (Morris-like)	O(n)	O(h)	Recursively process right subtree first, then left, maintaining previous node
Iterative with Stack (Optimal)	O(n)	O(h)	Use stack to simulate pre-order traversal while flattening in-place

Recursive In-Place (Morris-like) — Algorithm Steps

Use a global/instance variable to track the previously processed node
Recursively process the right subtree first
Then recursively process the left subtree
For each node, set its right child to the previous node
Set its left child to null and update the previous node reference

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Right Subtree

Recursively flatten right subtree first

Process Left Subtree

Then recursively flatten left subtree

Connect Current Node

Connect current node to previously processed node

Update Previous

Current node becomes the new previous node

Code -

solution.c — C

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

#include <stdlib.h>

struct TreeNode* prev = NULL;

void flatten(struct TreeNode* root) {
    if (!root) return;
    
    // Process right subtree first
    flatten(root->right);
    // Then process left subtree
    flatten(root->left);
    
    // Modify current node
    root->right = prev;
    root->left = NULL;
    prev = root;
}

// Alternative without global variable
struct TreeNode* helper(struct TreeNode* node, struct TreeNode* prev) {
    if (!node) return prev;
    
    // Process right first, then left
    prev = helper(node->right, prev);
    prev = helper(node->left, prev);
    
    // Connect current node
    node->right = prev;
    node->left = NULL;
    return node;
}

void flattenAlternative(struct TreeNode* root) {
    helper(root, NULL);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once during the recursive traversal

✓ Linear Growth

Space Complexity

O(h)

Only recursion stack space where h is the height of the tree, O(log n) for balanced trees, O(n) worst case

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 2000]
-100 ≤ Node.val ≤ 100
Follow up: Can you flatten the tree in-place (with O(1) extra space)?

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive In-Place (Morris-like) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler