Leetcode——初级部分——树部分——Python实现

最新推荐文章于 2022-02-25 17:03:02 发布

dta0502

最新推荐文章于 2022-02-25 17:03:02 发布

阅读量488

点赞数

分类专栏： Leetcode 文章标签： Python Leetcode 树

本文链接：https://blog.csdn.net/dta0502/article/details/80753612

版权

Leetcode 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一.二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

我的解答：

如果根节点为空，则深度为0，返回0，递归的出口

如果根节点不为空，那么深度至少为1，然后我们求他们左右子树的深度

比较左右子树深度值，返回较大的那一个

通过递归调用

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        left = 1
        right = 1
        if not root:
            return 0
        else:
            left = left + self.maxDepth(root.left)
            right = right + self.maxDepth(root.right)
            if left >= right:
                return left
            else:
                return right

二.验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1:

输入:
    2
   / \
  1   3
输出: true

示例 2:

输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。

我的解答：

1.这个解答有问题——忽略了隔层之间可能存在不符合规定的可能性

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        #根节点为None的情况——返回True
        if not root:
            return True
        else:
            #没有叶子结点，搜索到了终点，返回True
            if not root.left and not root.right:
                return True
            #没有左边结点、右边结点满足二叉搜索树条件情况
            elif not root.left:
                if root.right.val > root.val:
                    return self.isValidBST(root.right)
                else:
                    return False
            #没有右边结点、左边结点满足二叉搜索树条件情况
            elif not root.right:
                if root.left.val < root.val:
                    return self.isValidBST(root.left)
                else:
                    return False
            #左右结点均满足二叉搜索树条件情况
            elif root.left.val < root.val and root.right.val > root.val:
                return self.isValidBST(root.left) and self.isValidBST(root.right)
            #左右结点只要有一个不满足二叉搜索树情况
            else:
                return False

2.正确的解答

从上往下比较，每个节点往左就是最大，往右就是最小值

传输过程中原函数不能够传递最大最小值，又重新定义了一个函数调用

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.isValidBST_f2(root,-2**32,2**32-1)
        
    #从上往下比较，每个节点往左就是最大，往右就是最小值
    #传输过程中原函数不能够传递最大最小值，又重新定义了一个函数调用
    def isValidBST_f2(self,root,small,large):
        if not root:
            return True
        elif root.val >= large or root.val <= small:
            return False
        else:
            return self.isValidBST_f2(root.left,small,root.val) and self.isValidBST_f2(root.right,root.val,large)

三.对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

我的解答：

这里将根节点的左右节点假设成两颗独立的树，这样解题跟题目100就是类似的了,区别：递归调用时，因是对称，所以是左树左节点与右树右节点，左树右节点与右树左节点

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        #这里将根节点的左右节点假设成两颗独立的树，这样解题跟100就是类似的了,区别：递归调用时，因是对称，所以是左树左节点与右树右节点，左树右节点与右树左节点 
        #定义
        def isSameTree(p,q):
            if not p and not q: #左右数均为空，返回True
                return True
            elif p and q and p.val == q.val: #递归，每次重新从函数入口处进行，每次进行递归边界判断  
                l = isSameTree(p.left,q.right)
                r = isSameTree(p.right,q.left)
                return l and r
            else:
                return False
        #调用
        if not root:
            return True
        else:
            return isSameTree(root.left,root.right)

四.二叉树的层次遍历

给定一个二叉树，返回其按层次遍历的节点值。（即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

我的解答：

广度优先搜索BFS实现

队列：用一个队列，把当前点加进去，从这个点开始尝试所有可能的方向，尝试完以后把这个点出队，然后对还在队里的点（也就是刚才入队的点）继续同样的步骤，直到达到目的。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        #广度优先搜索BFS实现（队列：用一个队列，把当前点加进去，从这个点开始尝试所有可能的方向，尝试完以后把这个点出队，然后对还在队里的点（也就是刚才入队的点）继续同样的步骤，直到达到目的。）
        if not root:
            return []
        
        queue = [root]
        node = []
        res = []
        
        while queue:
            nodes = []
            node_value = []
            
            #下面是把这一层的所有节点的值全部取出来(放入到node_value中)、并且把子节点全部求出来(放入到nodes中)
            for node in queue:
                if node.left:
                    nodes.append(node.left)
                if node.right:
                    nodes.append(node.right)
                node_value = node_value + [node.val]
            
            queue = nodes #子节点存储到queue变量中
            res.append(node_value) #节点的值保存在res变量中
        
        return res

五.将有序数组转换为二叉搜索树

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

我的解答：

本质上是运用二分查找法！

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if not nums:
            return None
        mid = len(nums)//2 #得到中点
        root = TreeNode(nums[mid]) #root为树的根节点
        #下面是递归过程（左子树和右子树继续二分得到中间值）
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:]) #这里注意——中间节点已经给了root了，所以从mid+1开始
        return root

dta0502

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Leetcode——初级部分——树部分——Python实现

一.二叉树的最大深度给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7返回它的最大深度 3 。我的解答：如果根节点为空，则深度为0，返回0，递归的出口如果根节点不为空，那么深度至少...
复制链接

扫一扫