The Great Tree-List Recursion Problem

Introduction

The "Great Tree List Recursion" concept involves combining binary tree structures and linked lists through recursive algorithms, creating a versatile data structure that exhibits properties of both trees and lists.

This paradigm uses a binary tree with pointers to each node's left and right children.. Additionally, the tree's leaf nodes are connected to form a doubly linked list. This duality allows for efficient traversal and manipulation of the structure.

Recursion includes a depth-first traversal of the binary tree to produce a Great Tree List.. Starting from the root, the algorithm recursively traverses the left subtree, processes the current node by updating its pointers to form a linked list segment, and proceeds to the right subtree. This procedure continues until every node has been travelled through and connected to each other.

The real power of the Great Tree List Recursion lies in its ability to perform operations that benefit from both tree-like hierarchical organization and list-like sequential access. For instance, searching for elements, insertion, and deletion can be achieved efficiently using the binary tree structure, while tasks requiring sequential processing can utilize the linked list structure.

Note: I would Highly recommend you to come up with an approach before looking into the explanation

Great Tree List Recursion code:

Java Code:

 class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
        left = null;
        right = null;
    }
}

public class TreeToListConversion {

    private TreeNode prev = null; // Previous node in the linked list

    public void convertToLinkedList(TreeNode root) {
        if (root == null) {
            return;
        }

        // Recursively convert the left subtree
       
convertToLinkedList(root.left);

        // Update pointers to form the linked list
        if (prev != null) {
            prev.right = root;
            root.left = prev;
        }
        prev = root;

        // Recursively convert the right subtree
       
convertToLinkedList(root.right);
    }

    public void printList(TreeNode head) {
        TreeNode current = head;
        while (current != null) {
           
System.out.print(current.val + " ");
            current = current.right;
        }
    }
    public static void main(String[] args) {
        TreeNode root = new TreeNode(4);
        root.left = new TreeNode(2);
        root.right = new TreeNode(6);
        root.left.left = new TreeNode(1);
       
root.left.right = new TreeNode(3);
       
root.right.left = new TreeNode(5);
       
root.right.right = new TreeNode(7);
TreeToListConversion converter = new TreeToListConversion();
converter.convertToLinkedList(root); 
System.out.println("Converted Doubly Linked List:"); 
converter.printList(root.left.left); // Start from the smallest node

        // Output should be: 1 2 3 4 5 6 7
    }
}

Output:

Converted Doubly Linked List:
1 2 3 4 5 6 7

Explanation:

Working of the Code:

The code creates a binary search tree, converts it to a doubly linked list in place using the Great Tree List Recursion concept, and then prints the linked list. The convertToLinkedList method recursively traverses the tree, updating pointers to create the linked list structure.

Time Complexity:

The time complexity of the algorithm is O(n), where n is the quantity of nodes in the binary tree.. This is because each node is visited exactly once during the conversion process.

Space Complexity:

The space complexity is O(h), where h is the binary tree's height. This is due to the recursive calls on the stack. When the tree is skewed and has a n (unbalanced) height, the space complexity may be O(n)., the space complexity will be closer to O(log n).

Dry Run

Main Method:

The binary search tree is created with the structure shown above.
An instance of TreeToListConversion is created.
The convertToLinkedList method is called with the root of the tree.

convertToLinkedList Method:

Initial state: prev = null
Starting from the root (value 4):
Recursively call convertToLinkedList on the left subtree (node with value 2).
Recursively call convertToLinkedList on the left subtree (node with value 1).
Since there's no left subtree, nothing happens.
Update prev to point to the node with value 1.
Connect a node with value 1 to the right of a node with value 2.
Update prev to point to the node with value 2.
Connect a node with value 2 to the right of a node with value 4.
Recursively call convertToLinkedList on the right subtree (node with value 3).
Since there's no left subtree, nothing happens.
Update prev to point to the node with value 3.
Connect a node with value 3 to the right of a node with value 2.
Recursively call convertToLinkedList on the right subtree (node with value 6).
Recursively call convertToLinkedList on the left subtree (node with value 5).
Since there's no left subtree, nothing happens.
Update prev to point to the node with value 5.
Connect a node with value 5 to the right of a node with value 6.
Update prev to point to the node with value 6.
Connect a node with value 6 to the right of a node with value 4.
Update prev to point to the node with value 4.

Printing the Linked List:

The printList method is called with the leftmost node (value 1).
The loop iterates through the linked list using the right pointers and prints the values: 1 2 3 4 5 6 7.
Output: Converted Doubly Linked List: 1 2 3 4 5 6 7

Great Tree List Using Stack Data Structure code

Java Code:

import java.util.Stack;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
        left = null;
        right = null;
    }
}
public class TreeToListConversion {

    public TreeNode convertToLinkedList(TreeNode root) {
        if (root == null) {
            return null;
        }   
Stack<TreeNode> stack = new Stack<>();
        TreeNode current = root;
        TreeNode prev = null;
        TreeNode head = null;

        while (current != null || !stack.isEmpty()) {
            while (current != null) {
               
stack.push(current);
               
current = current.left;
            }

            current = stack.pop();

            if (prev != null) {
               
prev.right = current;
               
current.left = prev;
            } else {
                head = current; // Save the leftmost node as the head of the linked list
            }

            prev = current;
            current = current.right;
        }

        return head;
    }

    public void printList(TreeNode head) {
        TreeNode current = head;
        while (current != null) {
           
System.out.print(current.val + " ");
            current = current.right;
        }
    }
    public static void main(String[] args) {
        TreeNode root = new TreeNode(4);
        root.left = new TreeNode(2);
        root.right = new TreeNode(6);
        root.left.left = new TreeNode(1);
       
root.left.right = new TreeNode(3);
       
root.right.left = new TreeNode(5);
       
root.right.right = new TreeNode(7);

       
TreeToListConversion converter = new TreeToListConversion();
        TreeNode head = converter.convertToLinkedList(root);

       
System.out.println("Converted Doubly Linked List:");
       
converter.printList(head);

        // Output should be: 1 2 3 4 5 6 7
    }
}

Output:

Converted Doubly Linked List:
1 2 3 4 5 6 7

Explanation:

Time Complexity:

The time complexity of this algorithm is O(n), where n is the number of nodes in the binary tree. Every node is visited exactly once, and each node's push/pop operation on the stack takes constant time.

Space Complexity:

The stack size used for simulating the iterative process determines the space complexity. In the worst-case scenario, where the tree is skewed (unbalanced), the space complexity could reach O(n). In a balanced tree, the space complexity will be closer to O(log n) as the height of the stack is determined by the tree's height.

Dry Run

Step 1: Initializing