GeeksforGeeks App
Open App
Browser
Continue

# Construct Binary Tree from Ancestor Matrix | Top Down Approach

Given an ancestor matrix mat[n][n] where the ancestor matrix is defined as below.

```mat[i][j] = 1 if i is ancestor of j
mat[i][j] = 0, otherwise ```

Construct a Binary Tree from the given ancestor matrix where all its values of nodes are from 0 to n-1.

• It may be assumed that the input provided by the program is valid and the tree can be constructed out of it.
• Many Binary trees can be constructed from one input. The program will construct any one of them.

Examples:

```Input:
{ {0, 1, 1},
{0, 0, 0},
{0, 0, 0}
};
Output:
0
/   \
1     2

Input:
{ {0, 0, 0, 1, 1, 0},
{0, 0, 0, 0, 0, 1},
{1, 1, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0}
};
Output:
2
/   \
0      1
/   \    /
3     4  5```

Please refer to this article for Bottom-Up approach: Construct tree from ancestor matrix

Approach:  First, we will find the root of the tree. The root is the one whose column has all zeros. Once we find the root, we can then construct a tree from the root using DFS recursive approach.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of``// the above approach` `#include ``using` `namespace` `std;` `// Node structure for``// Binary Tree``struct` `Node {``    ``int` `data;``    ``Node *left, *right;``    ``Node(``int` `_val)``    ``{``        ``data = _val;``        ``left = right = NULL;``    ``}``};` `// Function to return``// root index of a``// binary tree``int` `getRootIndex(vector >& arr)``{``    ``int` `root_index = -1;` `    ``for` `(``int` `j = 0; j < arr[0].size(); j++) {``        ``int` `count = 0;``        ``for` `(``int` `i = 0; i < arr.size(); i++)``            ``if` `(arr[i][j] == 0) {``                ``count++;``            ``}` `        ``if` `(count == arr.size()) {``            ``root_index = j;``            ``break``;``        ``}``    ``}``    ``return` `root_index;``}` `// Function to print``// in-order traversal of``// a tree``void` `printInorder(Node* node)``{``    ``if` `(node == NULL) {``        ``return``;``    ``}``    ``printInorder(node->left);``    ``cout << node->data << ``" "``;``    ``printInorder(node->right);``}` `// Function to generate binary``// tree from parent matrix``Node* createTreeRec(vector >& arr, ``int` `index)``{` `    ``Node* node = ``new` `Node(index);` `    ``// If left is 1 then create``    ``// left child. (for 1st one in row)``    ``// If left is 2 then create``    ``// right child.(for 1st one in row)``    ``int` `left = 1;` `    ``for` `(``int` `j = 0; j < arr[index].size(); j++) {``        ``if` `(arr[index][j] == 1) {``            ``// recur for left sub-tree``            ``if` `(left == 1) {``                ``node->left = createTreeRec(arr, j);``            ``}``            ``// recur for right sub-tree``            ``else` `if` `(left == 2) {``                ``node->right = createTreeRec(arr, j);``            ``}``            ``left++;``        ``}``    ``}` `    ``return` `node;``}` `// Driver code``int` `main()``{` `    ``// Assuming leftmost 1 in a``    ``// row is left child, if exists``    ``// and rightmost 1 in a row``    ``// is right child, if exists``    ``vector > arr = {``        ``{ 0, 0, 0, 1, 1, 0 },``        ``{ 0, 0, 0, 0, 0, 1 },``        ``{ 1, 1, 0, 0, 0, 0 },``        ``{ 0, 0, 0, 0, 0, 0 },``        ``{ 0, 0, 0, 0, 0, 0 },``        ``{ 0, 0, 0, 0, 0, 0 },``    ``};` `    ``int` `root_index = getRootIndex(arr);``    ``Node* root = createTreeRec(arr, root_index);` `    ``// Printing inorder traversal``    ``// of tree to check the output``    ``printInorder(root);` `    ``return` `0;``}`

## Java

 `// Java implementation of``// the above approach``import` `java.io.*;` `public` `class` `GFG {` `    ``// Node structure for``    ``// Binary Tree``    ``static` `class` `Node {``        ``int` `data;``        ``Node left, right;``        ``Node(``int` `_val)``        ``{``            ``data = _val;``            ``left = right = ``null``;``        ``}``    ``};` `    ``// Function to return``    ``// root index of a``    ``// binary tree``    ``static` `int` `getRootIndex(``int``[][] arr)``    ``{``        ``int` `root_index = -``1``;` `        ``for` `(``int` `j = ``0``; j < arr[``0``].length; j++) {``            ``int` `count = ``0``;``            ``for` `(``int` `i = ``0``; i < arr.length; i++)``                ``if` `(arr[i][j] == ``0``) {``                    ``count++;``                ``}` `            ``if` `(count == arr.length) {``                ``root_index = j;``                ``break``;``            ``}``        ``}``        ``return` `root_index;``    ``}` `    ``// Function to print``    ``// in-order traversal of``    ``// a tree``    ``static` `void` `printInorder(Node node)``    ``{``        ``if` `(node == ``null``) {``            ``return``;``        ``}``        ``printInorder(node.left);``        ``System.out.print(node.data + ``" "``);``        ``printInorder(node.right);``    ``}` `    ``// Function to generate binary``    ``// tree from parent matrix``    ``static` `Node createTreeRec(``int``[][] arr, ``int` `index)``    ``{` `        ``Node node = ``new` `Node(index);` `        ``// If left is 1 then create``        ``// left child. (for 1st one in row)``        ``// If left is 2 then create``        ``// right child.(for 1st one in row)``        ``int` `left = ``1``;` `        ``for` `(``int` `j = ``0``; j < arr[index].length; j++) {``            ``if` `(arr[index][j] == ``1``) {``                ``// recur for left sub-tree``                ``if` `(left == ``1``) {``                    ``node.left = createTreeRec(arr, j);``                ``}` `                ``// recur for right sub-tree``                ``else` `if` `(left == ``2``) {``                    ``node.right = createTreeRec(arr, j);``                ``}``                ``left++;``            ``}``        ``}` `        ``return` `node;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Assuming leftmost 1 in a``        ``// row is left child, if exists``        ``// and rightmost 1 in a row``        ``// is right child, if exists``        ``int``[][] arr = {``            ``{ ``0``, ``0``, ``0``, ``1``, ``1``, ``0` `}, { ``0``, ``0``, ``0``, ``0``, ``0``, ``1` `},``            ``{ ``1``, ``1``, ``0``, ``0``, ``0``, ``0` `}, { ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `},``            ``{ ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `}, { ``0``, ``0``, ``0``, ``0``, ``0``, ``0` `},``        ``};` `        ``int` `root_index = getRootIndex(arr);``        ``Node root = createTreeRec(arr, root_index);` `        ``// Printing inorder traversal``        ``// of tree to check the output``        ``printInorder(root);``    ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of``# the above approach` `# Node structure for``# Binary Tree``class` `Node:``  ` `    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# Function to return``# root index of a``# binary tree``def` `getRootIndex(arr : ``list``) ``-``> ``int``:``    ``root_index ``=` `-``1` `    ``for` `j ``in` `range``(``len``(arr)):``        ``count ``=` `0``        ``for` `i ``in` `range``(``len``(arr)):``            ``if` `(arr[i][j] ``=``=` `0``):``                ``count ``+``=` `1` `        ``if` `(count ``=``=` `len``(arr)):``            ``root_index ``=` `j``            ``break` `    ``return` `root_index` `# Function to print``# in-order traversal of``# a tree``def` `printInorder(node : Node) ``-``> ``None``:` `    ``if` `(node ``is` `None``):``        ``return` `    ``printInorder(node.left)``    ``print``(node.data, end ``=` `" "``)``    ``printInorder(node.right)` `# Function to generate binary``# tree from parent matrix``def` `createTreeRec(arr : ``list``,``                  ``index : ``int``) ``-``> Node:` `    ``node ``=` `Node(index)` `    ``# If left is 1 then create``    ``# left child. (for 1st one in row)``    ``# If left is 2 then create``    ``# right child.(for 1st one in row)``    ``left ``=` `1` `    ``for` `j ``in` `range``(``len``(arr[index])):``        ``if` `(arr[index][j] ``=``=` `1``):``            ``# recur for left sub-tree``            ``if` `(left ``=``=` `1``):``                ``node.left ``=` `createTreeRec(arr, j)` `            ``# recur for right sub-tree``            ``elif` `(left ``=``=` `2``):``                ``node.right ``=` `createTreeRec(arr, j)` `            ``left ``+``=` `1` `    ``return` `node` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Assuming leftmost 1 in a``    ``# row is left child, if exists``    ``# and rightmost 1 in a row``    ``# is right child, if exists``    ``arr ``=` `[[``0``, ``0``, ``0``, ``1``, ``1``, ``0``],``           ``[``0``, ``0``, ``0``, ``0``, ``0``, ``1``],``           ``[``1``, ``1``, ``0``, ``0``, ``0``, ``0``],``           ``[``0``, ``0``, ``0``, ``0``, ``0``, ``0``],``           ``[``0``, ``0``, ``0``, ``0``, ``0``, ``0``],``           ``[``0``, ``0``, ``0``, ``0``, ``0``, ``0``]]` `    ``root_index ``=` `getRootIndex(arr)``    ``root ``=` `createTreeRec(arr, root_index)` `    ``# Printing inorder traversal``    ``# of tree to check the output``    ``printInorder(root)` `# This code is contributed by sanjeev2552`

## C#

 `// C# implementation of``// the above approach``using` `System;` `class` `GFG``{` `// Node structure for``// Binary Tree``class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;``    ``public` `Node(``int` `_val)``    ``{``        ``data = _val;``        ``left = right = ``null``;``    ``}``};` `// Function to return``// root index of a``// binary tree``static` `int` `getRootIndex(``int` `[,]arr)``{``    ``int` `root_index = -1;` `    ``for` `(``int` `j = 0; j < arr.GetLength(0); j++)``    ``{``        ``int` `count = 0;``        ``for` `(``int` `i = 0; i < arr.GetLength(1); i++)``            ``if` `(arr[i, j] == 0)``            ``{``                ``count++;``            ``}` `        ``if` `(count == arr.GetLength(0))``        ``{``            ``root_index = j;``            ``break``;``        ``}``    ``}``    ``return` `root_index;``}` `// Function to print``// in-order traversal of``// a tree``static` `void` `printInorder(Node node)``{``    ``if` `(node == ``null``)``    ``{``        ``return``;``    ``}``    ``printInorder(node.left);``    ``Console.Write(node.data + ``" "``);``    ``printInorder(node.right);``}` `// Function to generate binary``// tree from parent matrix``static` `Node createTreeRec(``int` `[,]arr, ``int` `index)``{` `    ``Node node = ``new` `Node(index);` `    ``// If left is 1 then create``    ``// left child. (for 1st one in row)``    ``// If left is 2 then create``    ``// right child.(for 1st one in row)``    ``int` `left = 1;` `    ``for` `(``int` `j = 0; j < arr.GetLength(1); j++)``    ``{``        ``if` `(arr[index, j] == 1)``        ``{``            ``// recur for left sub-tree``            ``if` `(left == 1)``            ``{``                ``node.left = createTreeRec(arr, j);``            ``}``            ` `            ``// recur for right sub-tree``            ``else` `if` `(left == 2)``            ``{``                ``node.right = createTreeRec(arr, j);``            ``}``            ``left++;``        ``}``    ``}` `    ``return` `node;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{` `    ``// Assuming leftmost 1 in a``    ``// row is left child, if exists``    ``// and rightmost 1 in a row``    ``// is right child, if exists``    ``int``[,] arr = {``        ``{ 0, 0, 0, 1, 1, 0 },``        ``{ 0, 0, 0, 0, 0, 1 },``        ``{ 1, 1, 0, 0, 0, 0 },``        ``{ 0, 0, 0, 0, 0, 0 },``        ``{ 0, 0, 0, 0, 0, 0 },``        ``{ 0, 0, 0, 0, 0, 0 },``    ``};` `    ``int` `root_index = getRootIndex(arr);``    ``Node root = createTreeRec(arr, root_index);` `    ``// Printing inorder traversal``    ``// of tree to check the output``    ``printInorder(root);` `}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`3 0 4 2 5 1`

Time Complexity: O(N2), where N is the size of the binary tree.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up