// C++ Program to convert a Binary Tree // to a Circular Doubly Linked List #include    using namespace std; // To represents a node of a Binary Tree struct Node {  struct Node *left *right;  int data; }; // A function that appends rightList at the end // of leftList. Node* concatenate(Node* leftList Node* rightList) {  // If either of the list is empty  // then return the other list  if (leftList == NULL)  return rightList;  if (rightList == NULL)  return leftList;  // Store the last Node of left List  Node* leftLast = leftList->left;  // Store the last Node of right List  Node* rightLast = rightList->left;  // Connect the last node of Left List  // with the first Node of the right List  leftLast->right = rightList;  rightList->left = leftLast;  // Left of first node points to  // the last node in the list  leftList->left = rightLast;  // Right of last node refers to the first  // node of the List  rightLast->right = leftList;  return leftList; } // Function converts a tree to a circular Linked List // and then returns the head of the Linked List Node* bTreeToCList(Node* root) {  if (root == NULL)  return NULL;  // Recursively convert left and right subtrees  Node* left = bTreeToCList(root->left);  Node* right = bTreeToCList(root->right);  // Make a circular linked list of single node  // (or root). To do so make the right and  // left pointers of this node point to itself  root->left = root->right = root;  // Step 1 (concatenate the left list with the list  // with single node i.e. current node)  // Step 2 (concatenate the returned list with the  // right List)  return concatenate(concatenate(left root) right); } // Display Circular Link List void displayCList(Node* head) {  cout << 'Circular Linked List is :n';  Node* itr = head;  do {  cout << itr->data << ' ';  itr = itr->right;  } while (head != itr);  cout << 'n'; } // Create a new Node and return its address Node* newNode(int data) {  Node* temp = new Node();  temp->data = data;  temp->left = temp->right = NULL;  return temp; } // Driver Program to test above function int main() {  Node* root = newNode(10);  root->left = newNode(12);  root->right = newNode(15);  root->left->left = newNode(25);  root->left->right = newNode(30);  root->right->left = newNode(36);  Node* head = bTreeToCList(root);  displayCList(head);  return 0; } // This code is contributed by Aditya Kumar (adityakumar129) 

// C Program to convert a Binary Tree // to a Circular Doubly Linked List #include  #include  // To represents a node of a Binary Tree typedef struct Node {  struct Node *left *right;  int data; } Node; // A function that appends rightList at the end // of leftList. Node* concatenate(Node* leftList Node* rightList) {  // If either of the list is empty  // then return the other list  if (leftList == NULL)  return rightList;  if (rightList == NULL)  return leftList;  // Store the last Node of left List  Node* leftLast = leftList->left;  // Store the last Node of right List  Node* rightLast = rightList->left;  // Connect the last node of Left List  // with the first Node of the right List  leftLast->right = rightList;  rightList->left = leftLast;  // Left of first node points to  // the last node in the list  leftList->left = rightLast;  // Right of last node refers to the first  // node of the List  rightLast->right = leftList;  return leftList; } // Function converts a tree to a circular Linked List // and then returns the head of the Linked List Node* bTreeToCList(Node* root) {  if (root == NULL)  return NULL;  // Recursively convert left and right subtrees  Node* left = bTreeToCList(root->left);  Node* right = bTreeToCList(root->right);  // Make a circular linked list of single node  // (or root). To do so make the right and  // left pointers of this node point to itself  root->left = root->right = root;  // Step 1 (concatenate the left list with the list  // with single node i.e. current node)  // Step 2 (concatenate the returned list with the  // right List)  return concatenate(concatenate(left root) right); } // Display Circular Link List void displayCList(Node* head) {  printf('Circular Linked List is :n');  Node* itr = head;  do {  printf('%d ' itr->data);  itr = itr->right;  } while (head != itr);  printf('n'); } // Create a new Node and return its address Node* newNode(int data) {  Node* temp = (Node*)malloc(sizeof(Node));  temp->data = data;  temp->left = temp->right = NULL;  return temp; } // Driver Program to test above function int main() {  Node* root = newNode(10);  root->left = newNode(12);  root->right = newNode(15);  root->left->left = newNode(25);  root->left->right = newNode(30);  root->right->left = newNode(36);  Node* head = bTreeToCList(root);  displayCList(head);  return 0; } // This code is contributed by Aditya Kumar (adityakumar129) 

// Java Program to convert a Binary Tree to a // Circular Doubly Linked List // Node class represents a Node of a Tree class Node {  int val;  Node left right;  public Node(int val)  {  this.val = val;  left = right = null;  } } // A class to represent a tree class Tree {  Node root;  public Tree() { root = null; }  // concatenate both the lists and returns the head  // of the List  public Node concatenate(Node leftList Node rightList)  {  // If either of the list is empty then  // return the other list  if (leftList == null)  return rightList;  if (rightList == null)  return leftList;  // Store the last Node of left List  Node leftLast = leftList.left;  // Store the last Node of right List  Node rightLast = rightList.left;  // Connect the last node of Left List  // with the first Node of the right List  leftLast.right = rightList;  rightList.left = leftLast;  // left of first node refers to  // the last node in the list  leftList.left = rightLast;  // Right of last node refers to the first  // node of the List  rightLast.right = leftList;  // Return the Head of the List  return leftList;  }  // Method converts a tree to a circular  // Link List and then returns the head  // of the Link List  public Node bTreeToCList(Node root)  {  if (root == null)  return null;  // Recursively convert left and right subtrees  Node left = bTreeToCList(root.left);  Node right = bTreeToCList(root.right);  // Make a circular linked list of single node  // (or root). To do so make the right and  // left pointers of this node point to itself  root.left = root.right = root;  // Step 1 (concatenate the left list with the list  // with single node i.e. current node)  // Step 2 (concatenate the returned list with the  // right List)  return concatenate(concatenate(left root) right);  }  // Display Circular Link List  public void display(Node head)  {  System.out.println('Circular Linked List is :');  Node itr = head;  do {  System.out.print(itr.val + ' ');  itr = itr.right;  } while (itr != head);  System.out.println();  } } // Driver Code class Main {  public static void main(String args[])  {  // Build the tree  Tree tree = new Tree();  tree.root = new Node(10);  tree.root.left = new Node(12);  tree.root.right = new Node(15);  tree.root.left.left = new Node(25);  tree.root.left.right = new Node(30);  tree.root.right.left = new Node(36);  // head refers to the head of the Link List  Node head = tree.bTreeToCList(tree.root);  // Display the Circular LinkedList  tree.display(head);  } } 

# Python3 Program to convert a Binary # Tree to a Circular Doubly Linked List class newNode: def __init__(self data): self.data = data self.left = self.right = None # A function that appends rightList # at the end of leftList. def concatenate(leftList rightList): # If either of the list is empty # then return the other list if (leftList == None): return rightList if (rightList == None): return leftList # Store the last Node of left List leftLast = leftList.left # Store the last Node of right List rightLast = rightList.left # Connect the last node of Left List # with the first Node of the right List leftLast.right = rightList rightList.left = leftLast # Left of first node points to # the last node in the list leftList.left = rightLast # Right of last node refers to # the first node of the List rightLast.right = leftList return leftList # Function converts a tree to a circular # Linked List and then returns the head # of the Linked List def bTreeToCList(root): if (root == None): return None # Recursively convert left and # right subtrees left = bTreeToCList(root.left) right = bTreeToCList(root.right) # Make a circular linked list of single # node (or root). To do so make the # right and left pointers of this node # point to itself root.left = root.right = root # Step 1 (concatenate the left list # with the list with single # node i.e. current node) # Step 2 (concatenate the returned list # with the right List) return concatenate(concatenate(left root) right) # Display Circular Link List def displayCList(head): print('Circular Linked List is :') itr = head first = 1 while (head != itr or first): print(itr.data end=' ') itr = itr.right first = 0 print() # Driver Code if __name__ == '__main__': root = newNode(10) root.left = newNode(12) root.right = newNode(15) root.left.left = newNode(25) root.left.right = newNode(30) root.right.left = newNode(36) head = bTreeToCList(root) displayCList(head) # This code is contributed by PranchalK 

// C# Program to convert a Binary Tree // to a Circular Doubly Linked List using System; // Node class represents a Node of a Tree public class Node {  public int val;  public Node left right;  public Node(int val)  {  this.val = val;  left = right = null;  } } // A class to represent a tree public class Tree {  internal Node root;  public Tree() { root = null; }  // concatenate both the lists  // and returns the head of the List  public virtual Node concatenate(Node leftList  Node rightList)  {  // If either of the list is empty  // then return the other list  if (leftList == null) {  return rightList;  }  if (rightList == null) {  return leftList;  }  // Store the last Node of left List  Node leftLast = leftList.left;  // Store the last Node of right List  Node rightLast = rightList.left;  // Connect the last node of Left List  // with the first Node of the right List  leftLast.right = rightList;  rightList.left = leftLast;  // left of first node refers to  // the last node in the list  leftList.left = rightLast;  // Right of last node refers to  // the first node of the List  rightLast.right = leftList;  // Return the Head of the List  return leftList;  }  // Method converts a tree to a circular  // Link List and then returns the head  // of the Link List  public virtual Node bTreeToCList(Node root)  {  if (root == null) {  return null;  }  // Recursively convert left  // and right subtrees  Node left = bTreeToCList(root.left);  Node right = bTreeToCList(root.right);  // Make a circular linked list of single  // node (or root). To do so make the  // right and left pointers of this node  // point to itself  root.left = root.right = root;  // Step 1 (concatenate the left list with  // the list with single node  // i.e. current node)  // Step 2 (concatenate the returned list  // with the right List)  return concatenate(concatenate(left root) right);  }  // Display Circular Link List  public virtual void display(Node head)  {  Console.WriteLine('Circular Linked List is :');  Node itr = head;  do {  Console.Write(itr.val + ' ');  itr = itr.right;  } while (itr != head);  Console.WriteLine();  } } // Driver Code public class GFG {  public static void Main(string[] args)  {  // Build the tree  Tree tree = new Tree();  tree.root = new Node(10);  tree.root.left = new Node(12);  tree.root.right = new Node(15);  tree.root.left.left = new Node(25);  tree.root.left.right = new Node(30);  tree.root.right.left = new Node(36);  // head refers to the head of the Link List  Node head = tree.bTreeToCList(tree.root);  // Display the Circular LinkedList  tree.display(head);  } } // This code is contributed by Shrikant13 

<script> // javascript Program to convert a Binary Tree to a // Circular Doubly Linked List // Node class represents a Node of a Tree class Node {  constructor(val) {  this.val = val;  this.left = null;  this.right = null;  } } // A class to represent a   var root = null;  // concatenate both the lists and returns the head  // of the List  function concatenate(leftList rightList) {  // If either of the list is empty then  // return the other list  if (leftList == null)  return rightList;  if (rightList == null)  return leftList;  // Store the last Node of left List  var leftLast = leftList.left;  // Store the last Node of right List  var rightLast = rightList.left;  // Connect the last node of Left List  // with the first Node of the right List  leftLast.right = rightList;  rightList.left = leftLast;  // left of first node refers to  // the last node in the list  leftList.left = rightLast;  // Right of last node refers to the first  // node of the List  rightLast.right = leftList;  // Return the Head of the List  return leftList;  }  // Method converts a to a circular  // Link List and then returns the head  // of the Link List  function bTreeToCList(root) {  if (root == null)  return null;  // Recursively convert left and right subtrees  var left = bTreeToCList(root.left);  var right = bTreeToCList(root.right);  // Make a circular linked list of single node  // (or root). To do so make the right and  // left pointers of this node point to itself  root.left = root.right = root;  // Step 1 (concatenate the left list with the list  // with single node i.e. current node)  // Step 2 (concatenate the returned list with the  // right List)  return concatenate(concatenate(left root) right);  }  // Display Circular Link List  function display(head) {  document.write('Circular Linked List is :  
');  var itr = head;  do {  document.write(itr.val + ' ');  itr = itr.right;  } while (itr != head);  document.write();  }  // Driver Code    // Build the   root = new Node(10);  root.left = new Node(12);  root.right = new Node(15);  root.left.left = new Node(25);  root.left.right = new Node(30);  root.right.left = new Node(36);  // head refers to the head of the Link List  var head = bTreeToCList(root);  // Display the Circular LinkedList  display(head); // This code contributed by umadevi9616 </script> 

