426. Convert a given Binary Tree to Doubly Linked List

The question and solution are from: http://www.geeksforgeeks.org/convert-given-binary-tree-doubly-linked-list-set-3/

Given a Binary Tree (BT), convert it to a Doubly Linked List(DLL) In-Place. The left and right pointers in nodes are to be used as previous and next pointers respectively in converted DLL. The order of nodes in DLL must be same as Inorder of the given Binary Tree. The first node of Inorder traversal (left most node in BT) must be head node of the DLL.

 

曾经的我能够想到的方法就是利用LinkedList来保存每个node，然后修改每个node的left和right。

下面这个方法现在想起来好像并不那么复杂了， 值得学习一下。

这种方法使用inorder traversal, 他先一直traverse到最左边，然后set head. 在traverse右边之前，把当前root设置成prev, 这样就可以把prev和后面部分的dll连起来。

public class BinaryTree {
    Node head, prev = null;
    void binaryTree2DoubleLinkedList(Node root) {
        if (root == null) return;
        binaryTree2DoubleLinkedList(root.left);
        if (prev == null) { 
            head = root;
        } else {
            root.left = prev;
            prev.right = root;
        }
        prev = root;
        binaryTree2DoubleLinkedList(root.right);
    }

    void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.right;
        }
    }
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        Node 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);

        tree.binaryTree2DoubleLinkedList(root);
        tree.printList(tree.head);

    }
    
    public Node binaryTreeToDDL(Node root) {
        if (root == null) return null;
        
        Node leftHead = binaryTreeToDDL(root.left);
        Node rightHead = binaryTreeToDDL(root.right);
        
        Node newHead = null;
        
        if (leftHead == null) {
            newHead = root;
        } else {
            Node leftEnd = leftHead;
            while (leftEnd.right != null) {
                leftEnd = leftEnd.right;
            }
            leftEnd.right = root;
            root.left = leftEnd;
            newHead = leftHead;
        }
        
        if (rightHead != null) {
            rightHead.left = root;
            root.right = rightHead;
        }
        return newHead;
    }
}

class Node {
    int data;
    Node left, right;

    public Node(int data) {
        this.data = data;
        left = right = null;
    }
}

 

Leetcode上的确是真正的doubly linked list. 所以实现上稍微有点不一样。

Convert a Binary Search Tree to a sorted Circular Doubly-Linked List in place.

You can think of the left and right pointers as synonymous to the predecessor and successor pointers in a doubly-linked list. For a circular doubly linked list, the predecessor of the first element is the last element, and the successor of the last element is the first element.

We want to do the transformation in place. After the transformation, the left pointer of the tree node should point to its predecessor, and the right pointer should point to its successor. You should return the pointer to the smallest element of the linked list.

 

Example 1:

Input: root = [4,2,5,1,3]

Output: [1,2,3,4,5]

Explanation: The figure below shows the transformed BST. The solid line indicates the successor relationship, while the dashed line means the predecessor 

class Solution {
    public Node treeToDoublyList(Node root) {
        if (root == null) {
            return null;
        }
        
        Node leftHead = treeToDoublyList(root.left);
        Node rightHead = treeToDoublyList(root.right);
        root.left = root;
        root.right = root;
        return connect(connect(leftHead, root), rightHead);
    }
    
    // Used to connect two circular doubly linked lists. n1 is the head of circular DLL as well as n2.
    private Node connect(Node n1, Node n2) {
        if (n1 == null) return n2;
        if (n2 == null) return n1;
        
        Node tail1 = n1.left;
        Node tail2 = n2.left;
        
        tail1.right = n2;
        n2.left = tail1;
        tail2.right = n1;
        n1.left = tail2;
        
        return n1;
    }
}