【LeetCode 116、117】填充每个节点的下一个右侧节点指针

最新推荐文章于 2020-10-05 14:49:15 发布

oyall520

最新推荐文章于 2020-10-05 14:49:15 发布

阅读量125

点赞数

文章标签：二叉树指针队列

本文链接：https://blog.csdn.net/oyall520/article/details/104880121

版权

一、【LeetCode 116】填充每个节点的下一个右侧节点指针

1. 题目描述

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

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

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

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

示例：
在这里插入图片描述

**输入：**{"$id":"1","left":{"$id":"2","left":{"$id":"3","left":null,"next":null,"right":null,"val":4},"next":null,"right":{"$id":"4","left":null,"next":null,"right":null,"val":5},"val":2},"next":null,"right":{"$id":"5","left":{"$id":"6","left":null,"next":null,"right":null,"val":6},"next":null,"right":{"$id":"7","left":null,"next":null,"right":null,"val":7},"val":3},"val":1}

**输出：**{"$id":"1","left":{"$id":"2","left":{"$id":"3","left":null,"next":{"$id":"4","left":null,"next":{"$id":"5","left":null,"next":{"$id":"6","left":null,"next":null,"right":null,"val":7},"right":null,"val":6},"right":null,"val":5},"right":null,"val":4},"next":{"$id":"7","left":{"$ref":"5"},"next":null,"right":{"$ref":"6"},"val":3},"right":{"$ref":"4"},"val":2},"next":null,"right":{"$ref":"7"},"val":1}

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。

2.第一种方法（层次遍历）

核心思想：利用树的广度优先遍历（BFS）

树的广度优先遍历（也即层次遍历）基于节点的层级 level 概念。一个节点的层级取决于该节点的深度或者到根节点的距离。需要先遍历完同一层级的所有节点，才能进入下一层级。使用广度优先遍历，可以将同一层级的所有节点连接起来。
（1）首先导入deque函数，使用该函数创建一个双端队列；
（2）然后判空，若树不存在，直接返回None即可；若存在，直接将根节点添加进双端队列queue中，因为第 0 层级只有一个节点，不需要建立连接，直接进入 while 循环即可。
（3）外层while 循环迭代的是树的层级，内部的 for 循环迭代的是一个层级上所有的节点。由于可以访问同一层级的所有节点，因此能够建立指针连接。
（4）for 循环弹出一个节点时，同时把它的孩子节点加入队列。因此队列中每个层级的元素也是顺序存储的。可以通过已有的顺序建立 next 指针。【只要没有遍历到最后一个节点，都可以通过node.next = queue[0]来建立指针连接；当遍历到最后一个节点时，node的next指向空，所以此时为node.next = None】
***注意： for 循环弹出一个节点时，同时把它的孩子节点加入队列。所以判断当前节点的孩子节点是否存在的两个if语句一定要在for循环里面，否则就相当于遍历到最后一个节点，退出for循环时，判断该节点的孩子节点是否存在，这样就出错了！

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
from collections import deque
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return None
        queue = deque([root])
        
        while queue:
            n = len(queue)
            for i in range(0, n):
                node = queue.popleft()
                if i < n - 1:
                    node.next = queue[0]
                elif i == n - 1:
                    node.next = None
            
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root

3.第二种方法（使用已建立的next指针）——充分利用完美二叉树的性质

一棵树里有两种类型的指针：

两个子节点连接同一个父节点，可通过该父节点直接访问这两个节点：

建立连接的形式如右：node.left.next = node.right
两个子节点连接的不是同一个父节点，这种情况不能直接连接。连接的是第一个父节点的右孩子和第二父节点的左孩子。由于已经在父节点这一层建立了 next 指针，因此可以直接通过第一个父节点的 next 指针找到第二个父节点，然后在它们的孩子之间建立连接。

建立连接的形式如右：node.right.next = node.next.left

完成当前层的连接后，进入下一层重复操作，直到所有的节点全部连接。进入下一层后需要更新最左节点，然后从新的最左节点开始遍历该层所有节点。 因为是完美二叉树，因此最左节点一定是当前层最左节点的左孩子。 如果当前最左节点的左孩子不存在，说明已经到达该树的最后一层，完成了所有节点的连接。

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
from collections import deque
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return root
        
        # 从根节点开始，第一层上不需要建立next指针
        leftmost = root
        
        # 一旦到达最后一层，就退出循环
        while leftmost.left:
            
            # 使用next指针从头节点开始迭代“链表”，并和下一层建立相应的连接
            head = leftmost
            while head:
                
                # 连接的第一种情况：两个子节点连接同一个父节点
                head.left.next = head.right
                
                # 连接的第二种情况：两个子节点不是连接同一个父节点
                if head.next:
                    head.right.next = head.next.left
                
                # 沿着当前层的节点一路建立连接
                head = head.next
            
            # 移到下一层
            leftmost = leftmost.left
        
        return root

二、【LeetCode 117】填充每个节点的下一个右侧节点指针II

1.题目描述

给定一个二叉树

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

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

初始状态下，所有 next 指针都被设置为 NULL。
在这里插入图片描述
输入： root = [1,2,3,4,5,null,7]
输出： [1,#,2,3,#,4,5,7,#]
解释： 给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。

2.代码

这题和上一题的区别就在于本题是一个二叉树，不是完美二叉树，也就意味着相邻层不同父节点的的子节点没有关系可寻，就不能使用树已有的next指针了。但是层次遍历依旧管用，思路一模一样，代码也是原封不动！

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
from collections import deque
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return None
        queue = deque([root])
        while queue:
            n = len(queue)
            for i in range(n):
                node = queue.popleft()
                if i < n - 1:
                    node.next = queue[0]
                elif i == n - 1:
                    node.next = None
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root

oyall520

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【LeetCode 116、117】填充每个节点的下一个右侧节点指针

一、【LeetCode 116】填充每个节点的下一个右侧节点指针1. 题目描述给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：struct Node {int val;Node *left;Node *right;Node *next;}填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 nex...
复制链接

扫一扫