K-th Largest Perfect Subtree Size in Binary Tree

K-th Largest Perfect Subtree Size in Binary Tree - Problem

K-th Largest Perfect Subtree Size in Binary Tree

You're given the root of a binary tree and an integer k. Your task is to find the size of the k-th largest perfect binary subtree within this tree.

A perfect binary tree is a special type of tree where:
• All leaf nodes are at the same level
• Every internal node has exactly two children

Return the size (number of nodes) of the k-th largest perfect subtree, or -1 if fewer than k perfect subtrees exist.

Example: In a tree with perfect subtrees of sizes [7, 3, 3, 1, 1], the 2nd largest would be size 3.

Input & Output

example_1.py — Basic Perfect Subtrees

$ Input: root = [5,3,6,5,2,5,7,1,null,null,null,null,null,null,8], k = 2

› Output: 3

💡 Note: The perfect subtrees have sizes [1,1,1,1,1,1,3,1]. The 2nd largest size is 3.

example_2.py — Single Node Tree

$ Input: root = [1], k = 1

› Output: 1

💡 Note: The only perfect subtree is the root itself with size 1.

example_3.py — No Perfect Subtrees of Required Rank

$ Input: root = [1,2,null,3], k = 2

› Output: -1

💡 Note: Only one perfect subtree exists (leaf node 3 with size 1), but we need the 2nd largest.

Visualization

Tap to expand

Understanding the Visualization

Identify Leaf Families

Single individuals (leaf nodes) are considered perfect families of size 1

Check Parent Generations

A parent forms a perfect family if both children lead perfect families of the same depth

Calculate Family Sizes

Perfect family size = left family + right family + parent (1)

Collect and Rank

Gather all perfect family sizes and rank them to find the k-th largest

Key Takeaway

🎯 Key Insight: A subtree is perfect if both its children are perfect subtrees of equal height, enabling efficient bottom-up detection in a single traversal.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for single DFS traversal + O(p log p) for sorting perfect subtree sizes where p ≤ n

⚡ Linearithmic

Space Complexity

O(n)

O(h) for recursion stack where h is tree height, plus O(p) for storing perfect subtree sizes

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 2000]
1 ≤ Node.val ≤ 2000
1 ≤ k ≤ 1024

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses a single DFS traversal to identify perfect subtrees by checking if both children are perfect with equal heights. We collect sizes during traversal and sort once at the end, achieving O(n + p log p) time complexity where p is the number of perfect subtrees.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subtrees)	O(n²)	O(n)	Check every subtree for perfection, collect sizes, and sort
Single DFS with Size Collection (Optimal)	O(n log n)	O(n)	One traversal to identify perfect subtrees and collect sizes efficiently

Brute Force (Check All Subtrees) — Algorithm Steps

Start DFS from root to visit every node
For each node, check if subtree rooted at that node is perfect
Use helper function to verify perfect tree (all leaves same level, all internal nodes have 2 children)
Collect sizes of all perfect subtrees in a list
Sort the list in descending order
Return the k-th element or -1 if k exceeds list length

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Each Node

Start DFS traversal from root, visiting every node

Check Perfection

For each node, verify if subtree rooted there is perfect

Collect Sizes

Store sizes of all perfect subtrees found

Sort and Select

Sort sizes in descending order and return k-th element

Code -

solution.c — C

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

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

struct PerfectInfo {
    bool isPerfect;
    int height;
    int size;
};

struct PerfectInfo isPerfect(struct TreeNode* node) {
    struct PerfectInfo result;
    
    if (!node) {
        result.isPerfect = true;
        result.height = 0;
        result.size = 0;
        return result;
    }
    
    if (!node->left && !node->right) {
        result.isPerfect = true;
        result.height = 1;
        result.size = 1;
        return result;
    }
    
    if (!node->left || !node->right) {
        result.isPerfect = false;
        result.height = 0;
        result.size = 0;
        return result;
    }
    
    struct PerfectInfo leftInfo = isPerfect(node->left);
    struct PerfectInfo rightInfo = isPerfect(node->right);
    
    if (leftInfo.isPerfect && rightInfo.isPerfect && 
        leftInfo.height == rightInfo.height) {
        result.isPerfect = true;
        result.height = leftInfo.height + 1;
        result.size = leftInfo.size + rightInfo.size + 1;
        return result;
    }
    
    result.isPerfect = false;
    result.height = 0;
    result.size = 0;
    return result;
}

void collectPerfectSizes(struct TreeNode* node, int* sizes, int* count) {
    if (!node) return;
    
    struct PerfectInfo info = isPerfect(node);
    if (info.isPerfect) {
        sizes[(*count)++] = info.size;
    }
    
    collectPerfectSizes(node->left, sizes, count);
    collectPerfectSizes(node->right, sizes, count);
}

int compare(const void* a, const void* b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int kthLargestPerfectSubtree(struct TreeNode* root, int k) {
    int* sizes = (int*)malloc(10000 * sizeof(int));
    int count = 0;
    
    collectPerfectSizes(root, sizes, &count);
    qsort(sizes, count, sizeof(int), compare);
    
    int result = (k <= count) ? sizes[k - 1] : -1;
    free(sizes);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire subtree to check if it's perfect

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for perfect subtree sizes and recursion stack

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 2000]
1 ≤ Node.val ≤ 2000
1 ≤ k ≤ 1024

43.8K Views

Medium 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Subtrees) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler