Binary Tree to CDLL

Binary trees are essential data structures in computer science that provide an organized method of storing and managing data. Circular Doubly Linked Lists (CDLLs), on the other hand, have a circular structure in which each node points to both its preceding and next node. Converting a binary tree to a CDLL entails rearranging the nodes of the tree into a circular doubly linked list while preserving the natural order. This page looks into the transformation's method, algorithms, and implementation specifics.

Understanding Binary Trees and CDLLs:

A binary tree is a hierarchical data structure composed of nodes, each of which has at most two offspring, referred to as the left and right child. A CDLL, on the other hand, is a linked list in which the final node refers back to the first node and vice versa, resulting in a circular structure. A CDLL node carries data as well as two pointers: one to the next node and one to the previous node.

Pseudocode

treeToCDLLUtil(root, head, tail):
    if root is NULL:
        return
    treeToCDLLUtil(root->left, head, tail)
    if head is NULL:
        head = root
        tail = root
    else:
        tail->right = root
        root->left = tail
        tail = root
    treeToCDLLUtil(root->right, head, tail)
    tail->right = head
    head->left = tail
treeToCDLL(root):
    head = NULL
    tail = NULL
    treeToCDLLUtil(root, head, tail)

Algorithm for Binary Tree to CDLL Conversion:

Input: Root node of the Binary Tree

1. Initialize Head and Tail Pointers:

Initialize head and tail pointers of the resulting CDLL as NULL.

2. Define Utility Function:

Create a utility function treeToCDLLUtil that takes the following parameters:
The root of the binary tree
Reference to the head pointer of the resulting CDLL
Reference to the tail pointer of the resulting CDLL

3. Utility Function (treeToCDLLUtil):

If the root is NULL, return.
Recursively call treeToCDLLUtil for the left subtree.

4. Handle Current Node:

If head is NULL:

Set head and tail pointers to the current node.

Else:

Connect the tail->right to the current node.
Connect the current node's left to tail.
Update tail to the current node.

5. Handle Right Subtree:

Recursively call treeToCDLLUtil for the right subtree.

6. Connect Head and Tail:

After both subtrees are processed, make the CDLL circular:
Connect tail->right to head.
Connect head->left to tail.

7. Return:

Return from the utility function.

Main Function:

Call the utility function treeToCDLLUtil with the root of the binary tree, head, and tail pointers

Converting Binary Tree to CDLL by traversal

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
struct Node* createNode(int value) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}
struct Node* concatenateCDLL(struct Node* leftList, struct Node* rightList) {
    if (leftList == NULL) return rightList;
    if (rightList == NULL) return leftList;
    struct Node* leftLast = leftList->left;
    struct Node* rightLast = rightList->left;
    leftLast->right = rightList;
    rightList->left = leftLast;
    leftList->left = rightLast;
    rightLast->right = leftList;

    return leftList;
}
struct Node* treeToCDLL(struct Node* root) {
    if (root == NULL) return NULL;
    struct Node* leftList = treeToCDLL(root->left);
    struct Node* rightList = treeToCDLL(root->right);
    root->left = root;
    root->right = root;
    leftList = concatenateCDLL(leftList, root);
    leftList = concatenateCDLL(leftList, rightList);
    return leftList;
}
void printCDLL(struct Node* head) {
    if (head == NULL) return;
    struct Node* current = head;
    do {
        printf("%d ", current->data);
        current = current->right;
    } while (current != head);
}
int main() {
    struct Node* root = createNode(10);
    root->left = createNode(5);
    root->right = createNode(20);
    root->left->left = createNode(3);
    root->left->right = createNode(7);
    root->right->right = createNode(30);

    struct Node* head = treeToCDLL(root);
    printf("Circular Doubly Linked List: ");
    printCDLL(head);
    return 0;
}

Output:

Converting Binary Tree to CDLL by recursion

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
struct Node* createNode(int value) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}
void treeToCDLLUtil(struct Node* root, struct Node** head, struct Node** tail) {
    if (root == NULL)
        return;
    treeToCDLLUtil(root->left, head, tail);
    if (*head == NULL) {
        *head = root;
        *tail = root;
    } else {
        (*tail)->right = root;
        root->left = *tail;
        *tail = root;
    }
    struct Node* rightChild = root->right;
    (*tail)->right = *head;
    (*head)->left = *tail;
    treeToCDLLUtil(rightChild, head, tail);
}
void treeToCDLL(struct Node* root, struct Node** head) {
    struct Node* tail = NULL;
    treeToCDLLUtil(root, head, &tail);
}
void printCDLL(struct Node* head) {
    if (head == NULL)
        return;
    struct Node* current = head;
    do {
        printf("%d ", current->data);
        current = current->right;
    } while (current != head);
}
int main() {
    struct Node* root = createNode(10);
    root->left = createNode(5);
    root->right = createNode(20);
    root->left->left = createNode(3);
    root->left->right = createNode(7);
    root->right->right = createNode(30);
    struct Node* head = NULL;
    treeToCDLL(root, &head);
    printf("Circular Doubly Linked List: ");
    printCDLL(head);
    return 0;
}

Output: