Flip Binary Tree To Match Preorder Traversal

Flip Binary Tree To Match Preorder Traversal - Problem

Imagine you have a binary tree where you can flip any node by swapping its left and right subtrees. Your goal is to transform the tree so that its preorder traversal matches a given sequence called voyage.

You're given:

A binary tree with n nodes, each uniquely valued from 1 to n
A sequence voyage representing the desired preorder traversal

Your task: Find the minimum number of flips needed to make the tree's preorder traversal match voyage. Return a list of all node values that need to be flipped.

Important: If it's impossible to achieve the desired traversal through flips, return [-1].

Example: If flipping node 1 swaps its left subtree (containing node 2) with its right subtree (containing node 3), the preorder changes from [1,2,...] to [1,3,...].

Input & Output

example_1.py — Basic Flip Required

$ Input: root = [1,2,3], voyage = [1,3,2]

› Output: [1]

💡 Note: We need to flip node 1 to swap its children. Originally preorder is [1,2,3], but we want [1,3,2]. Flipping node 1 swaps nodes 2 and 3, giving us the desired traversal.

example_2.py — No Flips Needed

$ Input: root = [1,2,3], voyage = [1,2,3]

› Output: []

💡 Note: The tree's natural preorder traversal already matches the voyage [1,2,3], so no flips are required. Return empty array.

example_3.py — Impossible Case

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

› Output: [-1]

💡 Note: The voyage contains node 4 which doesn't exist in our tree. No amount of flipping can create node 4, so it's impossible to match the voyage.

Constraints

The number of nodes in the tree is n
1 ≤ n ≤ 100
1 ≤ Node.val ≤ n
All the values in the tree are unique
voyage.length == n
1 ≤ voyage[i] ≤ n
All the values in voyage are unique

Visualization

Tap to expand

Time: O(n) - visit each actor onceSpace: O(h) - stage height depthPerfect! Minimum swaps guaranteed

Understanding the Visualization

Check the Lead Actor

Start with the main actor (root). If they're not who we expect first in our sequence, the show can't go on!

Examine Understudies

Look at the left understudy. If they're not next in our desired sequence, swap them with the right understudy.

Continue the Chain

Move to the next level and repeat the process for each actor and their understudies.

Final Performance

If at any point the wrong actor appears and can't be fixed by swapping, declare it impossible. Otherwise, return the list of actors whose understudies were swapped.

Key Takeaway

🎯 Key Insight: This greedy approach works because each node can only be flipped once. If the left child doesn't match our expected sequence after considering a flip, then it's impossible to achieve the desired preorder traversal. The single-pass nature makes it both time and space efficient!

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses a single-pass DFS traversal with a greedy flipping strategy. As we traverse the tree in preorder, we compare each node with the expected position in the voyage. When the left child doesn't match the next expected node, we flip the current node. This approach works because we only need to try flipping once per node - if it doesn't work, it's impossible to match the voyage.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass DFS (Optimal)	O(n)	O(n)	Traverse the tree once, flipping nodes when needed and tracking if match is possible
Try All Possible Flips	O(2^n × n)	O(n)	Generate all possible flip combinations and check which one produces the desired preorder

Single Pass DFS (Optimal) — Algorithm Steps

Initialize voyage index and result list for flipped nodes
Start DFS from root, comparing current node with voyage[index]
If current node doesn't match voyage[index], return False (impossible)
If left child doesn't match next expected node, try flipping
After potential flip, recursively process left and right subtrees
Return flip list if successful, [-1] if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at root, check if it matches voyage[0]

Check Children

If left child doesn't match next voyage element, flip

Continue Recursion

Process left and right subtrees recursively

Return Result

Return list of flipped nodes or [-1] if impossible

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

static int index_global;
static int* flipped_global;
static int flipped_size;

int dfs(struct TreeNode* node, int* voyage, int voyageSize) {
    if (!node) return 1;
    
    if (node->val != voyage[index_global]) {
        return 0;
    }
    
    index_global++;
    
    if (index_global >= voyageSize) {
        return 1;
    }
    
    // Check if we need to flip
    if (node->left && node->left->val != voyage[index_global]) {
        flipped_global[flipped_size++] = node->val;
        struct TreeNode* temp = node->left;
        node->left = node->right;
        node->right = temp;
    }
    
    return dfs(node->left, voyage, voyageSize) && dfs(node->right, voyage, voyageSize);
}

int* flipMatchVoyage(struct TreeNode* root, int* voyage, int voyageSize, int* returnSize) {
    index_global = 0;
    flipped_global = (int*)malloc(voyageSize * sizeof(int));
    flipped_size = 0;
    
    if (dfs(root, voyage, voyageSize)) {
        *returnSize = flipped_size;
        return flipped_global;
    } else {
        free(flipped_global);
        int* result = (int*)malloc(sizeof(int));
        result[0] = -1;
        *returnSize = 1;
        return result;
    }
}

int main() {
    // Input parsing and solution call would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through each node in the tree exactly once

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to tree height, result list for flipped nodes

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Single Pass DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler