leetcode--Populating Next Right Pointers in Each Node II-优快云博客

本文探讨了如何在二叉树中为每个节点填充Next指针以指向其右侧相邻节点的方法。介绍了四种不同的解决方案，包括使用栈进行层次遍历、递归等技巧，并分析了每种方法的特点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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：层次遍历。使用两个栈来交替记录两层。对于每个层，逐一连接即可。

/**
 * 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，找到当前节点右边的第一个节点

/**
 * 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指向前一个节点。

/**
 * 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的迭代换成递归

/**
 * 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);//连接下一层
    }
}