Construct Quad Tree - Practice Coding Problems

Construct Quad Tree - Problem

Construct Quad Tree is a fascinating problem that combines divide and conquer with tree data structures.

You're given an n × n matrix containing only 0s and 1s. Your task is to build a Quad-Tree representation of this matrix.

A Quad-Tree is a tree where each internal node has exactly four children representing four quadrants:

topLeft - upper-left quadrant
topRight - upper-right quadrant
bottomLeft - lower-left quadrant
bottomRight - lower-right quadrant

Each node has two attributes:

val - True if representing 1s, False if representing 0s
isLeaf - True if it's a leaf node, False if it has children

Construction Rules:

If current region has uniform values (all 0s or all 1s): create a leaf node
If current region has mixed values: create an internal node and recursively build four child subtrees

This data structure is widely used in image compression, spatial indexing, and computer graphics!

Input & Output

example_1.py — Simple 2×2 Matrix

$ Input: grid = [[0,1],[1,0]]

› Output: [[0,1],[1,0],[1,1],[1,1],[1,1]]

💡 Note: The root node is not a leaf (isLeaf=0) so its value can be anything (val=1). It has four children: Top-left and bottom-right are leaf nodes with value 0 (represented as [1,0]). Top-right and bottom-left are leaf nodes with value 1 (represented as [1,1]).

example_2.py — Uniform Matrix

$ Input: grid = [[1,1],[1,1]]

› Output: [[1,1]]

💡 Note: Since the entire matrix contains only 1s, we can represent it with a single leaf node with value 1. The output [1,1] means isLeaf=1 (true) and val=1 (true).

example_3.py — Larger Mixed Matrix

$ Input: grid = [[1,1,0,0],[1,1,0,0],[1,1,1,1],[1,1,1,1]]

› Output: [[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]

💡 Note: The 4×4 matrix gets divided into quadrants. Top-left is all 1s (leaf), top-right is all 0s (leaf), bottom-left is mixed (needs further division), bottom-right is all 1s (leaf). The mixed bottom-left quadrant gets divided into 4 more sub-quadrants.

Visualization

Tap to expand

Understanding the Visualization

Start with Full Matrix

Begin with the entire n×n matrix as the root region

Check Uniformity

Scan the region to see if all values are the same (all 0s or all 1s)

Create Leaf or Divide

If uniform, create leaf node. If mixed, divide into 4 equal quadrants

Recursive Processing

Apply the same process to each of the 4 quadrants

Build Tree Structure

Connect child nodes to parent nodes to form the complete quad-tree

Key Takeaway

🎯 Key Insight: Quad-trees efficiently represent spatial data by recursively subdividing regions until they become uniform, creating a hierarchical structure that saves space and enables fast spatial queries.

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

In worst case, we visit each cell once per level of recursion. With log n levels of recursion, total time is O(n² log n)

⚠ Quadratic Growth

Space Complexity

O(log n)

Recursion stack depth is at most log n levels (when dividing n×n matrix). Each recursive call uses constant space.

⚡ Linearithmic Space

Constraints

n == grid.length == grid[i].length
n == 2^x where 0 ≤ x ≤ 6
Matrix dimensions are powers of 2 (1, 2, 4, 8, 16, 32, 64)
grid[i][j] is either 0 or 1

Asked in

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

The optimal approach uses recursive divide and conquer to build the quad-tree. For each region, check if values are uniform. If yes, create a leaf node. If no, divide into 4 quadrants and recurse. Time complexity is O(n² log n) where n is the matrix dimension, and space complexity is O(log n) for recursion stack.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Divide and Conquer	O(n² log n)	O(log n)	Recursively divide matrix into quadrants and check uniformity

Recursive Divide and Conquer — Algorithm Steps

Check if current region has uniform values (all 0s or all 1s)
If uniform, create leaf node with appropriate value
If mixed, create internal node and divide into 4 quadrants
Recursively build quad-tree for each quadrant
Return the root node

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Uniformity

Examine if current region has all same values

Create Leaf or Divide

If uniform, create leaf node. If mixed, divide into 4 quadrants

Recursive Construction

Recursively build quad-tree for each quadrant

Build Tree Bottom-Up

Combine child nodes to form parent nodes

Code -

solution.c — C

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

typedef struct Node {
    bool val;
    bool isLeaf;
    struct Node* topLeft;
    struct Node* topRight;
    struct Node* bottomLeft;
    struct Node* bottomRight;
} Node;

Node* createNode(bool val, bool isLeaf) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->val = val;
    node->isLeaf = isLeaf;
    node->topLeft = NULL;
    node->topRight = NULL;
    node->bottomLeft = NULL;
    node->bottomRight = NULL;
    return node;
}

bool isUniform(int** grid, int r1, int c1, int r2, int c2, bool* val) {
    int firstVal = grid[r1][c1];
    for (int i = r1; i < r2; i++) {
        for (int j = c1; j < c2; j++) {
            if (grid[i][j] != firstVal) {
                return false;
            }
        }
    }
    *val = (firstVal == 1);
    return true;
}

Node* buildTree(int** grid, int r1, int c1, int r2, int c2) {
    bool val;
    if (isUniform(grid, r1, c1, r2, c2, &val)) {
        return createNode(val, true);
    }
    
    int midR = (r1 + r2) / 2;
    int midC = (c1 + c2) / 2;
    
    Node* topLeft = buildTree(grid, r1, c1, midR, midC);
    Node* topRight = buildTree(grid, r1, midC, midR, c2);
    Node* bottomLeft = buildTree(grid, midR, c1, r2, midC);
    Node* bottomRight = buildTree(grid, midR, midC, r2, c2);
    
    Node* node = createNode(true, false);
    node->topLeft = topLeft;
    node->topRight = topRight;
    node->bottomLeft = bottomLeft;
    node->bottomRight = bottomRight;
    
    return node;
}

Node* construct(int** grid, int gridSize, int* gridColSize) {
    return buildTree(grid, 0, 0, gridSize, gridColSize[0]);
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

In worst case, we visit each cell once per level of recursion. With log n levels of recursion, total time is O(n² log n)

⚠ Quadratic Growth

Space Complexity

O(log n)

Recursion stack depth is at most log n levels (when dividing n×n matrix). Each recursive call uses constant space.

⚡ Linearithmic Space

Constraints

n == grid.length == grid[i].length
n == 2^x where 0 ≤ x ≤ 6
Matrix dimensions are powers of 2 (1, 2, 4, 8, 16, 32, 64)
grid[i][j] is either 0 or 1

48.7K Views

Medium Frequency

~25 min Avg. Time

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

Recursive Divide and Conquer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler