Leetcode 刷题第14天 |226,101,104,111

一只AI学习小朋友

已于 2023-09-06 20:00:41 修改

阅读量36

点赞数

分类专栏： Leetcode刷题文章标签： leetcode 算法 python

于 2023-09-05 15:57:17 首次发布

本文链接：https://blog.csdn.net/m0_46690443/article/details/132691474

版权

Leetcode刷题专栏收录该内容

23 篇文章 0 订阅

订阅专栏

Leetcode 226 翻转二叉树

题目：

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例 1：
示例1
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
示例 2：
示例2
输入：root = [2,1,3]
输出：[2,3,1]
示例 3：
输入：root = []
输出：[]
提示：

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

算法思想：

首先要明确使用哪种遍历方式，前序遍历为“中左右”，后序遍历为“左右中”，中序遍历为“左中右”，层次遍历是逐层遍历。
这么多的遍历方式我们要选哪一种？经过思考可以知道，前序遍历和后序遍历都是在“边界”上访问根节点，访问根节点就是我们要处理的逻辑。因此无论是先交换后处理，还是先处理后交换都是可以的。但中序遍历是不可行的，因为，当遍历到“中”节点的时候，左子树已经全部交换完毕。这时要交换左右子树，交换后再遍历右子树，这时可以发现，有的子树被遍历两次，而有的子树却没有被遍历过。对于层次遍历，每次出栈节点都交换左右子树，交换完毕后再入栈左右孩子节点，这样并不会产生类似中序遍历的问题。

代码实现：

递归法

# 定义树的结构体
class TreeNode:
    def __init__(self, val=0, right=None, left=None) -> None:
        self.val = val
        self.right = right
        self.left = left

# 递归方式, 先序遍历
class Solution:
    def invertTree(self, root):
        if not root:
            return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)

        return root
    
# 递归方式，中序遍历
class Solution:
    def invertTree(self, root):
        if not root:
            return None
        # 虽然原始中序遍历不行，但经过改造也是可以的
        self.invertTree(root.left)
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        return root
    
# 递归方式，后序遍历
class Solution:
    def invertTree(self, root):
        if not root:
            return None
        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left
        return root

迭代法

# 定义二叉树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

# 先序遍历
class Solution:
    def invertTree(self, root):
        if not root:
            return None
        stack = [root]
        while stack:
            node = stack.pop()
            node.left, node.right = node.right, node.left
            if node.left != None:
                stack.append(node.left)
            if node.right != None:
                stack.append(node.right)
            
        return root

# 后序遍历
class Solution:
    def invertTree(self, root):
        if not root:
            return None
        stack = [root]
        while stack:
            node = stack.pop()
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
            node.left, node.right = node.right, node.left
        return root

# 中序遍历
class Solution:
    def invertTree(self, root):
        if not root:
            return None
        stack = [root]
        while stack:
            node = stack.pop()
            if node.left:
                stack.append(node.left)
            node.left, node.right = node.left, node.right
            if node.left:
                stack.append(node.left)
        return root

层次遍历法

# 定义树的结构
import collections
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def invertTree(self, root):
        if not root:
            return None
        queue = collections.deque([root])
        while queue:
            for _ in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left:
                    queue.append(node.left) 
                if node.right:
                    queue.append(node.right)
        return root

Leetcode 101 对称二叉树

题目：

给你一个二叉树的根节点 root ，检查它是否轴对称。
示例 1：
示例1
输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
示例2
输入：root = [1,2,2,null,3,null,3]
输出：false

提示：

树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

算法思想：

对于递归算法，本题采用“后序遍历”思想，但并非原始二叉树后序遍历的操作。很多人可能会问了？先序遍历可以么？中序遍历可以么？层次遍历可以么？对于非递归算法，本题采用层次遍历的思想。

代码实现：

递归法

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        return self.compare(root.left, root.right)
        
    def compare(self, left, right):
        #首先排除空节点的情况
        if left == None and right != None: return False
        elif left != None and right == None: return False
        elif left == None and right == None: return True
        #排除了空节点，再排除数值不相同的情况
        elif left.val != right.val: return False
        
        #此时就是：左右节点都不为空，且数值相同的情况
        #此时才做递归，做下一层的判断
        outside = self.compare(left.left, right.right) #左子树：左、 右子树：右
        inside = self.compare(left.right, right.left) #左子树：右、 右子树：左
        isSame = outside and inside #左子树：中、 右子树：中 （逻辑处理）
        return isSame

迭代法（使用队列）

