leetcode--Populating Next Right Pointers in Each Node II

最新推荐文章于 2021-12-24 11:09:57 发布

转载最新推荐文章于 2021-12-24 11:09:57 发布 · 80 阅读

文章标签：

#LeetCode

基础--5.算法（LeetCode）专栏收录该内容

178 篇文章

订阅专栏

本文介绍了解决二叉树中每个节点的next指针指向其右侧相邻节点的问题，提供了四种不同的实现方法，包括层次遍历、迭代及递归等方案。

Follow up for problem "Populating Next Right Pointers in Each Node".

What if the given tree could be any binary tree? Would your previous solution still work?

Note:

You may only use constant extra space.

For example,
Given the following binary tree,

After calling your function, the tree should look like:

         1 -> NULL
       /  \
      2 -> 3 -> NULL
     / \    \
    4-> 5 -> 7 -> NULL

分类：二叉树

题意：对于每个节点，将next指向其右边的相邻节点，如果右边没有节点，则指向Null。该树为任意二叉树。

解法1：层次遍历。使用两个栈来交替记录两层。对于每个层，逐一连接即可。

[java]view plaincopy 
   
 /** 
  * Definition for binary tree with next pointer. 
  * public class TreeLinkNode { 
  *     int val; 
  *     TreeLinkNode left, right, next; 
  *     TreeLinkNode(int x) { val = x; } 
  * } 
  */  
 public class Solution {  
     public void connect(TreeLinkNode root) {  
         if(root==null) return;    
         Stack<TreeLinkNode> stack1 = new Stack<TreeLinkNode>();    
         List<TreeLinkNode> stack2 = new ArrayList<TreeLinkNode>();    
         stack1.add(root);    
         while(stack1.size()>0||stack2.size()>0){              
             TreeLinkNode pre = null;    
             while(stack1.size()>0){    
                 TreeLinkNode t = stack1.pop();          
                 if(t.left!=null) stack2.add(t.left);    
                 if(t.right!=null) stack2.add(t.right);    
                 if(pre!=null){    
                     pre.next = t;                       
                 }    
                 pre = t;    
             }    
             Collections.reverse(stack2);    
             stack1.addAll(stack2);    
             stack2.clear();    
         }    
     }  
 }  

解法2：层次遍历，和Populating Next Right Pointers in Each Node里面的解法类似，主要问题是，1，找到下一层开始的第一个节点；2，找到当前节点右边的第一个节点

[java]view plaincopy 
   
 /** 
  * Definition for binary tree with next pointer. 
  * public class TreeLinkNode { 
  *     int val; 
  *     TreeLinkNode left, right, next; 
  *     TreeLinkNode(int x) { val = x; } 
  * } 
  */  
 public class Solution {  
     public void connect(TreeLinkNode root) {  
         if(root==null) return;  
         TreeLinkNode cur = root;//上一层第一个节点  
         TreeLinkNode start = null;  
         root.next = null;  
         while(root!=null){//没有到最后一层的第一个节点  
             start = findStart(root);//当前层第一个节点             
             cur = start;              
             while(cur!=null){//遍历当前层  
                cur.next = findNext(root,cur);  
                cur = cur.next;  
             }             
             root = start;//当前层第一个节点  
         }  
     }  
       
     public TreeLinkNode findStart(TreeLinkNode root){//找到下一层的第一个节点  
         while(root!=null){  
             if(root.left!=null) return root.left;  
             if(root.right!=null) return root.right;  
             root = root.next;  
         }  
         return null;  
     }  
       
     public TreeLinkNode findNext(TreeLinkNode root,TreeLinkNode cur){//找到当前节点右边的第一个节点  
         while(root!=null){//找到当前节点父节点  
             if(root.left==cur||root.right==cur) break;  
             root = root.next;             
         }         
         if(root.right==cur) root=root.next;//如果当前节点在父节点的右边，将root指向它的右边   
         while(root!=null){  
             if(root.left!=cur&&root.left!=null) return root.left;  
             if(root.right!=cur&&root.right!=null) return root.right;  
             root = root.next;  
         }  
         return null;  
     }  
 }  

解法3：层次遍历。关键在于保留下一层的第一个节点。另外保留一个pre指向前一个节点。

[java]view plaincopy 
   
 /** 
  * Definition for binary tree with next pointer. 
  * public class TreeLinkNode { 
  *     int val; 
  *     TreeLinkNode left, right, next; 
  *     TreeLinkNode(int x) { val = x; } 
  * } 
  */  
 public class Solution {  
     public void connect(TreeLinkNode root) {  
         if(root==null) return;  
         TreeLinkNode cur = root;//上一层第一个节点  
         while(root!=null){//没有到最后一层的第一个节点  
             cur = root;  
             TreeLinkNode temp = new TreeLinkNode(-1);//该节点用于保存下一层的第一个节点             
             TreeLinkNode pre = temp;  
             while(cur!=null){//遍历当前层  
                if(cur.left!=null){  
                    pre.next = cur.left;  
                    pre = pre.next;  
                }  
                if(cur.right!=null){  
                    pre.next = cur.right;  
                    pre = pre.next;  
                }  
                cur = cur.next;  
             }             
             root = temp.next;//下一层的第一个节点  
         }  
     }  
 }  

解法4：将解法3的迭代换成递归

[java]view plaincopy 
   
 /** 
  * Definition for binary tree with next pointer. 
  * public class TreeLinkNode { 
  *     int val; 
  *     TreeLinkNode left, right, next; 
  *     TreeLinkNode(int x) { val = x; } 
  * } 
  */  
 public class Solution {  
     public void connect(TreeLinkNode root) {  
         if(root==null) return;  
         TreeLinkNode temp = new TreeLinkNode(-1);             
         TreeLinkNode pre = temp;  
         while(root!=null){//遍历当前层  
            if(root.left!=null){  
                pre.next = root.left;  
                pre = pre.next;  
            }  
            if(root.right!=null){  
                pre.next = root.right;  
                pre = pre.next;  
            }  
            root = root.next;  
         }             
         connect(temp.next);//连接下一层  
     }  
 } 