Creating a tree with Left-Child Right-Sibling Representation
Last Updated :
10 Mar, 2023
Left-Child Right-Sibling Representation is a different representation of an n-ary tree where instead of holding a reference to each and every child node, a node holds just two references, first a reference to its first child, and the other to its immediate next sibling. This new transformation not only removes the need for advanced knowledge of the number of children a node has but also limits the number of references to a maximum of two, thereby making it so much easier to code.
At each node, link children of same parent from left to right.
Parent should be linked with only first child.
Examples:
Left Child Right Sibling tree representation
10
|
2 -> 3 -> 4 -> 5
| |
6 7 -> 8 -> 9
Prerequisite: Left-Child Right-Sibling Representation of Tree
Below is the implementation.
C++
// C++ program to create a tree with left child
// right sibling representation.
#include<bits/stdc++.h>
using namespace std;
struct Node
{
int data;
struct Node *next;
struct Node *child;
};
// Creating new Node
Node* newNode(int data)
{
Node *newNode = new Node;
newNode->next = newNode->child = NULL;
newNode->data = data;
return newNode;
}
// Adds a sibling to a list with starting with n
Node *addSibling(Node *n, int data)
{
if (n == NULL)
return NULL;
while (n->next)
n = n->next;
return (n->next = newNode(data));
}
// Add child Node to a Node
Node *addChild(Node * n, int data)
{
if (n == NULL)
return NULL;
// Check if child list is not empty.
if (n->child)
return addSibling(n->child, data);
else
return (n->child = newNode(data));
}
// Traverses tree in depth first order
void traverseTree(Node * root)
{
if (root == NULL)
return;
while (root)
{
cout << " " << root->data;
if (root->child)
traverseTree(root->child);
root = root->next;
}
}
//Driver code
int main()
{
/* Let us create below tree
* 10
* / / \ \
* 2 3 4 5
* | / | \
* 6 7 8 9 */
// Left child right sibling
/* 10
* |
* 2 -> 3 -> 4 -> 5
* | |
* 6 7 -> 8 -> 9 */
Node *root = newNode(10);
Node *n1 = addChild(root, 2);
Node *n2 = addChild(root, 3);
Node *n3 = addChild(root, 4);
Node *n4 = addChild(n3, 6);
Node *n5 = addChild(root, 5);
Node *n6 = addChild(n5, 7);
Node *n7 = addChild(n5, 8);
Node *n8 = addChild(n5, 9);
traverseTree(root);
return 0;
}
// Java program to create a tree with left child
// right sibling representation.
class GFG {
static class NodeTemp
{
int data;
NodeTemp next, child;
public NodeTemp(int data)
{
this.data = data;
next = child = null;
}
}
// Adds a sibling to a list with starting with n
static public NodeTemp addSibling(NodeTemp node, int data)
{
if(node == null)
return null;
while(node.next != null)
node = node.next;
return(node.next = new NodeTemp(data));
}
// Add child Node to a Node
static public NodeTemp addChild(NodeTemp node,int data)
{
if(node == null)
return null;
// Check if child is not empty.
if(node.child != null)
return(addSibling(node.child,data));
else
return(node.child = new NodeTemp(data));
}
// Traverses tree in depth first order
static public void traverseTree(NodeTemp root)
{
if(root == null)
return;
while(root != null)
{
System.out.print(root.data + " ");
if(root.child != null)
traverseTree(root.child);
root = root.next;
}
}
// Driver code
public static void main(String args[])
{
/* Let us create below tree
* 10
* / / \ \
* 2 3 4 5
* | / | \
* 6 7 8 9 */
// Left child right sibling
/* 10
* |
* 2 -> 3 -> 4 -> 5
* | |
* 6 7 -> 8 -> 9 */
NodeTemp root = new NodeTemp(10);
NodeTemp n1 = addChild(root,2);
NodeTemp n2 = addChild(root,3);
NodeTemp n3 = addChild(root,4);
NodeTemp n4 = addChild(n3,6);
NodeTemp n5 = addChild(root,5);
NodeTemp n6 = addChild(n5,7);
NodeTemp n7 = addChild(n5,8);
NodeTemp n8 = addChild(n5,9);
traverseTree(root);
}
}
// This code is contributed by M.V.S.Surya Teja.
# Python3 program to create a tree with
# left child right sibling representation.
# Creating new Node
class newNode:
def __init__(self, data):
self.Next = self.child = None
self.data = data
# Adds a sibling to a list with
# starting with n
def addSibling(n, data):
if (n == None):
return None
while (n.Next):
n = n.Next
n.Next = newNode(data)
return n.Next
# Add child Node to a Node
def addChild(n, data):
if (n == None):
return None
# Check if child list is not empty.
if (n.child):
return addSibling(n.child, data)
else:
n.child = newNode(data)
return n.child
# Traverses tree in depth first order
def traverseTree(root):
if (root == None):
return
while (root):
print(root.data, end = " ")
if (root.child):
traverseTree(root.child)
root = root.Next
# Driver code
if __name__ == '__main__':
# Let us create below tree
# 10
# / / \ \
# 2 3 4 5
# | / | \
# 6 7 8 9
# Left child right sibling
# 10
# |
# 2 -> 3 -> 4 -> 5
# | |
# 6 7 -> 8 -> 9
root = newNode(10)
n1 = addChild(root, 2)
n2 = addChild(root, 3)
n3 = addChild(root, 4)
n4 = addChild(n3, 6)
n5 = addChild(root, 5)
n6 = addChild(n5, 7)
n7 = addChild(n5, 8)
n8 = addChild(n5, 9)
traverseTree(root)
# This code is contributed by pranchalK
// C# program to create a tree with left
// child right sibling representation.
using System;
class GFG
{
public class NodeTemp
{
public int data;
public NodeTemp next, child;
public NodeTemp(int data)
{
this.data = data;
next = child = null;
}
}
// Adds a sibling to a list with
// starting with n
public static NodeTemp addSibling(NodeTemp node,
int data)
{
if (node == null)
{
return null;
}
while (node.next != null)
{
node = node.next;
}
return (node.next = new NodeTemp(data));
}
// Add child Node to a Node
public static NodeTemp addChild(NodeTemp node,
int data)
{
if (node == null)
{
return null;
}
// Check if child is not empty.
if (node.child != null)
{
return (addSibling(node.child,data));
}
else
{
return (node.child = new NodeTemp(data));
}
}
// Traverses tree in depth first order
public static void traverseTree(NodeTemp root)
{
if (root == null)
{
return;
}
while (root != null)
{
Console.Write(root.data + " ");
if (root.child != null)
{
traverseTree(root.child);
}
root = root.next;
}
}
// Driver code
public static void Main(string[] args)
{
/* Let us create below tree
* 10
* / / \ \
* 2 3 4 5
* | / | \
* 6 7 8 9 */
// Left child right sibling
/* 10
* |
* 2 -> 3 -> 4 -> 5
* | |
* 6 7 -> 8 -> 9 */
NodeTemp root = new NodeTemp(10);
NodeTemp n1 = addChild(root, 2);
NodeTemp n2 = addChild(root, 3);
NodeTemp n3 = addChild(root, 4);
NodeTemp n4 = addChild(n3, 6);
NodeTemp n5 = addChild(root, 5);
NodeTemp n6 = addChild(n5, 7);
NodeTemp n7 = addChild(n5, 8);
NodeTemp n8 = addChild(n5, 9);
traverseTree(root);
}
}
// This code is contributed by Shrikant13
<script>
// Javascript program to create a tree with left child
// right sibling representation.
class NodeTemp
{
constructor(data)
{
this.data=data;
this.next = this.child = null;
}
}
// Adds a sibling to a list with starting with n
function addSibling(node,data)
{
if(node == null)
return null;
while(node.next != null)
node = node.next;
return(node.next = new NodeTemp(data));
}
// Add child Node to a Node
function addChild(node,data)
{
if(node == null)
return null;
// Check if child is not empty.
if(node.child != null)
return(addSibling(node.child,data));
else
return(node.child = new NodeTemp(data));
}
// Traverses tree in depth first order
function traverseTree(root)
{
if(root == null)
return;
while(root != null)
{
document.write(root.data + " ");
if(root.child != null)
traverseTree(root.child);
root = root.next;
}
}
// Driver code
/* Let us create below tree
* 10
* / / \ \
* 2 3 4 5
* | / | \
* 6 7 8 9 */
// Left child right sibling
/* 10
* |
* 2 -> 3 -> 4 -> 5
* | |
* 6 7 -> 8 -> 9 */
let root = new NodeTemp(10);
let n1 = addChild(root,2);
let n2 = addChild(root,3);
let n3 = addChild(root,4);
let n4 = addChild(n3,6);
let n5 = addChild(root,5);
let n6 = addChild(n5,7);
let n7 = addChild(n5,8);
let n8 = addChild(n5,9);
traverseTree(root);
// This code is contributed by patel2127
</script>
Output 10 2 3 4 6 5 7 8 9
Time Complexity: O(n2), where n is the number of nodes in the tree.
Auxiliary Space: O(n)
Level Order Traversal: The above code talks about depth-first traversal. We can also do level order traversal of such representation.
Implementation:
C++
// C++ program to create a tree with left child
// right sibling representation.
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
struct Node* child;
};
// Creating new Node
Node* newNode(int data)
{
Node* newNode = new Node;
newNode->next = newNode->child = NULL;
newNode->data = data;
return newNode;
}
// Adds a sibling to a list with starting with n
Node* addSibling(Node* n, int data)
{
if (n == NULL)
return NULL;
while (n->next)
n = n->next;
return (n->next = newNode(data));
}
// Add child Node to a Node
Node* addChild(Node* n, int data)
{
if (n == NULL)
return NULL;
// Check if child list is not empty.
if (n->child)
return addSibling(n->child, data);
else
return (n->child = newNode(data));
}
// Traverses tree in level order
void traverseTree(Node* root)
{
// Corner cases
if (root == NULL)
return;
cout << root->data << " ";
if (root->child == NULL)
return;
// Create a queue and enqueue root
queue<Node*> q;
Node* curr = root->child;
q.push(curr);
while (!q.empty()) {
// Take out an item from the queue
curr = q.front();
q.pop();
// Print next level of taken out item and enqueue
// next level's children
while (curr != NULL) {
cout << curr->data << " ";
if (curr->child != NULL) {
q.push(curr->child);
}
curr = curr->next;
}
}
}
// Driver code
int main()
{
Node* root = newNode(10);
Node* n1 = addChild(root, 2);
Node* n2 = addChild(root, 3);
Node* n3 = addChild(root, 4);
Node* n4 = addChild(n3, 6);
Node* n5 = addChild(root, 5);
Node* n6 = addChild(n5, 7);
Node* n7 = addChild(n5, 8);
Node* n8 = addChild(n5, 9);
traverseTree(root);
return 0;
}
// Java program to create a tree with left child
// right sibling representation.
import java.util.*;
class GFG
{
static class Node
{
int data;
Node next;
Node child;
};
// Creating new Node
static Node newNode(int data)
{
Node newNode = new Node();
newNode.next = newNode.child = null;
newNode.data = data;
return newNode;
}
// Adds a sibling to a list with starting with n
static Node addSibling(Node n, int data)
{
if (n == null)
return null;
while (n.next != null)
n = n.next;
return (n.next = newNode(data));
}
// Add child Node to a Node
static Node addChild(Node n, int data)
{
if (n == null)
return null;
// Check if child list is not empty.
if (n.child != null)
return addSibling(n.child, data);
else
return (n.child = newNode(data));
}
// Traverses tree in level order
static void traverseTree(Node root)
{
// Corner cases
if (root == null)
return;
System.out.print(root.data+ " ");
if (root.child == null)
return;
// Create a queue and enqueue root
Queue<Node> q = new LinkedList<>();
Node curr = root.child;
q.add(curr);
while (!q.isEmpty())
{
// Take out an item from the queue
curr = q.peek();
q.remove();
// Print next level of taken out item and enqueue
// next level's children
while (curr != null)
{
System.out.print(curr.data + " ");
if (curr.child != null)
{
q.add(curr.child);
}
curr = curr.next;
}
}
}
// Driver code
public static void main(String[] args)
{
Node root = newNode(10);
Node n1 = addChild(root, 2);
Node n2 = addChild(root, 3);
Node n3 = addChild(root, 4);
Node n4 = addChild(n3, 6);
Node n5 = addChild(root, 5);
Node n6 = addChild(n5, 7);
Node n7 = addChild(n5, 8);
Node n8 = addChild(n5, 9);
traverseTree(root);
}
}
// This code is contributed by aashish1995
# Python3 program to create a tree with
# left child right sibling representation
from collections import deque
class Node:
def __init__(self, x):
self.data = x
self.next = None
self.child = None
# Adds a sibling to a list with
# starting with n
def addSibling(n, data):
if (n == None):
return None
while (n.next):
n = n.next
n.next = Node(data)
return n
# Add child Node to a Node
def addChild(n, data):
if (n == None):
return None
# Check if child list is not empty
if (n.child):
return addSibling(n.child, data)
else:
n.child = Node(data)
return n
# Traverses tree in level order
def traverseTree(root):
# Corner cases
if (root == None):
return
print(root.data, end = " ")
if (root.child == None):
return
# Create a queue and enqueue root
q = deque()
curr = root.child
q.append(curr)
while (len(q) > 0):
# Take out an item from the queue
curr = q.popleft()
#q.pop()
# Print next level of taken out
# item and enqueue next level's children
while (curr != None):
print(curr.data, end = " ")
if (curr.child != None):
q.append(curr.child)
curr = curr.next
# Driver code
if __name__ == '__main__':
root = Node(10)
n1 = addChild(root, 2)
n2 = addChild(root, 3)
n3 = addChild(root, 4)
n4 = addChild(n3, 6)
n5 = addChild(root, 5)
n6 = addChild(n5, 7)
n7 = addChild(n5, 8)
n8 = addChild(n5, 9)
traverseTree(root)
# This code is contributed by mohit kumar 29
// C# program to create a tree with left child
// right sibling representation.
using System;
using System.Collections.Generic;
class GFG
{
public
class Node
{
public
int data;
public
Node next;
public
Node child;
};
// Creating new Node
static Node newNode(int data)
{
Node newNode = new Node();
newNode.next = newNode.child = null;
newNode.data = data;
return newNode;
}
// Adds a sibling to a list with starting with n
static Node addSibling(Node n, int data)
{
if (n == null)
return null;
while (n.next != null)
n = n.next;
return (n.next = newNode(data));
}
// Add child Node to a Node
static Node addChild(Node n, int data)
{
if (n == null)
return null;
// Check if child list is not empty.
if (n.child != null)
return addSibling(n.child, data);
else
return (n.child = newNode(data));
}
// Traverses tree in level order
static void traverseTree(Node root)
{
// Corner cases
if (root == null)
return;
Console.Write(root.data + " ");
if (root.child == null)
return;
// Create a queue and enqueue root
Queue<Node> q = new Queue<Node>();
Node curr = root.child;
q.Enqueue(curr);
while (q.Count != 0)
{
// Take out an item from the queue
curr = q.Peek();
q.Dequeue();
// Print next level of taken out item and enqueue
// next level's children
while (curr != null)
{
Console.Write(curr.data + " ");
if (curr.child != null)
{
q.Enqueue(curr.child);
}
curr = curr.next;
}
}
}
// Driver code
public static void Main(String[] args)
{
Node root = newNode(10);
Node n1 = addChild(root, 2);
Node n2 = addChild(root, 3);
Node n3 = addChild(root, 4);
Node n4 = addChild(n3, 6);
Node n5 = addChild(root, 5);
Node n6 = addChild(n5, 7);
Node n7 = addChild(n5, 8);
Node n8 = addChild(n5, 9);
traverseTree(root);
}
}
// This code is contributed by Rajput-Ji
<script>
// JavaScript program to create a
// tree with left child
// right sibling representation.
class Node
{
// Creating new Node
constructor(data)
{
this.data=data;
this.next = this.child = null;
}
}
// Adds a sibling to a list with starting with n
function addSibling(n,data)
{
if (n == null)
return null;
while (n.next != null)
n = n.next;
return (n.next = new Node(data));
}
// Add child Node to a Node
function addChild(n,data)
{
if (n == null)
return null;
// Check if child list is not empty.
if (n.child != null)
return addSibling(n.child, data);
else
return (n.child = new Node(data));
}
// Traverses tree in level order
function traverseTree(root)
{
// Corner cases
if (root == null)
return;
document.write(root.data+ " ");
if (root.child == null)
return;
// Create a queue and enqueue root
let q = [];
let curr = root.child;
q.push(curr);
while (q.length!=0)
{
// Take out an item from the queue
curr = q[0];
q.shift();
// Print next level of taken out item and enqueue
// next level's children
while (curr != null)
{
document.write(curr.data + " ");
if (curr.child != null)
{
q.push(curr.child);
}
curr = curr.next;
}
}
}
// Driver code
let root = new Node(10);
let n1 = addChild(root, 2);
let n2 = addChild(root, 3);
let n3 = addChild(root, 4);
let n4 = addChild(n3, 6);
let n5 = addChild(root, 5);
let n6 = addChild(n5, 7);
let n7 = addChild(n5, 8);
let n8 = addChild(n5, 9);
traverseTree(root);
// This code is contributed by unknown2108
</script>
Time Complexity: O(n), where n is the number of nodes in the tree.
Auxiliary Space: O(n)
If you like GeeksforGeeks(We know you do!) and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to [email protected].
Similar Reads
Left-Child Right-Sibling Representation of Tree An n-ary tree in computer science is a collection of nodes normally represented hierarchically in the following fashion. The tree starts at the root node.Each node of the tree holds a list of references to its child nodes.The number of children a node has is less than or equal to n. A typical repres
15+ min read
Find right sibling of a binary tree with parent pointers Given a binary tree with parent pointers, find the right sibling of a given node(pointer to the node will be given), if it doesn’t exist return null. Do it in O(1) space and O(n) time? Examples: 1 / \ 2 3 / \ \ 4 6 5 / \ \ 7 9 8 / \ 10 12 Input : Given above tree with parent pointer and node 10 Outp
10 min read
Construct a Binary Tree from String with bracket representation | Set 2 Given a string s consisting of parentheses {'(' and ')'} and integers, the task is to construct a Binary Tree from it and print its Preorder traversal. Examples: Input: S = "1(2)(3)"Output: 1 2 3Explanation: The corresponding binary tree is as follows: 1 / \ 2 3 Input: "4(2(3)(1))(6(5))"Output: 4 2
9 min read
Construct Binary Tree from String with bracket representation Given a string consisting of parenthesis and integers, representing a binary tree. The task is to construct a binary tree from this string. The string contains an integer followed by zero, one or two pairs of parenthesis. The integer represents the root's value and a pair of parenthesis contains a c
15+ min read
Find the sum of all left leaf nodes which also has its right sibling Given a Binary Tree rooted at root, the task is to find the sum of all leaf nodes which are left child of their parents and which also have their right sibling i.e, it's a parent has also a right child. Examples: Input: 16 / \ 20 15 / / \ 100 21 25 / / \ / \27 14 9 7 6 / \ \ 17 12 2Output: 24.Explan
8 min read
Printing Hierarchical Structure with Numbering and Indentation Consider the below diagram , which shows a sort of hierarchical organization for a company . Electronics R'Us has four departments namely R&D , Sales, Purchasing , Manufacturing . Sales is subsequently divide into Domestic and International categories and so on . We need to generate an output wh
6 min read
Basic Operations on Binary Tree with Implementations The tree is a hierarchical Data Structure. A binary tree is a tree that has at most two children. The node which is on the left of the Binary Tree is called “Left-Child†and the node which is on the right is called “Right-Childâ€. Also, the smaller tree or the subtree in the left of the root node is
11 min read
Right sibling of each node in a tree given as array of edges Given a tree, with N nodes and E edges (every edge is denoted by two integers, X, Y stating that X is the parent of Y), the task is to print all the nodes with their right siblings in separate lines. If there is no right sibling for a particular node then print -1 instead. Examples: In the image sho
7 min read
Find largest subtree having identical left and right subtrees Given a binary tree, find the largest subtree having identical left and right subtree. Expected complexity is O(n).For example, Input: 50 / \ 10 60 / \ / \ 5 20 70 70 / \ / \ 65 80 65 80Output: Largest subtree is rooted at node 60A simple solution is to consider every node, recursively check if left
12 min read
Linked complete binary tree & its creation A complete binary tree is a binary tree where each level 'l' except the last has 2^l nodes and the nodes at the last level are all left-aligned. Complete binary trees are mainly used in heap-based data structures. The nodes in the complete binary tree are inserted from left to right in one level at
14 min read