Path In Zigzag Labelled Binary Tree - Practice Coding Problems

Path In Zigzag Labelled Binary Tree - Problem

Imagine a special infinite binary tree where nodes are labeled in a unique zigzag pattern! 🌲

Here's how the labeling works:

Odd-numbered rows (1st, 3rd, 5th...): Labels go left to right → → →
Even-numbered rows (2nd, 4th, 6th...): Labels go right to left ← ← ←

For example:

       1           (Row 1: left→right)
     /   \
    3     2         (Row 2: right←left)
   / \   / \
  4   5 6   7       (Row 3: left→right)

Your mission: Given a node's label, find the complete path from the root (node 1) to that node!

Input: An integer label representing a node in the zigzag binary tree

Output: An array containing all labels in the path from root to the target node

Input & Output

example_1.py — Basic Path Finding

$ Input: label = 14

› Output: [1, 3, 6, 14]

💡 Note: Node 14 is in level 4. Tracing back: 14 → 6 (level 3) → 3 (level 2) → 1 (level 1, root). The complete path from root to node 14 is [1, 3, 6, 14].

example_2.py — Early Level Node

$ Input: label = 26

› Output: [1, 2, 6, 10, 26]

💡 Note: Node 26 is in level 5. Working backwards through the zigzag pattern: 26 → 10 → 6 → 2 → 1, giving us the root-to-target path [1, 2, 6, 10, 26].

example_3.py — Root Node Edge Case

$ Input: label = 1

› Output: [1]

💡 Note: The root node 1 has no parent, so the path is simply [1]. This is the simplest case where the target is the root itself.

Constraints

1 ≤ label ≤ 10⁶
The given label will always exist in the zigzag binary tree
Tree property: Every node has exactly two children (except leaf nodes)

Visualization

Tap to expand

Understanding the Visualization

Identify the Level

First, determine which level (floor) contains our target node using powers of 2

Convert to Normal Position

Transform the zigzag position to what it would be in a normal left-to-right binary tree

Find the Parent

In a normal binary tree, parent is at position divided by 2 in the previous level

Convert Back to Zigzag

Transform the parent's normal position back to its actual zigzag position

Repeat Until Root

Continue this process until we reach the root node (level 1)

Key Takeaway

🎯 Key Insight: By understanding the mathematical relationship between zigzag positions and normal binary tree positions, we can calculate any path in O(log n) time without building the tree!

Asked in

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

The optimal approach uses mathematical calculation to find the path in O(log n) time. Key insights: calculate the target node's level using bit operations, then trace backwards by converting between zigzag positions and normal binary tree positions using level boundary mathematics. This avoids building the entire tree structure.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Calculation (Optimal)	O(log n)	O(log n)	Use mathematical properties to directly calculate the path without building the tree
Brute Force (Level-by-Level Construction)	O(n)	O(√n)	Build the tree level by level until we find the target node

Mathematical Calculation (Optimal) — Algorithm Steps

Calculate the level of the target node using logarithms
Start from the target node and work backwards to root
For each level, determine if it follows left-to-right or right-to-left ordering
Use mathematical formulas to convert positions and find parents
Build the path by tracing from target back to root

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Target Level

Use bit shifting to quickly determine which level contains the target

Convert Positions

Transform zigzag positions to normal binary tree positions

Calculate Parents

Use division by 2 to find parent positions in normal binary tree

Convert Back

Transform normal positions back to zigzag positions for each level

Code -

solution.c — C

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

int* pathInZigZagTree(int label, int* returnSize) {
    // Find the level of the target node
    int level = 1;
    while ((1 << level) <= label) {
        level++;
    }
    
    int* path = (int*)malloc(level * sizeof(int));
    *returnSize = 0;
    int tempLabel = label;
    int tempLevel = level;
    
    // Trace back from target to root
    while (tempLevel > 0) {
        path[(*returnSize)++] = tempLabel;
        
        // Calculate level boundaries
        int levelStart = 1 << (tempLevel - 1);  // 2^(level-1)
        int levelEnd = (1 << tempLevel) - 1;    // 2^level - 1
        
        // Convert to "normal" position if this level is reversed
        int normalPos;
        if (tempLevel % 2 == 0) {  // Even level (right to left)
            normalPos = levelEnd - tempLabel + levelStart;
        } else {  // Odd level (left to right)
            normalPos = tempLabel;
        }
        
        // Calculate parent's normal position
        int parentNormalPos = normalPos / 2;
        
        // Move to parent level
        tempLevel--;
        if (tempLevel == 0) break;
        
        // Calculate parent level boundaries
        int parentStart = 1 << (tempLevel - 1);
        int parentEnd = (1 << tempLevel) - 1;
        
        // Convert parent's normal position to actual label
        if (tempLevel % 2 == 0) {  // Parent level is even (right to left)
            tempLabel = parentEnd - parentNormalPos + parentStart;
        } else {  // Parent level is odd (left to right)
            tempLabel = parentNormalPos;
        }
    }
    
    // Reverse the path
    for (int i = 0; i < *returnSize / 2; i++) {
        int temp = path[i];
        path[i] = path[*returnSize - 1 - i];
        path[*returnSize - 1 - i] = temp;
    }
    
    return path;
}

int main() {
    int label;
    scanf("%d", &label);
    int returnSize;
    int* result = pathInZigZagTree(label, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We only need to traverse from the target node level back to root, which is O(log n) levels

⚡ Linearithmic

Space Complexity

O(log n)

We store the path which has at most log n nodes (the height of the tree to reach node n)

⚡ Linearithmic Space

23.5K 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

Mathematical Calculation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler