Print Binary Tree in 2-Dimensions

Last Updated : 23 Jul, 2025

Given a Binary Tree, the task is to print the tree in a 2-dimensional layout.

Examples: 

Input:

Print-Binary-Tree-in-2-Dimensions-1

Output:
1
2 3
4 5

Input:

Print-Binary-Tree-in-2-Dimensions-2

Output:
1
2

Table of Content

Using Inorder Traversal - O(n) Time and O(n) Space

The idea is to print a binary tree in a 2D matrix format using Inorder Traversal. First, we calculate the height of the tree to determine the number of rows and columns required in the matrix. Then, we perform an Inorder Traversal, placing the node values at the appropriate positions based on the traversal order and calculating the column offsets to properly position each node. Finally, we print the matrix, ensuring that empty positions are represented as spaces.

C++ 
// C++ code to print Binary Tree in 2D
// using Inorder Traversal
#include <bits/stdc++.h>
using namespace std;

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

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

// Function to find the height of the binary tree
int findHeight(Node *root) {
    if (!root) {
        return -1;
    }

    int leftHeight = findHeight(root->left);
    int rightHeight = findHeight(root->right);

    return max(leftHeight, rightHeight) + 1;
}

// Helper function to perform inorder traversal and
// populate the 2D matrix
void inorder(Node *root, int row, int col, int height,
             vector<vector<string>> &ans) {
    if (!root) {
        return;
    }

    // Calculate offset for child positions
    int offset = pow(2, height - row - 1);

    // Traverse the left subtree
    if (root->left) {
        inorder(root->left, row + 1, col - offset, height, ans);
    }

    // Place the current node's value in the matrix
    ans[row][col] = to_string(root->data);

    // Traverse the right subtree
    if (root->right) {
        inorder(root->right, row + 1, col + offset, height, ans);
    }
}

// Function to convert the binary tree to a 2D matrix
vector<vector<string>> treeToMatrix(Node *root) {

    // Find the height of the tree
    int height = findHeight(root);

    // Rows are height + 1; columns are 2^(height+1) - 1
    int rows = height + 1;
    int cols = pow(2, height + 1) - 1;

    // Initialize 2D matrix with empty strings
    vector<vector<string>> ans(rows, vector<string>(cols, ""));

    // Populate the matrix using inorder traversal
    inorder(root, 0, (cols - 1) / 2, height, ans);

    return ans;
}

void print2DArray(vector<vector<string>> &arr) {
    for (auto &row : arr) {
        for (auto &cell : row) {
            if (cell.empty()) {
                cout << " ";
            }
            else {
                cout << cell;
            }
        }
        cout << endl;
    }
}

int main() {

    // Hardcoded binary tree
    //        1
    //       / \ 
    //      2   3
    //         / \  
    //        4   5
    Node *root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->right->left = new Node(4);
    root->right->right = new Node(5);

    vector<vector<string>> result = treeToMatrix(root);

    print2DArray(result);

    return 0;
}
Java 
// Java code to print Binary Tree in 2D using 
// Inorder Traversal
import java.util.*;

class Node {
    int data;
    Node left, right;

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

class GfG {

    // Function to find the height of the binary tree
    static int findHeight(Node root) {
        if (root == null) {
            return -1;
        }

        int leftHeight = findHeight(root.left);
        int rightHeight = findHeight(root.right);

        return Math.max(leftHeight, rightHeight) + 1;
    }

    // Helper function to perform inorder traversal and
    // populate the 2D matrix
    static void inorder(Node root, int row, int col, 
                        int height, 
                        List<List<String>> ans) {
        if (root == null) {
            return;
        }

        // Calculate offset for child positions
        int offset = (int) Math.pow(2, height - row - 1);

        // Traverse the left subtree
        if (root.left != null) {
            inorder(root.left, row + 1, col - offset,
                    height, ans);
        }

        // Place the current node's value in the matrix
        ans.get(row).set(col, String.valueOf(root.data));

        // Traverse the right subtree
        if (root.right != null) {
            inorder(root.right, row + 1, col + offset,
                    height, ans);
        }
    }

