leetcode--Flatten Binary Tree to Linked List

Given a binary tree, flatten it to a linked list in-place.

For example,
Given

         1
        / \
       2   5
      / \   \
     3   4   6

The flattened tree should look like:

   1
    \
     2
      \
       3
        \
         4
          \
           5
            \
             6

分类：二叉树

题意：将二叉树转换成链表

解法1：递归。递归方法将返回链表的第一个节点。对于根节点而言，分别递归转换左右子树，然后找到左链表的最后一个节点(如果存在的话)，连接该节点与右链表。

再用根节点连接左链表。

该方法超时，原因在于找左链表的最后一个节点，耗时。

[java]  view plain  copy

1. /** 
2.  * Definition for a binary tree node. 
3.  * public class TreeNode { 
4.  *     int val; 
5.  *     TreeNode left; 
6.  *     TreeNode right; 
7.  *     TreeNode(int x) { val = x; } 
8.  * } 
9.  */  
10. public class Solution {    
11.     public void flatten(TreeNode root) {    
12.         if(root==null) return ;  
13.         flatten(root.left);  
14.         flatten(root.right);  
15.         TreeNode left = root.left;  
16.         if(left==null) return;  
17.         while(left.right!=null){//找到左链表最后一个节点  
18.             left = left.right;  
19.         }  
20.         left.right = root.right;  
21.         root.right = root.left;  
22.     }         
23. }    

解法2：递归解决。该方法返回转换成链表以后的最后一个节点。与解法1不同，先递归转换左子树，然后连接左链表跟右子树的第一个节点，接着在递归转换右子树。最后连接根节点和左链表。由于返回的是最后一个节点，省去方法1所说的找到最后一个节点的时间。

[java]  view plain  copy

1. /** 
2.  * Definition for a binary tree node. 
3.  * public class TreeNode { 
4.  *     int val; 
5.  *     TreeNode left; 
6.  *     TreeNode right; 
7.  *     TreeNode(int x) { val = x; } 
8.  * } 
9.  */  
10. public class Solution {  
11.     public void flatten(TreeNode root) {  
12.         helper(root);  
13.     }  
14.       
15.     TreeNode helper(TreeNode root){  
16.         if(root==null) return null;  
17.         TreeNode left = null;  
18.         TreeNode right = null;        
19.         if(root.left!=null){  
20.             left = helper(root.left);  
21.             if(left!=null){//如果左链表存在  
22.                 left.right = root.right;//连接左链表跟右子树               
23.                 root.right = root.left;//连接根节点跟左链表  
24.             }  
25.             root.left = null;  
26.         }                 
27.         right = helper(root.right);   
28.         //根据情况，返回最后一个节点  
29.         if(right!=null)  
30.             return right;  
31.         else if(left!=null)  
32.             return left;  
33.         else   
34.             return root;  
35.     }  
36. }  

解法3：使用栈。对于根节点，先后存入其左节点，右节点。然后将左节点连接到根节点的右边。至于其他节点，因为已经存在栈里面了。只要对于每个节点都重复上述过程，而不理会其子树。

[java]  view plain  copy

1. /** 
2.  * Definition for a binary tree node. 
3.  * public class TreeNode { 
4.  *     int val; 
5.  *     TreeNode left; 
6.  *     TreeNode right; 
7.  *     TreeNode(int x) { val = x; } 
8.  * } 
9.  */  
10. public class Solution {    
11.     public void flatten(TreeNode root) {    
12.         if(root==null) return;  
13.         Stack<TreeNode> stack = new Stack<TreeNode>();  
14.         stack.add(root);  
15.         while(!stack.isEmpty()){  
16.             TreeNode cur = stack.pop();  
17.             if(cur.left!=null) stack.add(cur.left);  
18.             if(cur.right!=null) stack.add(cur.right);  
19.             cur.left=null;  
20.             if(!stack.isEmpty()){//当前左节点转换成右节点  
21.                 cur.right = stack.peek();  
22.             }  
23.         }  
24.     }    
25. }

原文链接http://blog.youkuaiyun.com/crazy__chen/article/details/46493951