import collections
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left) #将左子树头结点加入队列
        queue.append(root.right) #将右子树头结点加入队列
        while queue: #接下来就要判断这这两个树是否相互翻转
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if not leftNode and not rightNode: #左节点为空、右节点为空，此时说明是对称的
                continue
            
            #左右一个节点不为空，或者都不为空但数值不相同，返回false
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            queue.append(leftNode.left) #加入左节点左孩子
            queue.append(rightNode.right) #加入右节点右孩子
            queue.append(leftNode.right) #加入左节点右孩子
            queue.append(rightNode.left) #加入右节点左孩子
        return True

迭代法（使用栈）

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        st = [] #这里改成了栈
        st.append(root.left)
        st.append(root.right)
        while st:
            rightNode = st.pop()
            leftNode = st.pop()
            if not leftNode and not rightNode:
                continue
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            st.append(leftNode.left)
            st.append(rightNode.right)
            st.append(leftNode.right)
            st.append(rightNode.left)
        return True

迭代法（层次遍历思想）

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque([root.left, root.right])
        while queue:
            level_size = len(queue)
            
            if level_size % 2 != 0:
                return False
            
            level_vals = []
            for i in range(level_size):
                node = queue.popleft()
                if node:
                    level_vals.append(node.val)
                    queue.append(node.left)
                    queue.append(node.right)
                else:
                    level_vals.append(None)
                    
            if level_vals != level_vals[::-1]:
                return False
        return True

Leetcode 104 求二叉树的最大深度

题目：

给定一个二叉树 root ，返回其最大深度。
二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。
示例 1：
示例1
输入：root = [3,9,20,null,null,15,7]
输出：3
示例 2：
输入：root = [1,null,2]
输出：2
提示：

树中节点的数量在 [0, $10^4$ ] 区间内
-100 <= Node.val <= 100

算法思想：

通常使用先序遍历求深度，使用后序遍历求高度。但最大深度与高度相同，所以用后序遍历求的高度也就是先序遍历的深度。

代码实现：

递归法

class solution:
    def maxdepth(self, root: treenode) -> int:
        return self.getdepth(root)
        
    def getdepth(self, node):
        if not node:
            return 0
        leftheight = self.getdepth(node.left) #左
        rightheight = self.getdepth(node.right) #右
        height = 1 + max(leftheight, rightheight) #中
        return height

非递归法（层次遍历法）

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        depth = 0
        queue = collections.deque([root])
        
        while queue:
            depth += 1
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return depth

Leetcode 111 求二叉树的最小深度

题目：

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例 1：
示例1
输入：root = [3,9,20,null,null,15,7]
输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5
提示：

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

算法思想：

本题要与最大深度区分开，并不是在最大深度的递归实现上简单改一改就行的。如果某棵二叉树只有右子树，左子树为None，就会出现问题？

代码实现：

递归法

class Solution:
    def getDepth(self, node):
        if node is None:
            return 0
        leftDepth = self.getDepth(node.left)  # 左
        rightDepth = self.getDepth(node.right)  # 右
        
        # 当一个左子树为空，右不为空，这时并不是最低点
        if node.left is None and node.right is not None:
            return 1 + rightDepth
        
        # 当一个右子树为空，左不为空，这时并不是最低点
        if node.left is not None and node.right is None:
            return 1 + leftDepth
        
        result = 1 + min(leftDepth, rightDepth)
        return result

    def minDepth(self, root):
        return self.getDepth(root)

非递归法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        depth = 0
        queue = collections.deque([root])
        
        while queue:
            depth += 1 
            for _ in range(len(queue)):
                node = queue.popleft()
                
                if not node.left and not node.right:
                    return depth
            
                if node.left:
                    queue.append(node.left)
                    
                if node.right:
                    queue.append(node.right)
        return depth

一只AI学习小朋友

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Leetcode 刷题第14天 |226,101,104,111

经过思考可以知道，前序遍历和后序遍历都是在“边界”上访问根节点，访问根节点就是我们要处理的逻辑。这时要交换左右子树，交换后再遍历右子树，这时可以发现，有的子树被遍历两次，而有的子树却没有被遍历过。对于层次遍历，每次出栈节点都交换左右子树，交换完毕后再入栈左右孩子节点，这样并不会产生类似中序遍历的问题。首先要明确使用哪种遍历方式，前序遍历为“中左右”，后序遍历为“左右中”，中序遍历为“左中右”，层次遍历是逐层遍历。输入：root = [2,null,3,null,4,null,5,null,6]
复制链接

扫一扫