Creating a tree with Left-Child Right-Sibling Representation - GeeksforGeeks

23 Feb, 2022
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++
Java
Python3
C#
Javascript
// 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 NodeNode* 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 nNode *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 NodeNode *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 ordervoid 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 Nodeclass newNode:    def __init__(self, data):        self.Next = self.child = None        self.data = data # Adds a sibling to a list with# starting with ndef 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 Nodedef 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 orderdef traverseTree(root):    if (root == None):        return     while (root):        print(root.data, end = " ")        if (root.child):            traverseTree(root.child)        root = root.Next # Driver codeif __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 npublic 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 Nodepublic 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 orderpublic 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 codepublic 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>
10 2 3 4 6 5 7 8 9
 
Level Order Traversal: The above code talks about depth-first traversal. We can also do level order traversal of such representation.
C++
Java
Python3
C#
Javascript
// 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 NodeNode* 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 nNode* 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 NodeNode* 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 ordervoid 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 codeint 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 representationfrom 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 ndef 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 Nodedef 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 orderdef 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 codeif __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 nfunction 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 Nodefunction 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 orderfunction 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 codelet 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>
10 2 3 4 5 6 7 8 9
 
This article is contributed by SAKSHI TIWARI. 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 review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
MvssTeja
shrikanth13
PranchalKatiyar
Sheenam Yadav
mohit kumar 29
aashish1995
Rajput-Ji
patel2127
unknown2108
surinderdawra388
n-ary-tree
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Decision Tree
Binary Tree | Set 2 (Properties)
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Introduction to Tree Data Structure
Lowest Common Ancestor in a Binary Tree | Set 1
Expression Tree
Binary Tree (Array implementation)
Deletion in a Binary Tree
BFS vs DFS for Binary Tree
Relationship between number of nodes and height of binary tree