Flatten Binary Tree to Linked List

Flatten Binary Tree to Linked List - Problem

Given the root of a binary tree, flatten the tree into a "linked list":

The "linked list" should use the same TreeNode class where the right child pointer points to the next node in the list and the left child pointer is always null.
The "linked list" should be in the same order as a pre-order traversal of the binary tree.

Note: The transformation should be done in-place - modify the original tree structure rather than creating a new tree.

Input & Output

Example 1 — Basic Binary Tree

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

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

💡 Note: Pre-order traversal gives us 1→2→3→4→5→6. The flattened tree becomes a right-skewed tree with this sequence.

Example 2 — Empty Tree

$ Input: root = []

› Output: []

💡 Note: Empty tree remains empty after flattening.

Example 3 — Single Node

$ Input: root = [0]

› Output: [0]

💡 Note: Single node tree remains unchanged - no left or right children to rearrange.

Constraints

The number of nodes in the tree is in the range [0, 2000]
-100 ≤ Node.val ≤ 100

Visualization

Tap to expand

Asked in

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

The key insight is to rearrange the tree structure in-place by connecting the rightmost node of each left subtree to the current node's right subtree. The most efficient approach uses DFS with rightmost connection which processes each node once and maintains the pre-order sequence. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Iterative Stack-based Morris-like Traversal

⏱️ Time: O(n) Space: O(h)

Process nodes iteratively using a stack. For each node, if it has both left and right children, push the right child to stack, then move left child to right position. Continue until stack is empty.

Pre-order Traversal with Array

⏱️ Time: O(n) Space: O(n)

First traverse the tree in pre-order and store all nodes in an array. Then iterate through the array and connect each node's right pointer to the next node while setting left pointers to null.

Recursive DFS with Rightmost Connection

⏱️ Time: O(n) Space: O(h)

For each node, if it has a left subtree, find the rightmost node in that subtree and connect it to the current node's right subtree. Then move the left subtree to the right and continue recursively.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    char** videos;
    int count;
} PersonVideos;

typedef struct {
    int* friends;
    int count;
} PersonFriends;

typedef struct {
    char* video;
    int count;
} VideoCount;

int compareVideos(const void* a, const void* b) {
    VideoCount* va = (VideoCount*)a;
    VideoCount* vb = (VideoCount*)b;
    if (va->count != vb->count) {
        return va->count - vb->count;
    }
    return strcmp(va->video, vb->video);
}

char** solution(PersonVideos* watchedVideos, PersonFriends* friends, int n, int id, int level, int* returnSize) {
    int* distances = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        distances[i] = -1;
    }
    
    int* queue = (int*)malloc(n * sizeof(int));
    int front = 0, rear = 0;
    
    queue[rear++] = id;
    distances[id] = 0;
    
    // BFS to find shortest distances
    while (front < rear) {
        int current = queue[front++];
        
        for (int i = 0; i < friends[current].count; i++) {
            int friend_id = friends[current].friends[i];
            if (distances[friend_id] == -1) {
                distances[friend_id] = distances[current] + 1;
                queue[rear++] = friend_id;
            }
        }
    }
    
    // Collect videos from people at target level
    VideoCount* videoCountArray = (VideoCount*)malloc(1000 * sizeof(VideoCount));
    int videoCountSize = 0;
    
    for (int person = 0; person < n; person++) {
        if (distances[person] == level) {
            for (int i = 0; i < watchedVideos[person].count; i++) {
                char* video = watchedVideos[person].videos[i];
                int found = 0;
                for (int j = 0; j < videoCountSize; j++) {
                    if (strcmp(videoCountArray[j].video, video) == 0) {
                        videoCountArray[j].count++;
                        found = 1;
                        break;
                    }
                }
                if (!found) {
                    videoCountArray[videoCountSize].video = (char*)malloc(strlen(video) + 1);
                    strcpy(videoCountArray[videoCountSize].video, video);
                    videoCountArray[videoCountSize].count = 1;
                    videoCountSize++;
                }
            }
        }
    }
    
    // Sort by frequency then alphabetically
    qsort(videoCountArray, videoCountSize, sizeof(VideoCount), compareVideos);
    
    char** result = (char**)malloc(videoCountSize * sizeof(char*));
    for (int i = 0; i < videoCountSize; i++) {
        result[i] = videoCountArray[i].video;
    }
    *returnSize = videoCountSize;
    
    free(distances);
    free(queue);
    free(videoCountArray);
    return result;
}

int main() {
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

52.0K Views

High Frequency

~25 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