    // Function to convert the binary tree to a 2D matrix
    static List<List<String>> treeToMatrix(Node root) {

        // Find the height of the tree
        int height = findHeight(root);

        // Rows are height + 1; columns are 2^(height+1) - 1
        int rows = height + 1;
        int cols = (int) Math.pow(2, height + 1) - 1;

        // Initialize 2D matrix with empty strings
        List<List<String>> ans = new ArrayList<>();
        for (int i = 0; i < rows; i++) {
            List<String> row = new ArrayList<>(Collections
                                               .nCopies(cols, ""));
            ans.add(row);
        }

        // Populate the matrix using inorder traversal
        inorder(root, 0, (cols - 1) / 2, height, ans);

        return ans;
    }

    // Function to print a 2D matrix
    static void print2DArray(List<List<String>> arr) {
        for (List<String> row : arr) {
            for (String cell : row) {
                if (cell.isEmpty()) {
                    System.out.print(" ");
                } else {
                    System.out.print(cell);
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {

        // Hardcoded binary tree
        //        1
        //       / \ 
        //      2   3 
        //         / \  
        //        4   5 
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);

        List<List<String>> result = treeToMatrix(root);

        print2DArray(result);
    }
}
Python 
# Python code to print Binary Tree in 2D using 
# Inorder Traversal
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
        
# Function to find the height of the binary tree
def find_height(root):
    if not root:
        return -1

    left_height = find_height(root.left)
    right_height = find_height(root.right)

    return max(left_height, right_height) + 1

# Helper function to perform inorder traversal 
# and populate the 2D matrix
def inorder(root, row, col, height, ans):
    if not root:
        return

    # Calculate offset for child positions
    offset = 2 ** (height - row - 1)

    # Traverse the left subtree
    if root.left:
        inorder(root.left, row + 1, col - offset, 
                height, ans)

    # Place the current node's value in the matrix
    ans[row][col] = str(root.data)

    # Traverse the right subtree
    if root.right:
        inorder(root.right, row + 1, col + offset, 
                height, ans)

# Function to convert the binary tree to a 2D matrix
def tree_to_matrix(root):
  
    # Find the height of the tree
    height = find_height(root)

    # Rows are height + 1; columns are 2^(height+1) - 1
    rows = height + 1
    cols = 2 ** (height + 1) - 1

    # Initialize 2D matrix with empty strings
    ans = [["" for _ in range(cols)] for _ in range(rows)]

    # Populate the matrix using inorder traversal
    inorder(root, 0, (cols - 1) // 2, height, ans)

    return ans

# Function to print a 2D matrix
def print_2d_array(arr):
    for row in arr:
        for cell in row:
            if cell == "":
                print(" ", end="")
            else:
                print(cell, end="")
        print()

if __name__ == "__main__":
  
    # Hardcoded binary tree
    #        1
    #       / \ 
    #      2   3 
    #         / \  
    #        4   5 
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.right.left = Node(4)
    root.right.right = Node(5)

    result = tree_to_matrix(root)

    print_2d_array(result)
C# 
// C# code to print Binary Tree in 2D using
// Inorder Traversal
using System;
using System.Collections.Generic;

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

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

class GfG {

    // Function to find the height of the binary tree
    static int FindHeight(Node root) {
        if (root == null) {
            return -1;
        }

        int leftHeight = FindHeight(root.left);
        int rightHeight = FindHeight(root.right);

        return Math.Max(leftHeight, rightHeight) + 1;
    }

    // Helper function to perform inorder traversal and
    // populate the 2D matrix
    static void Inorder(Node root, int row, int col,
                        int height, List<List<string> > ans) {
        if (root == null) {
            return;
        }

        // Calculate offset for child positions
        int offset = (int)Math.Pow(2, height - row - 1);

        // Traverse the left subtree
        if (root.left != null) {
            Inorder(root.left, row + 1, col - offset,
                    height, ans);
        }

        // Place the current node's value in the matrix
        ans[row][col] = root.data.ToString();

        // Traverse the right subtree
        if (root.right != null) {
            Inorder(root.right, row + 1, col + offset,
                    height, ans);
        }
    }

    // Function to convert the binary tree to a 2D matrix
    static List<List<string> > TreeToMatrix(Node root) {

        // Find the height of the tree
        int height = FindHeight(root);

        // Rows are height + 1; columns are 2^(height+1) - 1
        int rows = height + 1;
        int cols = (int)Math.Pow(2, height + 1) - 1;

        // Initialize 2D matrix with empty strings
        List<List<string> > ans = new List<List<string> >();
        for (int i = 0; i < rows; i++) {
            ans.Add(new List<string>(new string[cols]));
        }

        // Populate the matrix using inorder traversal
        Inorder(root, 0, (cols - 1) / 2, height, ans);

        return ans;
    }

    // Function to print a 2D matrix
    static void Print2DArray(List<List<string> > arr) {
        foreach(var row in arr) {
            foreach(var cell in row) {
                if (string.IsNullOrEmpty(cell)) {
                    Console.Write(" ");
                }
                else {
                    Console.Write(cell);
                }
            }
            Console.WriteLine();
        }
    }

    static void Main(string[] args) {

        // Hardcoded binary tree
        //        1
        //       / \ 
        //      2   3
        //         / \  
        //        4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);

        List<List<string> > result = TreeToMatrix(root);

        Print2DArray(result);
    }
}
JavaScript 
// JavaScript code to print Binary Tree in 2D 
// using Inorder Traversal
// Node class for the binary tree
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// Function to find the height of the binary tree
function findHeight(root) {
    if (!root) {
        return -1;
    }

    let leftHeight = findHeight(root.left);
    let rightHeight = findHeight(root.right);

    return Math.max(leftHeight, rightHeight) + 1;
}

// Helper function to perform inorder traversal 
// and populate the 2D matrix
function inorder(root, row, col, height, ans) {
    if (!root) {
        return;
    }

    // Calculate offset for child positions
    let offset = Math.pow(2, height - row - 1);

    // Traverse the left subtree
    if (root.left) {
        inorder(root.left, row + 1, col - offset, 
                height, ans);
    }

    // Place the current node's value in the matrix
    ans[row][col] = root.data.toString();

    // Traverse the right subtree
    if (root.right) {
        inorder(root.right, row + 1, col + offset, 
                height, ans);
    }
}

// Function to convert the binary tree to a 2D matrix
function treeToMatrix(root) {

    // Find the height of the tree
    let height = findHeight(root);

    // Rows are height + 1; columns are 2^(height+1) - 1
    let rows = height + 1;
    let cols = Math.pow(2, height + 1) - 1;

    // Initialize 2D matrix with empty strings
    let ans = Array.from({ length: rows }, () =>
              Array(cols).fill(""));

    // Populate the matrix using inorder traversal
    inorder(root, 0, Math.floor((cols - 1) / 2), 
            height, ans);

    return ans;
}

// Function to print a 2D matrix
function print2DArray(arr) {
    arr.forEach(row => {
        console.log(row.map(cell => cell === "" 
                               ? " " : cell).join(""));
    });
}

// Hardcoded binary tree
//        1
//       / \ 
//      2   3 
//         / \  
//        4   5 
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);

let result = treeToMatrix(root);

print2DArray(result);

Output
   1   
 2   3 
    4 5

Using Preorder Traversal - O(n) Time and O(n) Space

The idea is to represent a binary tree in a 2D matrix format using a preorder traversal. First, we calculate the tree's height, then recursively traverse the tree, placing each node's value at the correct row and column in the matrix. The column positions are adjusted based on the height of the tree to ensure that each node's left and right children are placed correctly. The matrix is then printed.

C++ 
// C++ code to print Binary Tree in 2D
// using Preorder Traversal
#include <bits/stdc++.h>
using namespace std;

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

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

// Function to find the height of the binary tree
int findHeight(Node *root) {
  
    if (!root) {
        return -1;
    }

    int leftHeight = findHeight(root->left);
    int rightHeight = findHeight(root->right);

    return max(leftHeight, rightHeight) + 1;
}

// Helper function to perform preorder traversal and
// populate the 2D matrix
void preorder(Node *root, int row, int col, int height,
              vector<vector<string>> &ans) {
    if (!root) {
        return;
    }

    // Place the current node's value in the matrix
    ans[row][col] = to_string(root->data);

    // Calculate offset for child positions
    int offset = pow(2, height - row - 1);

    // Traverse the left subtree
    if (root->left) {
        preorder(root->left, row + 1, col - offset, height, ans);
    }

    // Traverse the right subtree
    if (root->right) {
        preorder(root->right, row + 1, col + offset, height, ans);
    }
}

// Function to convert the binary tree to a 2D matrix
vector<vector<string>> treeToMatrix(Node *root) {

    // Find the height of the tree
    int height = findHeight(root);

    // Rows are height + 1; columns are 2^(height+1) - 1
    int rows = height + 1;
    int cols = pow(2, height + 1) - 1;

    // Initialize 2D matrix with empty strings
    vector<vector<string>> ans(rows, vector<string>(cols, ""));

    // Populate the matrix using preorder traversal
    preorder(root, 0, (cols - 1) / 2, height, ans);

    return ans;
}

void print2DArray(vector<vector<string>> &arr) {
  
    for (auto &row : arr) {
        for (auto &cell : row) {
            if (cell.empty()) {
                cout << " ";
            }
            else {
                cout << cell;
            }
        }
        cout << endl;
    }
}

int main() {

    // Hardcoded binary tree
    //        1
    //       / \ 
    //      2   3
    //         / \  
    //        4   5
    Node *root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->right->left = new Node(4);
    root->right->right = new Node(5);

    vector<vector<string>> result = treeToMatrix(root);

    print2DArray(result);

    return 0;
}
Java 
// Java code to print Binary Tree in 2D using 
// Preorder Traversal
import java.util.*;

class Node {
    int data;
    Node left, right;

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

class GfG {

    // Function to find the height of the binary tree
    static int findHeight(Node root) {
        if (root == null) {
            return -1;
        }

        int leftHeight = findHeight(root.left);
        int rightHeight = findHeight(root.right);

        return Math.max(leftHeight, rightHeight) + 1;
    }

    // Helper function to perform preorder traversal and
    // populate the 2D matrix
    static void preorder(Node root, int row, int col, 
                         int height, 
                         List<List<String>> ans) {
        if (root == null) {
            return;
        }

        // Place the current node's value in the matrix
        ans.get(row).set(col, String.valueOf(root.data));

        // Calculate offset for child positions
        int offset = (int) Math.pow(2, height - row - 1);

        // Traverse the left subtree
        if (root.left != null) {
            preorder(root.left, row + 1, col - offset,
                     height, ans);
        }

        // Traverse the right subtree
        if (root.right != null) {
            preorder(root.right, row + 1, col + offset,
                     height, ans);
        }
    }

    // Function to convert the binary tree to a 2D matrix
    static List<List<String>> treeToMatrix(Node root) {

        // Find the height of the tree
        int height = findHeight(root);

        // Rows are height + 1; columns are 2^(height+1) - 1
        int rows = height + 1;
        int cols = (int) Math.pow(2, height + 1) - 1;

        // Initialize 2D matrix with empty strings
        List<List<String>> ans = new ArrayList<>();
        for (int i = 0; i < rows; i++) {
            List<String> row = new ArrayList<>(Collections
                                               .nCopies(cols, ""));
            ans.add(row);
        }

        // Populate the matrix using preorder traversal
        preorder(root, 0, (cols - 1) / 2, height, ans);

        return ans;
    }

    static void print2DArray(List<List<String>> arr) {
        for (List<String> row : arr) {
            for (String cell : row) {
                if (cell.isEmpty()) {
                    System.out.print(" ");
                } else {
                    System.out.print(cell);
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {

        // Hardcoded binary tree
        //        1
        //       / \ 
        //      2   3 
        //         / \  
        //        4   5 
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);

        List<List<String>> result = treeToMatrix(root);

        print2DArray(result);
    }
}
Python 
# Python code to print Binary Tree in 2D using 
# Preorder Traversal
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Function to find the height of the binary tree
def find_height(root):
    if not root:
        return -1

    left_height = find_height(root.left)
    right_height = find_height(root.right)

    return max(left_height, right_height) + 1

# Helper function to perform preorder traversal 
# and populate the 2D matrix
def preorder(root, row, col, height, ans):
    if not root:
        return

    # Place the current node's value in the matrix
    ans[row][col] = str(root.data)

    # Calculate offset for child positions
    offset = 2 ** (height - row - 1)

    # Traverse the left subtree
    if root.left:
        preorder(root.left, row + 1, col - offset, 
                 height, ans)

    # Traverse the right subtree
    if root.right:
        preorder(root.right, row + 1, col + offset, 
                 height, ans)

# Function to convert the binary tree to a 2D matrix
def tree_to_matrix(root):
  
    # Find the height of the tree
    height = find_height(root)

    # Rows are height + 1; columns are 2^(height+1) - 1
    rows = height + 1
    cols = 2 ** (height + 1) - 1

    # Initialize 2D matrix with empty strings
    ans = [["" for _ in range(cols)] for _ in range(rows)]

    # Populate the matrix using preorder traversal
    preorder(root, 0, (cols - 1) // 2, height, ans)

    return ans

def print_2d_array(arr):
    for row in arr:
        for cell in row:
            if cell == "":
                print(" ", end="")
            else:
                print(cell, end="")
        print()

if __name__ == "__main__":
  
    # Hardcoded binary tree
    #        1
    #       / \ 
    #      2   3 
    #         / \  
    #        4   5 
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.right.left = Node(4)
    root.right.right = Node(5)

    result = tree_to_matrix(root)

    print_2d_array(result)
C# 
// C# code to print Binary Tree in 2D using
// Preorder Traversal
using System;
using System.Collections.Generic;

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

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

class GfG {

    // Function to find the height of the binary tree
    static int FindHeight(Node root) {
        if (root == null) {
            return -1;
        }

        int leftHeight = FindHeight(root.left);
        int rightHeight = FindHeight(root.right);

        return Math.Max(leftHeight, rightHeight) + 1;
    }

    // Helper function to perform preorder traversal
    // and populate the 2D matrix
    static void Preorder(Node root, int row, int col,
                         int height,
                         List<List<string> > ans) {
        if (root == null) {
            return;
        }

        // Place the current node's value in the matrix
        ans[row][col] = root.data.ToString();

        // Calculate offset for child positions
        int offset = (int)Math.Pow(2, height - row - 1);

        // Traverse the left subtree
        if (root.left != null) {
            Preorder(root.left, row + 1, col - offset,
                     height, ans);
        }

        // Traverse the right subtree
        if (root.right != null) {
            Preorder(root.right, row + 1, col + offset,
                     height, ans);
        }
    }

    // Function to convert the binary tree to a 2D matrix
    static List<List<string> > TreeToMatrix(Node root) {

        // Find the height of the tree
        int height = FindHeight(root);

        // Rows are height + 1; columns are 2^(height+1) - 1
        int rows = height + 1;
        int cols = (int)Math.Pow(2, height + 1) - 1;

        // Initialize 2D matrix with empty strings
        List<List<string> > ans = new List<List<string> >();
        for (int i = 0; i < rows; i++) {
            ans.Add(new List<string>(new string[cols]));
        }

        // Populate the matrix using preorder traversal
        Preorder(root, 0, (cols - 1) / 2, height, ans);

        return ans;
    }

    static void Print2DArray(List<List<string> > arr) {
        foreach(var row in arr) {
            foreach(var cell in row) {
                if (string.IsNullOrEmpty(cell)) {
                    Console.Write(" ");
                }
                else {
                    Console.Write(cell);
                }
            }
            Console.WriteLine();
        }
    }

    static void Main(string[] args) {

        // Hardcoded binary tree
        //        1
        //       / \ 
        //      2   3
        //         / \  
        //        4   5
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);

        List<List<string> > result = TreeToMatrix(root);

        Print2DArray(result);
    }
}
JavaScript 
// JavaScript code to print Binary Tree in 2D
// using Preorder Traversal
// Node class for the binary tree
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// Function to find the height of the binary tree
function findHeight(root) {
    if (!root) {
        return -1;
    }

    let leftHeight = findHeight(root.left);
    let rightHeight = findHeight(root.right);

    return Math.max(leftHeight, rightHeight) + 1;
}

// Helper function to perform preorder traversal
// and populate the 2D matrix
function preorder(root, row, col, height, ans) {
    if (!root) {
        return;
    }

    // Place the current node's value in the matrix
    ans[row][col] = root.data.toString();

    // Calculate offset for child positions
    let offset = Math.pow(2, height - row - 1);

    // Traverse the left subtree
    if (root.left) {
        preorder(root.left, row + 1, col - offset, height,
                 ans);
    }

    // Traverse the right subtree
    if (root.right) {
        preorder(root.right, row + 1, col + offset, height,
                 ans);
    }
}

// Function to convert the binary tree to a 2D matrix
function treeToMatrix(root) {

    // Find the height of the tree
    let height = findHeight(root);

    // Rows are height + 1; columns are 2^(height+1) - 1
    let rows = height + 1;
    let cols = Math.pow(2, height + 1) - 1;

    // Initialize 2D matrix with empty strings
    let ans = Array.from({length : rows},
                         () => Array(cols).fill(""));

    // Populate the matrix using preorder traversal
    preorder(root, 0, Math.floor((cols - 1) / 2), height,
             ans);

    return ans;
}

function print2DArray(arr) {
    arr.forEach(row => {
        console.log(
            row.map(cell => cell === "" ? " " : cell)
                .join(""));
    });
}

// Hardcoded binary tree
//        1
//       / \ 
//      2   3
//         / \  
//        4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);

let result = treeToMatrix(root);

print2DArray(result);

Output
   1   
 2   3 
    4 5

Using Level Order Traversal - O(n) Time and O(n) Space

The idea is to represent a binary tree in a 2D matrix format using a level order traversal. We first calculate the height of the tree, then traverse the tree level by level, placing each node’s value in the appropriate position in the matrix. The matrix is structured such that the root is centered in the top row, and child nodes are placed at calculated offsets based on the tree height. Finally, the matrix is printed.

C++ 
// C++ code to print Binary Tree in 2D 
// using Level Order Traversal
#include <bits/stdc++.h>
using namespace std;

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

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

// Function to find the height of the binary tree
int findHeight(Node *root) {
    if (!root) {
        return -1;
    }

    int leftHeight = findHeight(root->left);
    int rightHeight = findHeight(root->right);

    return max(leftHeight, rightHeight) + 1;
}

// Helper function to perform level order traversal and
// populate the 2D matrix
void levelOrder(Node *root, int row, int col, int height,
                vector<vector<string>> &ans) {
    if (!root) {
        return;
    }

    // Place the current node's value in the matrix
    ans[row][col] = to_string(root->data);

    // Calculate offset for child positions
    int offset = pow(2, height - row - 1);

    // Traverse the left subtree
    if (root->left) {
        levelOrder(root->left, row + 1, col - offset,
                   height, ans);
    }

    // Traverse the right subtree
    if (root->right) {
        levelOrder(root->right, row + 1, col + offset,
                   height, ans);
    }
}

// Function to convert the binary tree to a 2D matrix
vector<vector<string>> treeToMatrix(Node *root) {
  
    // Find the height of the tree
    int height = findHeight(root);

    // Rows are height + 1; columns are 2^(height+1) - 1
    int rows = height + 1;
    int cols = pow(2, height + 1) - 1;

    // Initialize 2D matrix with empty strings
    vector<vector<string>> ans(rows, 
                               vector<string>(cols, ""));

    // Populate the matrix using level order traversal
    levelOrder(root, 0, (cols - 1) / 2, height, ans);

    return ans;
}

void print2DArray(vector<vector<string>> &arr) {
    for (auto &row : arr) {
        for (auto &cell : row) {
            if (cell.empty()) {
                cout << " ";
            } 
            else {
                cout << cell;
            }
        }
        cout << endl;
    }
}

int main() {
  
    // Hardcoded binary tree
    //        1
    //       / \ 
    //      2   3 
    //         / \  
    //        4   5 
    Node *root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->right->left = new Node(4);
    root->right->right = new Node(5);

    vector<vector<string>> result = treeToMatrix(root);

    print2DArray(result);

    return 0;
}
Java 
// Java code to print Binary Tree in 2D using 
// Level Order Traversal
import java.util.*;

class Node {
    int data;
    Node left, right;

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

class GfG {

    // Function to find the height of the binary tree
    static int findHeight(Node root) {
        if (root == null) {
            return -1;
        }

        int leftHeight = findHeight(root.left);
        int rightHeight = findHeight(root.right);

        return Math.max(leftHeight, rightHeight) + 1;
    }

    // Helper function to perform level order traversal and
    // populate the 2D matrix
    static void levelOrder(Node root, int row, int col, 
                           int height, 
                           List<List<String>> ans) {
        if (root == null) {
            return;
        }

        // Place the current node's value in the matrix
        ans.get(row).set(col, String.valueOf(root.data));

        // Calculate offset for child positions
        int offset = (int) Math.pow(2, height - row - 1);

        // Traverse the left subtree
        if (root.left != null) {
            levelOrder(root.left, row + 1, col - offset,
                       height, ans);
        }

        // Traverse the right subtree
        if (root.right != null) {
            levelOrder(root.right, row + 1, col + offset,
                       height, ans);
        }
    }

    // Function to convert the binary tree to a 2D matrix
    static List<List<String>> treeToMatrix(Node root) {

        // Find the height of the tree
        int height = findHeight(root);

        // Rows are height + 1; columns are 2^(height+1) - 1
        int rows = height + 1;
        int cols = (int) Math.pow(2, height + 1) - 1;

        // Initialize 2D matrix with empty strings
        List<List<String>> ans = new ArrayList<>();
        for (int i = 0; i < rows; i++) {
            List<String> row = new ArrayList<>(Collections
                                               .nCopies(cols, ""));
            ans.add(row);
        }

        // Populate the matrix using level order traversal
        levelOrder(root, 0, (cols - 1) / 2, height, ans);

        return ans;
    }

    static void print2DArray(List<List<String>> arr) {
        for (List<String> row : arr) {
            for (String cell : row) {
                if (cell.isEmpty()) {
                    System.out.print(" ");
                } else {
                    System.out.print(cell);
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {

        // Hardcoded binary tree
        //        1
        //       / \ 
        //      2   3 
        //         / \  
        //        4   5 
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);

        List<List<String>> result = treeToMatrix(root);

        print2DArray(result);
    }
}
Python 
# Python code to print Binary Tree in 2D using 
# Level Order Traversal
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Function to find the height of the binary tree
def find_height(root):
    if not root:
        return -1

    left_height = find_height(root.left)
    right_height = find_height(root.right)

    return max(left_height, right_height) + 1

# Helper function to perform level order traversal 
# and populate the 2D matrix
def level_order(root, row, col, height, ans):
    if not root:
        return

    # Place the current node's value in the matrix
    ans[row][col] = str(root.data)

    # Calculate offset for child positions
    offset = 2 ** (height - row - 1)

    # Traverse the left subtree
    if root.left:
        level_order(root.left, row + 1, col - offset, 
                    height, ans)

    # Traverse the right subtree
    if root.right:
        level_order(root.right, row + 1, col + offset, 
                    height, ans)

# Function to convert the binary tree to a 2D matrix
def tree_to_matrix(root):
  
    # Find the height of the tree
    height = find_height(root)

    # Rows are height + 1; columns are 2^(height+1) - 1
    rows = height + 1
    cols = 2 ** (height + 1) - 1

    # Initialize 2D matrix with empty strings
    ans = [["" for _ in range(cols)] for _ in range(rows)]

    # Populate the matrix using level order traversal
    level_order(root, 0, (cols - 1) // 2, height, ans)

    return ans

def print_2d_array(arr):
    for row in arr:
        for cell in row:
            if cell == "":
                print(" ", end="")
            else:
                print(cell, end="")
        print()

if __name__ == "__main__":
  
    # Hardcoded binary tree
    #        1
    #       / \ 
    #      2   3 
    #         / \  
    #        4   5 
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.right.left = Node(4)
    root.right.right = Node(5)

    result = tree_to_matrix(root)

    print_2d_array(result)
C# 
// C# code to print Binary Tree in 2D using 
// Level Order Traversal
using System;
using System.Collections.Generic;

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

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

class GfG {

    // Function to find the height of the binary tree
    static int FindHeight(Node root) {
        if (root == null) {
            return -1;
        }

        int leftHeight = FindHeight(root.left);
        int rightHeight = FindHeight(root.right);

        return Math.Max(leftHeight, rightHeight) + 1;
    }

    // Helper function to perform level order traversal 
    // and populate the 2D matrix
    static void LevelOrder(Node root, int row, int col,
                                  int height, 
                                  List<List<string>> ans) {
        if (root == null) {
            return;
        }

        // Place the current node's value in the matrix
        ans[row][col] = root.data.ToString();

        // Calculate offset for child positions
        int offset = (int)Math.Pow(2, height - row - 1);

        // Traverse the left subtree
        if (root.left != null) {
            LevelOrder(root.left, row + 1, col - offset, 
                     height, ans);
        }

        // Traverse the right subtree
        if (root.right != null) {
            LevelOrder(root.right, row + 1, col + offset, 
                     height, ans);
        }
    }

    // Function to convert the binary tree to a 2D matrix
    static List<List<string>> TreeToMatrix(Node root) {

        // Find the height of the tree
        int height = FindHeight(root);

        // Rows are height + 1; columns are 2^(height+1) - 1
        int rows = height + 1;
        int cols = (int)Math.Pow(2, height + 1) - 1;

        // Initialize 2D matrix with empty strings
        List<List<string>> ans = new List<List<string>>();
        for (int i = 0; i < rows; i++) {
            ans.Add(new List<string>(new string[cols]));
        }

        // Populate the matrix using level order traversal
        LevelOrder(root, 0, (cols - 1) / 2, height, ans);

        return ans;
    }

    static void Print2DArray(List<List<string>> arr) {
        foreach (var row in arr) {
            foreach (var cell in row) {
                if (string.IsNullOrEmpty(cell)) {
                    Console.Write(" ");
                } 
                else {
                    Console.Write(cell);
                }
            }
            Console.WriteLine();
        }
    }

    static void Main(string[] args) {

        // Hardcoded binary tree
        //        1
        //       / \ 
        //      2   3 
        //         / \  
        //        4   5 
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);

        List<List<string>> result = TreeToMatrix(root);

        Print2DArray(result);
    }
}
JavaScript 
// JavaScript code to print Binary Tree in 2D
// using Level Order Traversal

// Node class for the binary tree
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// Function to find the height of the binary tree
function findHeight(root) {
    if (!root) {
        return -1;
    }

    let leftHeight = findHeight(root.left);
    let rightHeight = findHeight(root.right);

    return Math.max(leftHeight, rightHeight) + 1;
}

// Helper function to perform level order traversal
// and populate the 2D matrix
function levelOrder(root, row, col, height, ans) {
    if (!root) {
        return;
    }

    // Place the current node's value in the matrix
    ans[row][col] = root.data.toString();

    // Calculate offset for child positions
    let offset = Math.pow(2, height - row - 1);

    // Traverse the left subtree
    if (root.left) {
        levelOrder(root.left, row + 1, col - offset, height,
                   ans);
    }

    // Traverse the right subtree
    if (root.right) {
        levelOrder(root.right, row + 1, col + offset,
                   height, ans);
    }
}

// Function to convert the binary tree to a 2D matrix
function treeToMatrix(root) {

    // Find the height of the tree
    let height = findHeight(root);

    // Rows are height + 1; columns are 2^(height+1) - 1
    let rows = height + 1;
    let cols = Math.pow(2, height + 1) - 1;

    // Initialize 2D matrix with empty strings
    let ans = Array.from({length : rows},
                         () => Array(cols).fill(""));

    // Populate the matrix using level order traversal
    levelOrder(root, 0, Math.floor((cols - 1) / 2), height,
               ans);

    return ans;
}

// Function to print the 2D array
function print2DArray(arr) {
    arr.forEach(row => {
        console.log(
            row.map(cell => cell === "" ? " " : cell)
                .join(""));
    });
}

// Hardcoded binary tree
//        1
//       / \ 
//      2   3
//         / \  
//        4   5
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.right.left = new Node(4);
root.right.right = new Node(5);

let result = treeToMatrix(root);

print2DArray(result);

Output
   1   
 2   3 
    4 5
Comment
Article Tags:
Tree
DSA

Explore