// A C++ program for in-place conversion of Binary Tree to // CDLL #include    using namespace std; /* A binary tree node has - data  left and right pointers  */ struct Node {  int data;  Node* left;  Node* right; }; // A utility function that converts given binary tree to // a doubly linked list // root --> the root of the binary tree // head --> head of the created doubly linked list Node* BTree2DoublyLinkedList(Node* root Node** head) {  // Base case  if (root == NULL)  return root;  // Initialize previously visited node as NULL. This is  // static so that the same value is accessible in all  // recursive calls  static Node* prev = NULL;  // Recursively convert left subtree  BTree2DoublyLinkedList(root->left head);  // Now convert this node  if (prev == NULL)  *head = root;  else {  root->left = prev;  prev->right = root;  }  prev = root;  // Finally convert right subtree  BTree2DoublyLinkedList(root->right head);  return prev; } // A simple recursive function to convert a given Binary // tree to Circular Doubly Linked List using a utility // function root --> Root of Binary Tree tail --> Pointer to // tail node of created circular doubly linked list Node* BTree2CircularDoublyLinkedList(Node* root) {  Node* head = NULL;  Node* tail = BTree2DoublyLinkedList(root &head);  // make the changes to convert a DLL to CDLL  tail->right = head;  head->left = tail;  // return the head of the created CDLL  return head; } /* Helper function that allocates a new node with the given data and NULL left and right pointers. */ Node* newNode(int data) {  Node* new_node = new Node;  new_node->data = data;  new_node->left = new_node->right = NULL;  return (new_node); } /* Function to print nodes in a given circular doubly linked  * list */ void printList(Node* head) {  if (head == NULL)  return;  Node* ptr = head;  do {  cout << ptr->data << ' ';  ptr = ptr->right;  } while (ptr != head); } /* Driver program to test above functions*/ int main() {  // Let us create the tree shown in above diagram  Node* root = newNode(10);  root->left = newNode(12);  root->right = newNode(15);  root->left->left = newNode(25);  root->left->right = newNode(30);  root->right->left = newNode(36);  // Convert to DLL  Node* head = BTree2CircularDoublyLinkedList(root);  // Print the converted list  printList(head);  return 0; } // This code was contributed by Abhijeet // Kumar(abhijeet19403) 

// A Java program for in-place conversion of Binary Tree to // CDLL // A binary tree node has - data left pointer and right // pointer class Node {  int data;  Node left right;  public Node(int data)  {  this.data = data;  left = right = null;  } } class BinaryTree {  Node root;  // head --> Pointer to head node of created doubly  // linked list  Node head;  // Initialize previously visited node as NULL. This is  // static so that the same value is accessible in all  // recursive calls  static Node prev = null;  // A simple utility recursive function to convert a  // given Binary tree to Doubly Linked List root --> Root  // of Binary Tree  void BTree2DoublyLinkedList(Node root)  {  // Base case  if (root == null)  return;  // Recursively convert left subtree  BTree2DoublyLinkedList(root.left);  // Now convert this node  if (prev == null)  head = root;  else {  root.left = prev;  prev.right = root;  }  prev = root;  // Finally convert right subtree  BTree2DoublyLinkedList(root.right);  }  // A simple function to convert a given binary tree to  // Circular doubly linked list  // using a utility function  void BTree2CircularDoublyLinkedList(Node root)  {  BTree2DoublyLinkedList(root);  // make the changes to convert a DLL to CDLL  prev.right = head;  head.left = prev;  }  /* Function to print nodes in a given doubly linked list  */  void printList(Node node)  {  if (node == null)  return;  Node curr = node;  do {  System.out.print(curr.data + ' ');  curr = curr.right;  } while (curr != node);  }  // Driver program to test above functions  public static void main(String[] args)  {  // Let us create the tree as shown in above diagram  BinaryTree tree = new BinaryTree();  tree.root = new Node(10);  tree.root.left = new Node(12);  tree.root.right = new Node(15);  tree.root.left.left = new Node(25);  tree.root.left.right = new Node(30);  tree.root.right.left = new Node(36);  // convert to DLL  tree.BTree2CircularDoublyLinkedList(tree.root);  // Print the converted List  tree.printList(tree.head);  } } // This code has been contributed by Abhijeet // Kumar(abhijeet19403) 

# A python program for in-place conversion of Binary Tree to DLL # A binary tree node has data left pointers and right pointers class Node: def __init__(self val): self.data = val self.left = None self.right = None # head --> Pointer to head node of created doubly linked list head = None # Initialize previously visited node as NULL. This is # so that the same value is accessible in all recursive # calls prev = None # A simple recursive function to convert a given Binary tree # to Doubly Linked List # root --> Root of Binary Tree def BinaryTree2DoubleLinkedList(root): # Base case if (root == None): return # Recursively convert left subtree BinaryTree2DoubleLinkedList(root.left) # Now convert this node global prev head if (prev == None): head = root else: root.left = prev prev.right = root prev = root # Finally convert right subtree BinaryTree2DoubleLinkedList(root.right) # Function to print nodes in a given doubly linked list def printList(node): while (node != None): print(node.data) node = node.right # Driver program to test above functions # Let us create the tree as shown in above diagram root = Node(10) root.left = Node(12) root.right = Node(15) root.left.left = Node(25) root.left.right = Node(30) root.right.left = Node(36) # convert to DLL BinaryTree2DoubleLinkedList(root) # Print the converted List printList(head) # This code is contributed by adityamaharshi21. 

// A C# program for in-place conversion of Binary Tree to // CDLL using System; public class Node {  public int data;  public Node left right;  public Node(int data)  {  this.data = data;  left = right = null;  } } public class BinaryTree {  Node root;  // head --> Pointer to head node of created doubly  // linked list  Node head;  // Initialize previously visited node as NULL. This is  // static so that the same value is accessible in all  // recursive calls  static Node prev = null;  // A simple utility recursive function to convert a  // given Binary tree to Doubly Linked List root --> Root  // of Binary Tree  void BTree2DoublyLinkedList(Node root)  {  // Base case  if (root == null)  return;  // Recursively convert left subtree  BTree2DoublyLinkedList(root.left);  // Now convert this node  if (prev == null)  head = root;  else {  root.left = prev;  prev.right = root;  }  prev = root;  // Finally convert right subtree  BTree2DoublyLinkedList(root.right);  }  // A simple function to convert a given binary tree to  // Circular doubly linked list  // using a utility function  void BTree2CircularDoublyLinkedList(Node root)  {  BTree2DoublyLinkedList(root);  // make the changes to convert a DLL to CDLL  prev.right = head;  head.left = prev;  }  /* Function to print nodes in a given doubly linked list  */  void printList(Node node)  {  if (node == null)  return;  Node curr = node;  do {  Console.Write(curr.data + ' ');  curr = curr.right;  } while (curr != node);  }  static public void Main()  {  // Let us create the tree as shown in above diagram  BinaryTree tree = new BinaryTree();  tree.root = new Node(10);  tree.root.left = new Node(12);  tree.root.right = new Node(15);  tree.root.left.left = new Node(25);  tree.root.left.right = new Node(30);  tree.root.right.left = new Node(36);  // convert to DLL  tree.BTree2CircularDoublyLinkedList(tree.root);  // Print the converted List  tree.printList(tree.head);  } } // This code is contributed by lokesh(lokeshmvs21). 

// A javascript program for in-place conversion of Binary Tree to DLL // A binary tree node has data left pointers and right pointers class Node {  constructor(val) {  this.data = val;  this.left = null;  this.right = null;  } } var root; // head --> Pointer to head node of created doubly linked list var head; // Initialize previously visited node as NULL. This is // so that the same value is accessible in all recursive // calls var prev = null; // A simple recursive function to convert a given Binary tree // to Doubly Linked List // root --> Root of Binary Tree function BinaryTree2DoubleLinkedList(root) {  // Base case  if (root == null)  return;    // Recursively convert left subtree  BinaryTree2DoubleLinkedList(root.left);    // Now convert this node  if (prev == null)  head = root;  else {  root.left = prev;  prev.right = root;  }  prev = root;    // Finally convert right subtree  BinaryTree2DoubleLinkedList(root.right); } /* Function to print nodes in a given doubly linked list */ function printList(node) {  while (node != null) {  console.log(node.data + ' ');  node = node.right;  } } // Driver program to test above functions // Let us create the tree as shown in above diagram root = new Node(10); root.left = new Node(12); root.right = new Node(15); root.left.left = new Node(25); root.left.right = new Node(30); root.right.left = new Node(36); // convert to DLL BinaryTree2DoubleLinkedList(root); // Print the converted List printList(head); // This code is contributed by ishankhandelwals.