二刷 leetcode (10)

最新推荐文章于 2023-03-27 23:50:16 发布

凌疯墨子

最新推荐文章于 2023-03-27 23:50:16 发布

阅读量241

点赞数

分类专栏： python 文章标签：二叉树最大深度验证二叉搜索树验证二叉对称树二叉树层次遍历将有序数组转换为二叉搜索树

本文链接：https://blog.csdn.net/annilingmo/article/details/81030958

版权

python 专栏收录该内容

64 篇文章 2 订阅

订阅专栏

104. 二叉树的最大深度

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

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

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

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

返回它的最大深度 3 。

代码：递归找出左右子树的最大深度

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

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        #### the first method
        if root is not None:
            return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
        else:
            return 0
        
        
        #### the second method
        if root is None:
            return 0
        leftDepth=self.maxDepth(root.left)+1
        rightDepth=self.maxDepth(root.right)+1
        return max(leftDepth,rightDepth)

98. 验证二叉搜索树

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

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

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

示例 1:

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

示例 2:

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

代码：

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

class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        ### the first method
        def boolean_SearchTree(root, min, max):
            if root == None:
                return True
            if root.val <= min or root.val >=max:
                return False
            return boolean_SearchTree(root.left, min, root.val) and boolean_SearchTree(root.right, root.val, max)
        return boolean_SearchTree(root, -2**63, 2**63-1)
        
        #### the second method
        def inorderTraversal(root, inorder):
            if root:
                inorderTraversal(root.left, inorder)
                inorder.append(root.val)
                inorderTraversal(root.right, inorder)
        
        if root is None:
            return True
        inorder = []
        inorderTraversal(root, inorder)
        for i in range(len(inorder) - 1):
            if inorder[i] >= inorder[i+1]:
                return False
        return True
        
    
        #### 非递归方法
        stack = [] 
        pre = None
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            if root:
                node = stack.pop()
                if pre ==None or node.val > pre.val:
                    pre = node
                else:
                    if node.val <= pre.val:
                        return False
                root = root.right
        return True

101. 对称二叉树

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

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

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

代码：

class Solution2(object):
    """
    两种辅助函数
    """
    def recursive(self, left, right):
        if left is None and right is None:
            return  True
        if left is None or right is None:
            return False
        if left.val == right.val:
            return self.recursive(left.left, right.right) and self.recursive(left.right, right.left)
        return False

    def Help(self, L, R):
        if not L and not R:
            return True
        elif L and R and L.val == R.val:
            return self.Help(L.left, R.right) and self.Help(L.right, R.left)
        else:
            return False


    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root is None:
            return True
        else:
            return self.recursive(root.left, root.right)

102. 二叉树的层次遍历

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

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

返回其层次遍历结果：

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

代码：

class Solution3:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

        #### the first method

        # if root is None:
        #     return []
        # res = []
        # queue = [root]
        # while queue:
        #     nodes = []
        #     values = []
        #     for node in queue:
        #         if node.left:
        #             nodes.append(node.left)
        #         if node.right:
        #             nodes.append(node.right)
        #         values += [node.val]
        #     res += [values]
        #     queue = nodes
        # return res

        #### the second method
        res = []
        if root is None:
            return res
        res.append([root.val])
        queue = [root]
        while queue and queue[0]:
            level = []
            count = len(level)
            for i in range(count):
                node = queue.pop(0)
                if node.left:
                    queue.append([root.left])
                    level.append(node.left.val)
                if node.right:
                    queue.append([root.right])
                    level.append(node.right.val)
            if level:
                res.append(level)
        return res

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

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

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

示例:

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

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

      0
     / \
   -3   9
   /   /
 -10  5

代码：

class Solution4(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        ### the first method
        if len(nums) == 0:
            return None
        mid = len(nums) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1 :])
        return root

        #### the second method 
        if not nums:
            return None

        def insert(nums, l, r):
            if l > r:
                return None
            m = (l + r) // 2
            newNode = TreeNode(nums[m])
            newNode.left = insert(nums, l, m - 1)
            newNode.right = insert(nums, m + 1, r)
            return newNode

        return insert(nums, 0, len(nums) - 1)

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

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

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

说明:

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

凌疯墨子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二刷 leetcode (10)

104. 二叉树的最大深度给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7返回它的最大深度 3 。代码：递归找出左右子树的最大深度# Definition for a binar...
复制链接

扫一扫