Reverse alternate levels of a perfect binary tree

Last Updated : 3 Jun, 2026

Given the root of a binary tree, reverse the values of nodes at every alternate level from left to right, while keeping the tree structure unchanged. Only the node values may be modified. The root node is considered to be at level 0. Therefore, values at levels 1, 3, 5, ... are reversed.

Examples:

Input: root[] = [1, 2, 3, 42, 51, 63, 72]

Output:

Explanation: Level 1 contains the nodes 2 and 3, so their values are swapped. Levels 0 and 2 remain unchanged.

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

Output:

Explanation: Level 1 contains only one node, so reversing it has no visible effect. At level 3, the node values are reversed from left to right. Levels 0 and 2 remain unchanged.

Try It Yourself

[Expected Approach 1] Level Order Traversal with Extra Value Array - O(n) Time O(n) Space

The idea is based on level-order traversal line by line. For every alternate level (1, 3, 5, ...), store the node values in a separate array, reverse the array, and then assign the reversed values back to the nodes of that level. The tree structure remains unchanged; only node values are modified.

C++

#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

class Node
{
  public:
    int data;
    Node *left;
    Node *right;

    Node(int val)
    {
        data = val;
        left = nullptr;
        right = nullptr;
    }
};

void alternateReverse(Node *root)
{

    // If tree is empty, nothing to reverse
    if (root == nullptr)
        return;

    queue<Node *> q;
    q.push(root);

    // Root is at level 0
    int lvl = 0;

    // Perform level order traversal
    while (!q.empty())
    {

        int sz = q.size();

        // Stores nodes and values of current odd level
        vector<Node *> nodes;
        vector<int> values;

        for (int i = 0; i < sz; i++)
        {

            Node *curr = q.front();
            q.pop();

            // Store nodes and values only for odd levels
            if (lvl % 2 == 1)
            {
                nodes.push_back(curr);
                values.push_back(curr->data);
            }

            // Push left child
            if (curr->left)
                q.push(curr->left);

            // Push right child
            if (curr->right)
                q.push(curr->right);
        }

        // Reverse values at alternate levels
        if (lvl % 2 == 1)
        {

            reverse(values.begin(), values.end());

            // Assign reversed values back to nodes
            for (int i = 0; i < nodes.size(); i++)
            {
                nodes[i]->data = values[i];
            }
        }

        lvl++;
    }
}

// Inorder traversal of tree
void inorder(Node *root)
{

    if (root == nullptr)
        return;

    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

// Driver Code
int main()
{

    Node *root = new Node(1);

    root->left = new Node(2);
    root->right = new Node(3);

    root->left->left = new Node(42);
    root->left->right = new Node(51);

    root->right->left = new Node(63);
    root->right->right = new Node(72);

    alternateReverse(root);

    inorder(root);

    return 0;
}

Java

import java.util.*;

class Node {
    int data;
    Node left, right;

    Node(int val)
    {
        data = val;
        left = right = null;
    }
}

public class GfG {
    static void alternateReverse(Node root)
    {
        if (root == null)
            return;

        Queue<Node> q = new LinkedList<>();
        q.add(root);

        int lvl = 0;

        while (!q.isEmpty()) {
            int sz = q.size();

            List<Node> nodes = new ArrayList<>();
            List<Integer> values = new ArrayList<>();

            for (int i = 0; i < sz; i++) {
                Node curr = q.poll();

                if (lvl % 2 == 1) {
                    nodes.add(curr);
                    values.add(curr.data);
                }

                if (curr.left != null)
                    q.add(curr.left);
                if (curr.right != null)
                    q.add(curr.right);
            }

            if (lvl % 2 == 1) {
                Collections.reverse(values);
                for (int i = 0; i < nodes.size(); i++)
                    nodes.get(i).data = values.get(i);
            }

            lvl++;
        }
    }

    static void inorder(Node root)
    {
        if (root == null)
            return;

        inorder(root.left);
        System.out.print(root.data + " ");
        inorder(root.right);
    }

    public static void main(String[] args)
    {
        Node root = new Node(1);

        root.left = new Node(2);
        root.right = new Node(3);

        root.left.left = new Node(42);
        root.left.right = new Node(51);

        root.right.left = new Node(63);
        root.right.right = new Node(72);

        alternateReverse(root);
        inorder(root);
    }
}

Python

from collections import deque


class Node:
    def __init__(self, val):
        self.data = val
        self.left = None
        self.right = None


def alternateReverse(root):
    if root is None:
        return

    q = deque([root])
    lvl = 0

    while q:
        sz = len(q)
        nodes = []
        values = []

        for _ in range(sz):
            curr = q.popleft()

            if lvl % 2 == 1:
                nodes.append(curr)
                values.append(curr.data)

            if curr.left is not None:
                q.append(curr.left)
            if curr.right is not None:
                q.append(curr.right)

        if lvl % 2 == 1:
            values.reverse()
            for i in range(len(nodes)):
                nodes[i].data = values[i]

        lvl += 1


def inorder(root):
    if root is None:
        return

    inorder(root.left)
    print(root.data, end=' ')
    inorder(root.right)


if __name__ == '__main__':
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(42)
    root.left.right = Node(51)
    root.right.left = Node(63)
    root.right.right = Node(72)

    alternateReverse(root)
    inorder(root)

C#

using System;
using System.Collections.Generic;

public class Node {
    public int data;
    public Node left;
    public Node right;

    public Node(int val)
    {
        data = val;
        left = null;
        right = null;
    }
}

public class GfG {
    public static void alternateReverse(Node root)
    {
        // If tree is empty, nothing to reverse
        if (root == null)
            return;

        Queue<Node> q = new Queue<Node>();
        q.Enqueue(root);

        // Root is at level 0
        int lvl = 0;

        // Perform level order traversal
        while (q.Count > 0) {
            int sz = q.Count;

            // Stores nodes and values of current odd level
            List<Node> nodes = new List<Node>();
            List<int> values = new List<int>();

            for (int i = 0; i < sz; i++) {
                Node curr = q.Dequeue();

                // Store nodes and values only for odd
                // levels
                if (lvl % 2 == 1) {
                    nodes.Add(curr);
                    values.Add(curr.data);
                }

                // Push left child
                if (curr.left != null)
                    q.Enqueue(curr.left);

                // Push right child
                if (curr.right != null)
                    q.Enqueue(curr.right);
            }

            // Reverse values at alternate levels
            if (lvl % 2 == 1) {
                values.Reverse();

                // Assign reversed values back to nodes
                for (int i = 0; i < nodes.Count; i++) {
                    nodes[i].data = values[i];
                }
            }

            lvl++;
        }
    }

    // Inorder traversal of tree
    public static void inorder(Node root)
    {
        if (root == null)
            return;

        inorder(root.left);
        Console.Write(root.data + " ");
        inorder(root.right);
    }

    // Driver Code
    public static void Main(string[] args)
    {
        Node root = new Node(1);

        root.left = new Node(2);
        root.right = new Node(3);

        root.left.left = new Node(42);
        root.left.right = new Node(51);

        root.right.left = new Node(63);
        root.right.right = new Node(72);

        alternateReverse(root);

        inorder(root);
    }
}

JavaScript

class Node {
    constructor(val)
    {
        this.data = val;
        this.left = null;
        this.right = null;
    }
}

function alternateReverse(root)
{
    // If tree is empty, nothing to reverse
    if (root === null)
        return;

    let q = [];
    q.push(root);

    // Root is at level 0
    let lvl = 0;

    // Perform level order traversal
    while (q.length > 0) {
        let sz = q.length;

        // Stores nodes and values of current odd level
        let nodes = [];
        let values = [];

        for (let i = 0; i < sz; i++) {
            let curr = q.shift();

            // Store nodes and values only for odd levels
            if (lvl % 2 === 1) {
                nodes.push(curr);
                values.push(curr.data);
            }

            // Push left child
            if (curr.left !== null)
                q.push(curr.left);

            // Push right child
            if (curr.right !== null)
                q.push(curr.right);
        }

        // Reverse values at alternate levels
        if (lvl % 2 === 1) {
            values.reverse();

            // Assign reversed values back to nodes
            for (let i = 0; i < nodes.length; i++) {
                nodes[i].data = values[i];
            }
        }

        lvl++;
    }
}

// Inorder traversal of tree
function inorder(root)
{
    if (root === null)
        return;

    inorder(root.left);
    console.log(root.data);
    inorder(root.right);
}

// Driver Code
let root = new Node(1);

root.left = new Node(2);
root.right = new Node(3);

root.left.left = new Node(42);
root.left.right = new Node(51);

root.right.left = new Node(63);
root.right.right = new Node(72);

alternateReverse(root);

inorder(root);

Output

42 3 51 1 63 2 72

[Expected Approach 2] Level Order Traversal and Pointer Array - O(n) Time O(n) Space

The idea is same as above except the fact that we use pointer or reference array to store items of a level. In real world situations, the actual data maybe large, so this is a space optimized version for nodes having large data.

C++

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

class Node
{
  public:
    int data;
    Node *left;
    Node *right;

    Node(int val)
    {
        data = val;
        left = nullptr;
        right = nullptr;
    }
};

void alternateReverse(Node *root)
{
    // If tree is empty, nothing to reverse
    if (!root)
        return;

    queue<Node *> q;
    q.push(root);

    // Root is considered at level 0
    int lvl = 0;

    // Standard BFS traversal
    while (!q.empty())
    {
        int sz = q.size();

        // Stores all nodes present at current level
        vector<Node *> cur;

        for (int i = 0; i < sz; i++)
        {
            Node *node = q.front();
            q.pop();

            cur.push_back(node);

            // Push left and right child for next level traversal
            if (node->left)
                q.push(node->left);

            if (node->right)
                q.push(node->right);
        }

        // Reverse node values at alternate levels
        // Here, levels 1, 3, 5 ... are reversed
        if (lvl % 2 == 1)
        {
            int l = 0;
            int r = cur.size() - 1;

            // Swap values from both ends
            while (l < r)
            {
                swap(cur[l]->data, cur[r]->data);
                l++;
                r--;
            }
        }

        lvl++;
    }
}

// Inorder traversal of tree
void inorder(Node *root)
{
    if (root == nullptr)
        return;

    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

// Driver Code
int main()
{
    Node *root = new Node(1);

    root->left = new Node(2);
    root->right = new Node(3);

    root->left->left = new Node(42);
    root->left->right = new Node(51);

    root->right->left = new Node(63);
    root->right->right = new Node(72);

    alternateReverse(root);

    inorder(root);

    return 0;
}

Java

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

class Node {
    public int data;
    public Node left;
    public Node right;

    public Node(int val)
    {
        data = val;
        left = null;
        right = null;
    }
}

public class GfG {
    public static void alternateReverse(Node root)
    {
        // If tree is empty, nothing to reverse
        if (root == null)
            return;

        Queue<Node> q = new LinkedList<>();
        q.add(root);

        // Root is considered at level 0
        int lvl = 0;

        // Standard BFS traversal
        while (!q.isEmpty()) {
            int sz = q.size();

            // Stores all nodes present at current level
            Stack<Node> cur = new Stack<>();

            for (int i = 0; i < sz; i++) {
                Node node = q.poll();

                cur.push(node);

                // Push left and right child for next level
                // traversal
                if (node.left != null)
                    q.add(node.left);

                if (node.right != null)
                    q.add(node.right);
            }

            // Reverse node values at alternate levels
            // Here, levels 1, 3, 5... are reversed
            if (lvl % 2 == 1) {
                int l = 0;
                int r = cur.size() - 1;

                // Swap values from both ends
                while (l < r) {
                    int temp = cur.get(l).data;
                    cur.get(l).data = cur.get(r).data;
                    cur.get(r).data = temp;
                    l++;
                    r--;
                }
            }

            lvl++;
        }
    }

    // Inorder traversal of tree
    public static void inorder(Node root)
    {
        if (root == null)
            return;

        inorder(root.left);
        System.out.print(root.data + " ");
        inorder(root.right);
    }

    // Driver Code
    public static void main(String[] args)
    {
        Node root = new Node(1);

        root.left = new Node(2);
        root.right = new Node(3);

        root.left.left = new Node(42);
        root.left.right = new Node(51);

        root.right.left = new Node(63);
        root.right.right = new Node(72);

        alternateReverse(root);

        inorder(root);
    }
}

Python

from collections import deque


class Node:
    def __init__(self, val):
        self.data = val
        self.left = None
        self.right = None


def alternateReverse(root):
    # If tree is empty, nothing to reverse
    if not root:
        return

    q = deque([root])

    # Root is considered at level 0
    lvl = 0

    # Standard BFS traversal
    while q:
        sz = len(q)

        # Stores all nodes present at current level
        cur = []

        for _ in range(sz):
            node = q.popleft()
            cur.append(node)

            # Push left and right child for next level traversal
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)

        # Reverse node values at alternate levels
        # Here, levels 1, 3, 5... are reversed
        if lvl % 2 == 1:
            l, r = 0, len(cur) - 1

            # Swap values from both ends
            while l < r:
                cur[l].data, cur[r].data = cur[r].data, cur[l].data
                l += 1
                r -= 1

        lvl += 1

# Inorder traversal of tree


def inorder(root):
    if root is None:
        return

    inorder(root.left)
    print(root.data, end=' ')
    inorder(root.right)


# Driver Code
if __name__ == '__main__':
    root = Node(1)

    root.left = Node(2)
    root.right = Node(3)

    root.left.left = Node(42)
    root.left.right = Node(51)

    root.right.left = Node(63)
    root.right.right = Node(72)

    alternateReverse(root)

    inorder(root)

C#

using System;
using System.Collections.Generic;

public class Node {
    public int data;
    public Node left;
    public Node right;

    public Node(int val)
    {
        data = val;
        left = null;
        right = null;
    }
}

public class GfG {
    public static void alternateReverse(Node root)
    {
        // If tree is empty, nothing to reverse
        if (root == null)
            return;

        Queue<Node> q = new Queue<Node>();
        q.Enqueue(root);

        // Root is considered at level 0
        int lvl = 0;

        // Standard BFS traversal
        while (q.Count > 0) {
            int sz = q.Count;

            // Stores all nodes present at current level
            List<Node> cur = new List<Node>();

            for (int i = 0; i < sz; i++) {
                Node node = q.Dequeue();

                cur.Add(node);

                // Push left and right child for next level
                // traversal
                if (node.left != null)
                    q.Enqueue(node.left);

                if (node.right != null)
                    q.Enqueue(node.right);
            }

            // Reverse node values at alternate levels
            // Here, levels 1, 3, 5... are reversed
            if (lvl % 2 == 1) {
                int l = 0;
                int r = cur.Count - 1;

                // Swap values from both ends
                while (l < r) {
                    int temp = cur[l].data;
                    cur[l].data = cur[r].data;
                    cur[r].data = temp;
                    l++;
                    r--;
                }
            }

            lvl++;
        }
    }

    // Inorder traversal of tree
    public static void inorder(Node root)
    {
        if (root == null)
            return;

        inorder(root.left);
        Console.Write(root.data + " ");
        inorder(root.right);
    }

    // Driver Code
    public static void Main()
    {
        Node root = new Node(1);

        root.left = new Node(2);
        root.right = new Node(3);

        root.left.left = new Node(42);
        root.left.right = new Node(51);

        root.right.left = new Node(63);
        root.right.right = new Node(72);

        alternateReverse(root);

        inorder(root);
    }
}

JavaScript

class Node {
    constructor(val)
    {
        this.data = val;
        this.left = null;
        this.right = null;
    }
}

function alternateReverse(root)
{
    // If tree is empty, nothing to reverse
    if (!root)
        return;

    let q = [];
    q.push(root);

    // Root is considered at level 0
    let lvl = 0;

    // Standard BFS traversal
    while (q.length > 0) {
        let sz = q.length;

        // Stores all nodes present at current level
        let cur = [];

        for (let i = 0; i < sz; i++) {
            let node = q.shift();

            cur.push(node);

            // Push left and right child for next level
            // traversal
            if (node.left)
                q.push(node.left);

            if (node.right)
                q.push(node.right);
        }

        // Reverse node values at alternate levels
        // Here, levels 1, 3, 5... are reversed
        if (lvl % 2 == 1) {
            let l = 0;
            let r = cur.length - 1;

            // Swap values from both ends
            while (l < r) {
                [cur[l].data, cur[r].data] =
                    [ cur[r].data, cur[l].data ];
                l++;
                r--;
            }
        }

        lvl++;
    }
}

// Inorder traversal of tree
function inorder(root)
{
    if (root == null)
        return;

    inorder(root.left);
    console.log(root.data);
    inorder(root.right);
}

// Driver Code
let root = new Node(1);

root.left = new Node(2);
root.right = new Node(3);

root.left.left = new Node(42);
root.left.right = new Node(51);

root.right.left = new Node(63);
root.right.right = new Node(72);

alternateReverse(root);
inorder(root);

Output

42 3 51 1 63 2 72

Time Complexity: O(n)
Auxiliary Space: O(n)

Comment

Article Tags:

Explore