Minimum Number of Operations to Sort a Binary Tree by Level

Minimum Number of Operations to Sort a Binary Tree by Level - Problem

You're given a binary tree where each node contains a unique value. Your task is to sort each level of the tree in strictly increasing order using the minimum number of swap operations possible.

The Challenge: In one operation, you can choose any two nodes at the same level and swap their values. You cannot swap values between different levels - only nodes that are at the same distance from the root.

Goal: Return the minimum number of swaps needed to make all levels sorted from left to right in ascending order.

Example: If a level contains values [7, 6, 8, 5], you need to determine the minimum swaps to make it [5, 6, 7, 8].

Input & Output

example_1.py — Basic Tree

$ Input: root = [1,4,3,7,6,8,5]

› Output: 3

💡 Note: Level 1: [1] (already sorted). Level 2: [4,3] → swap to get [3,4] (1 swap). Level 3: [7,6,8,5] → need 2 swaps to get [5,6,7,8]. Total: 0 + 1 + 2 = 3 swaps.

example_2.py — Already Sorted

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

› Output: 3

💡 Note: Level 1: [1] (sorted). Level 2: [3,2] → 1 swap to get [2,3]. Level 3: [7,6,5,4] → 2 swaps minimum to get [4,5,6,7]. Total: 3 swaps.

example_3.py — Single Node

$ Input: root = [1]

› Output: 0

💡 Note: Only one node, already sorted at every level. No swaps needed.

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁵
All values in the tree are unique
The tree is guaranteed to be a valid binary tree

Visualization

Tap to expand

Understanding the Visualization

Level-Order Traversal

Use BFS to visit each level of the tree from left to right

Extract Level Values

Collect all node values at each level into separate arrays

Find Sorting Permutation

For each level, determine what swaps are needed to sort the values

Count Minimum Swaps

Use cycle detection to find the minimum number of swaps required

Key Takeaway

🎯 Key Insight: The minimum number of swaps to sort an array equals the array length minus the number of cycles in the permutation that transforms the array to its sorted form.

Asked in

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

The optimal solution uses BFS traversal to collect values level by level, then applies cycle detection to find minimum swaps needed to sort each level. The key insight is that minimum swaps equals array length minus number of cycles in the sorting permutation. Time complexity: O(n log k) where n is total nodes and k is maximum level size.

Common Approaches

Approach	Time	Space	Notes
✓ BFS + Cycle Detection (Optimal)	O(n log k)	O(k)	Use BFS to collect levels, then find cycles in sorting permutation
Brute Force (Try All Swaps)	O(n! * k)	O(h + k)	Generate all possible swap combinations for each level until sorted

BFS + Cycle Detection (Optimal) — Algorithm Steps

Use BFS to traverse tree and collect values for each level
For each level array, create a mapping from value to its target sorted position
Build a graph where each position points to where its element should go
Count the number of cycles in this permutation graph
Calculate minimum swaps as (array length - number of cycles)

Visualization

Tap to expand

Step-by-Step Walkthrough

BFS Traversal

Collect values level by level

Create Index Map

Map each value to its sorted position

Find Cycles

Follow permutation links to detect cycles

Count Swaps

Minimum swaps = n - cycles - fixed

Code -

solution.c — C

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

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

typedef struct {
    int value;
    int index;
} IndexedValue;

typedef struct {
    TreeNode** items;
    int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->items = (TreeNode**)malloc(capacity * sizeof(TreeNode*));
    q->front = q->size = 0;
    q->rear = capacity - 1;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, TreeNode* item) {
    q->rear = (q->rear + 1) % q->capacity;
    q->items[q->rear] = item;
    q->size++;
}

TreeNode* dequeue(Queue* q) {
    TreeNode* item = q->items[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return item;
}

int compareIndexedValues(const void *a, const void *b) {
    IndexedValue *ia = (IndexedValue *)a;
    IndexedValue *ib = (IndexedValue *)b;
    return (ia->value - ib->value);
}

int minSwapsToSort(int* arr, int n) {
    if (n <= 1) return 0;
    
    IndexedValue* indexedArr = (IndexedValue*)malloc(n * sizeof(IndexedValue));
    
    for (int i = 0; i < n; i++) {
        indexedArr[i].value = arr[i];
        indexedArr[i].index = i;
    }
    
    qsort(indexedArr, n, sizeof(IndexedValue), compareIndexedValues);
    
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int cycles = 0;
    
    for (int i = 0; i < n; i++) {
        if (visited[i] || indexedArr[i].index == i) {
            continue;
        }
        
        int cycleLength = 0;
        int current = i;
        
        while (!visited[current]) {
            visited[current] = true;
            current = indexedArr[current].index;
            cycleLength++;
        }
        
        if (cycleLength > 1) {
            cycles++;
        }
    }
    
    int fixedElements = 0;
    for (int i = 0; i < n; i++) {
        if (indexedArr[i].index == i) {
            fixedElements++;
        }
    }
    
    free(indexedArr);
    free(visited);
    
    return n - cycles - fixedElements;
}

int minimumOperations(TreeNode* root) {
    if (!root) return 0;
    
    int totalSwaps = 0;
    Queue* queue = createQueue(10000);
    enqueue(queue, root);
    
    while (queue->size > 0) {
        int levelSize = queue->size;
        int* levelValues = (int*)malloc(levelSize * sizeof(int));
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode* node = dequeue(queue);
            levelValues[i] = node->val;
            
            if (node->left) enqueue(queue, node->left);
            if (node->right) enqueue(queue, node->right);
        }
        
        totalSwaps += minSwapsToSort(levelValues, levelSize);
        free(levelValues);
    }
    
    free(queue->items);
    free(queue);
    return totalSwaps;
}

int main() {
    printf("0\n"); // Placeholder
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

O(n) for BFS traversal, O(k log k) for sorting each level, where k is max level size

⚡ Linearithmic

Space Complexity

O(k)

O(k) for storing level values and index mappings, where k is maximum level size

✓ Linear Space

78.7K Views

Medium-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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS + Cycle Detection (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler