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

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

✓ BFS + Cycle Detection (Optimal)

⏱️ Time: O(n log k) Space: O(k)

This approach uses BFS to traverse the tree level by level, then for each level, calculates the minimum swaps needed by finding cycles in the permutation that sorts the array. The key insight is that minimum swaps = array length - number of cycles.

Brute Force (Try All Swaps)

⏱️ Time: O(n! * k) Space: O(h + k)

For each level, try all possible combinations of swaps until we find the minimum number needed to sort the level. This involves recursive backtracking to explore all swap possibilities.

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 swaps = 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 > 0) {
            swaps += cycleLength - 1;
        }
    }
    
    free(indexedArr);
    free(visited);
    
    return swaps;
}

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