[GeeksForGeeks] Extract Leaves of a Binary Tree in a Doubly Linked List

Given a Binary Tree, extract all leaves of it in a Doubly Linked List (DLL). Note that the DLL need to be created in-place. Assume that the node structure of DLL and Binary Tree is same, only the meaning of left and right pointers are different. In DLL, left means previous pointer and right means next pointer.

Let the following be input binary tree
        1
     /     
    2       3
   /        
  4   5       6
 /          / 
7   8       9   10


Output:
Doubly Linked List
7<->8<->5<->9<->10

Modified Tree:
        1
     /     
    2       3
   /         
  4           6

import java.util.LinkedList;
import java.util.Queue;

public class ExtractLeavesToDLL {
    private TreeNode head = null;
    private TreeNode tail = null;
    public void extractLeaveNodesToDLL(TreeNode root) {
        recursionHelper(root);
    }
    private boolean recursionHelper(TreeNode node) {
        if(node == null) {
            return false;
        }
        else if(node.left == null && node.right == null) {
            if(head == null) {
                head = node;
                tail = node;
            }
            else {
                tail.right = node;
                node.left = tail;
                tail = node;
            }
            return true;
        }
        if(recursionHelper(node.left)) {
            node.left = null;
        }
        if(recursionHelper(node.right)) {
            node.right = null;
        }
        return false;
    }
    private void traverseDLL(TreeNode head) {
        TreeNode curr = head;
        while(curr != null) {
            String prevNode = curr.left == null ? "null" : Integer.toString(curr.left.key);
            String nextNode = curr.right == null ? "null" : Integer.toString(curr.right.key);
            System.out.println(curr.key + "'s prev node is " + prevNode + " and its next node is " + nextNode);
            curr = curr.right;
        }
    }
    private void traverseBT(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        
        while(!queue.isEmpty()) {
            TreeNode curr = queue.poll();
            String leftNode = curr.left == null ? "null" : Integer.toString(curr.left.key);
            String rightNode = curr.right == null ? "null" : Integer.toString(curr.right.key);
            System.out.println(curr.key + "'s left node is " + leftNode + " and its right node is " + rightNode);
            if(curr.left != null) {
                queue.add(curr.left);
            }
            if(curr.right != null) {
                queue.add(curr.right);
            }
        }
    }
    public static void main(String[] args) {
        TreeNode[] nodes = new TreeNode[10];
        for(int i = 0; i < nodes.length; i++) {
            nodes[i] = new TreeNode(i + 1);
        }
        nodes[0].left = nodes[1]; nodes[0].right = nodes[2];
        nodes[1].left = nodes[3]; nodes[1].right = nodes[4];
        nodes[2].right = nodes[5];
        nodes[3].left = nodes[6]; nodes[3].right = nodes[7];
        nodes[5].left = nodes[8]; nodes[5].right = nodes[9];
        ExtractLeavesToDLL test = new ExtractLeavesToDLL();
        test.extractLeaveNodesToDLL(nodes[0]);
        
        //check dll is correctly constructed 
        test.traverseDLL(test.head);
        //check binary tree is correctly modified.
        test.traverseBT(nodes[0]);
    }
}