Converting a Binary Tree to a Doubly Linked List | Programming Concept | DSA

When it comes to data structures in computer science, binary trees and linked lists are fundamental concepts that often come into play. In this post, we will explore an intriguing problem: converting a binary tree into a doubly linked list (DLL). This task may seem daunting, but with the right approach, we can achieve it seamlessly. Let's dive into the details!

Understanding the Problem

What is a Binary Tree?

A binary tree is a hierarchical structure in which each node has at most two children referred to as the left child and the right child. This structure is crucial for organizing data hierarchically, facilitating efficient searching, inserting, and deleting operations.

What is a Doubly Linked List?

A doubly linked list (DLL) is a linear data structure consisting of nodes, where each node contains three components: a data field and two pointers. One pointer points to the next node in the sequence (next), while the other points to the previous node (prev). This bidirectional nature of DLLs allows for easy traversal in both directions.

Our goal is to convert a given binary tree into a DLL such that:

• The left and right pointers of the binary tree nodes are repurposed to act as the previous and next pointers in the DLL.
• The order of nodes in the DLL reflects the in-order traversal of the binary tree.
• The head of the DLL is the leftmost node of the binary tree.

Efficient Approach

To convert a binary tree into a DLL, we can use a recursive approach. Here’s how the process works:

1. In-Order Traversal: The in-order traversal visits nodes in the order of left child, current node, and right child. This order is essential because it aligns with our requirement for the doubly linked list.

2. Node Manipulation: During the traversal, we need to adjust the pointers of the nodes to link them as a doubly linked list.

Implementation

Below is a C++ implementation of the approach discussed:

class Node {

public:

    int data;

    Node* left;  // used as previous pointer in DLL

    Node* right; // used as next pointer in DLL

   

    Node(int val) : data(val), left(nullptr), right(nullptr) {}

};

class Solution {

public:

    void create(Node* root, Node* &head) {

        if (!root) return;

        // Traverse right first

        create(root->right, head);

        // Link current node with the head

        root->right = head; // Set the right pointer (next)

        if (head) {

            head->left = root; // Set the left pointer (previous)

        }

        head = root; // Move head to the current node

        // Traverse left

        create(root->left, head);

    }

    Node* bToDLL(Node* root) {

        Node* head = nullptr;

        create(root, head);

        return head; // Return the head of the doubly linked list

    }

};

 

Explanation of the Code

1. Node Structure: We define a Node class to represent each node in the binary tree, with data, left, and right pointers.

2. Recursive Function: The create function recursively processes the binary tree. It first traverses the right subtree, then links the current node to the head of the DLL, and finally traverses the left subtree.

3. Main Function: The bToDLL function initializes the head pointer to nullptr and starts the conversion process.

Complexity Analysis

• Time Complexity: The time complexity for this conversion is O(n), where n is the number of nodes in the binary tree. Each node is processed once during the traversal.

• Space Complexity: The space complexity is O(h), where h is the height of the binary tree, due to the recursion stack. In the worst case, for a skewed tree, this can be O(n).

Converting a binary tree to a doubly linked list is a fascinating problem that showcases the power of recursion and pointer manipulation. By following the in-order traversal and appropriately adjusting node pointers, we can efficiently transform the binary tree structure into a DLL.

This approach not only enhances our understanding of trees and linked lists but also equips us with techniques that can be applied to various other data structure problems. Whether you're preparing for coding interviews or just looking to deepen your understanding of data structures, mastering this conversion process is a valuable skill.