填充每个节点的下一个右侧节点指针

来源：力扣（LeetCode）链接：leetcode.cn/problems/po…

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例 1：

图片.png

输入：root = [1,2,3,4,5,6,7]

输出：[1,#,2,3,#,4,5,6,7,#]

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。
序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

示例 2:

输入：root = []

输出：[]

提示：

树中节点的数量在 [0, 212 - 1] 范围内
-1000 <= node.val <= 1000

代码

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }
        
        Node leftmost = root;
        
        while (leftmost.left != null) {
            Node head = leftmost;
            
            while (head != null) {
                head.left.next = head.right;
                
                if (head.next != null) {
                    head.right.next = head.next.left;
                }
                
                head = head.next;
            }
            
            leftmost = leftmost.left;
        }
        
        return root;
    }
}

思路分析

首先判断根节点是否为空，若为空则直接返回null。
定义一个变量leftmost表示当前层的最左节点，初始化为根节点。
进入循环，条件是当前层的最左节点的左子节点不为空（即还有下一层）。
在循环中，定义一个指针head指向当前层的头节点，即leftmost。
在当前层内部循环中，首先将当前节点的左子节点的next指针指向右子节点，即head.left.next = head.right。
然后判断当前节点的next是否为空，若不为空，则将当前节点的右子节点的next指针指向当前节点的next左子节点，即head.right.next = head.next.left。
更新head指针，使其指向当前节点的next，继续处理下一个节点。
一轮循环结束后，将leftmost指向下一层的最左节点，即leftmost = leftmost.left。
重复执行步骤3到步骤8，直到所有层都处理完毕。
返回根节点。

填充每个节点的下一个右侧节点指针||

来源：力扣（LeetCode）链接：leetcode.cn/problems/po…

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

示例 1：

图片.png

输入：root = [1,2,3,4,5,null,7]

输出：[1,#,2,3,#,4,5,7,#]

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。

示例 2：

输入：root = []

输出：[]

提示：

树中的节点数在范围 [0, 6000] 内
-100 <= Node.val <= 100

进阶：

你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序的隐式栈空间不计入额外空间复杂度。

代码

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }
        
        Node curr = root;
        Node dummy = new Node(0);
        Node prev = dummy;
        
        while (curr != null) {
            if (curr.left != null) {
                prev.next = curr.left;
                prev = prev.next;
            }
            
            if (curr.right != null) {
                prev.next = curr.right;
                prev = prev.next;
            }
            
            curr = curr.next;
            
            if (curr == null) {
                curr = dummy.next;
                dummy.next = null;
                prev = dummy;
            }
        }
        
        return root;
    }
}

思路分析

首先判断根节点是否为空，若为空则直接返回null。
定义三个指针curr、dummy和prev，初始化curr为根节点，dummy为一个哑节点，prev为哑节点。
进入循环，条件是curr不为空。
在循环中，首先判断当前节点的左子节点是否存在，若存在，则将prev的next指针指向左子节点，并更新prev为左子节点。
接着判断当前节点的右子节点是否存在，若存在，则将prev的next指针指向右子节点，并更新prev为右子节点。
更新curr指针，使其指向当前节点的下一个节点。
若curr为空，则说明当前层的节点已经处理完毕，将curr指针指向下一层的起始节点，即dummy.next，并将dummy.next置为null，同时将prev指针重置为哑节点。
重复执行步骤3到步骤7，直到所有节点都被处理完毕。
返回根节点。

力扣深度优先搜索练习题（填充每个节点的下一个右侧节点指针、填充每个节点的下一个右侧节点指针||）

填充每个节点的下一个右侧节点指针

代码

思路分析

填充每个节点的下一个右侧节点指针||

代码

思路分析