将二叉树转换成双链表

将二叉树转换成双链表

题目：

描述
将一个二叉树按照中序遍历转换成双向链表。

样例
样例 1：

输入:
	    4
	   / \
	  2   5
	 / \
	1   3		

输出: 1<->2<->3<->4<->5
样例 2：

输入:
	    3
	   / \
	  4   1

输出:4<->3<->1

解题思路1：先用队列存储二叉树中序遍历结果，然后遍历队列建立双向链表

/**
 * Definition for Doubly-ListNode.
 * public class DoublyListNode {
 *     int val;
 *     DoublyListNode next, prev;
 *     DoublyListNode(int val) {
 *         this.val = val;
 *         this.next = this.prev = null;
 *     }
 * } * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */

public class Solution {
    /**
     * @param root: The root of tree
     * @return: the head of doubly list node
     */
    public DoublyListNode bstToDoublyList(TreeNode root) {
        // write your code here
        if(root == null) {
            return null;
        }

        Queue<TreeNode> queue = new LinkedList();
        inOrder(root, queue);
        DoublyListNode head = queueToDList(queue);
        head.prev = null;
        return head;
    }

    private DoublyListNode queueToDList(Queue<TreeNode> queue) {
        if(queue == null || queue.isEmpty()) {
            return null;
        }
        DoublyListNode pr = new DoublyListNode(0);
        DoublyListNode head = pr;
        while(!queue.isEmpty()) {
            TreeNode tCur = queue.poll();
            DoublyListNode cur = new DoublyListNode(tCur.val);
            cur.prev = pr;
            pr.next = cur;
            pr = cur;
        }

        return head.next;
    }

    private void inOrder(TreeNode node, Queue<TreeNode> queue) {
        if(node == null) {
            return ;
        }

        inOrder(node.left, queue);
        queue.offer(node);
        inOrder(node.right, queue);
    }
}

解题思路2：用递归进行解决，

/**
 * Definition for Doubly-ListNode.
 * public class DoublyListNode {
 *     int val;
 *     DoublyListNode next, prev;
 *     DoublyListNode(int val) {
 *         this.val = val;
 *         this.next = this.prev = null;
 *     }
 * } * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */

public class Solution {
    /**
     * @param root: The root of tree
     * @return: the head of doubly list node
     */
    public DoublyListNode bstToDoublyList(TreeNode root) {
        // write your code here
        if(root == null) {
            return null;
        }

        // flag = 2 为了让返回的节点是 头节点
        DoublyListNode node = dfs(root, 2);
        return node;
    }
    
    // flag用于标记当前遍历的是左子树还是右子树
    // 1为左子树 2为右子树
    // 当flag = 1 返回节点时 要将节点遍历至最后一个节点方便连接
    // flag = 2 返回节点时 同理要将节点遍历至头节点
    private DoublyListNode dfs(TreeNode root, int flag) {
        if(root == null) {
            return null;
        }

        DoublyListNode pr = dfs(root.left, 1);
        DoublyListNode node = new DoublyListNode(root.val);
        DoublyListNode next = dfs(root.right, 2);

        if(pr != null) {
            pr.next = node;
            node.prev = pr;
        }

        if(next != null) {
            node.next = next;
            next.prev = node;
        }

        if(flag == 1) {
            while(node.next != null) {
                node = node.next;
            }
        } else {
            while(node.prev != null) {
                node = node.prev;
            }
        }

        return node;
    }
}