【LeetCode专题】树、二叉树、二叉搜索树

最新推荐文章于 2021-11-13 23:51:40 发布

置顶

アナリスト

最新推荐文章于 2021-11-13 23:51:40 发布

阅读量256

点赞数

文章标签： python LeetCode 树二叉树 BST

本文链接：https://blog.csdn.net/fearlesslpp/article/details/103294929

版权

这篇博客深入探讨了LeetCode中与树、二叉树和二叉搜索树相关的算法问题，包括中序、层次和锯齿形遍历，对称、平衡和最大深度判断，以及二叉搜索树的插入、删除和最近公共祖先等操作。文章通过实例讲解了递归和非递归的解决方案，并提供了详细的代码实现。

摘要由CSDN通过智能技术生成

LeetCode94 二叉树的中序遍历

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        reslist=[]
        def inorder(root):
            if not root:
                return
            inorder(root.left)
            reslist.append(root.val)
            inorder(root.right)
        inorder(root)
        return reslist

中序遍历的递归实现，和先序遍历、后序遍历非常类似。
ToDo：非递归实现

LeetCode102 二叉树的层次遍历

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res=[] #2维数组
        def dfs(root,depth):
            if not root:
                return
            if depth>=len(res):
                res.append([])
            res[depth].append(root.val)
            dfs(root.left,depth+1)
            dfs(root.right,depth+1)
        
        dfs(root,0)
        return res

同一层（depth相同）的节点放到同一个list中，利用dfs实现，从root开始一直往‘左臂’前进，当depth大于等于二维数组长度，就对二维数组创建新的元素（一维数组），将节点值存入新创建的list，‘左下角’到底之后，递归栈回退，将右节点的值插入和它同一层的list中，然后回退，直到遍历完整个树，结果就保存到了二维数组中。本质上是一种‘先序’遍历。

LeetCode103 二叉树的锯齿形层次遍历

class Solution(object):
    def zigzagLevelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        reslist=[]
        def dfs(root,depth):
            if not root:
                return
            if depth==len(reslist):
                reslist.append([])
            if depth%2==0:
                reslist[depth].append(root.val)
            else:
                reslist[depth].insert(0,root.val)
            dfs(root.left,depth+1)
            dfs(root.right,depth+1)
        dfs(root,0)
        return reslist

锯齿形层次遍历和一般层次遍历区别是，需要对depth的奇偶性进行判断，若是偶数，则插入到list的末尾，反之插入到list的开头。

LeetCode101 对称二叉树

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def check(node1, node2):
            if not node1 and not node2:
                return True
            elif not node1 or not node2:
                return False
            if node1.val != node2.val:
                return False
            return check(node1.left,node2.right) and check(node1.right,node2.left)
        
        return check(root, root)

方法很巧妙，定义辅助函数check，判断两个树node1、node2是否对称。当两树都是空树，对称返回True；反之至少一个非空，假如有一个是空，那么就是一空一非空，返回False；反之都是非空，但是值不相同，也返回False；反之值也相同，那么就看‘node1的左子树和node2的右子树是否对称’，以及‘node1的右子树和node2的左子树是否对称’，这两者必须同时满足。最后调用check，两个节点都设为root，仔细去体会。

LeetCode104 二叉树的最大深度

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

代码非常简单，若当前根节点为空，返回0，否则，返回当前根节点的左右孩子的深度较大值再加一。

LeetCode100 相同的树

class Solution(object):

    def isSameTree(self, p, q):
        """
        :type p: TreeNode
        :type q: TreeNode
        :rtype: bool
        """
        if not p and not q:
            return True
        if p and q and p.val==q.val:
            return self.isSameTree(p.left, q.left) and  self.isSameTree(p.right, q.right)
        else:
            return False

代码很简单，若两树都为空，则是相同的；若两树都不为空，且根节点值相同，则看两树的左孩子与左孩子，右孩子与右孩子是否各自相同，且二者必须都相同；其他情况都是不相同。

LeetCode98 验证二叉搜索树

class Solution(object):
    lastV=-2**32
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        if self.isValidBST(root.left):
            if self.lastV<root.val:
                self.lastV=root.val
                return self.isValidBST(root.right)
        return False

二叉搜索树的中序遍历是升序排序；因此，可以在中序遍历的过程中，查看是否满足升序，即当前元素是否总比上一个遍历的元素大，为此用lastV记录上一个遍历的值；（注意：空树一定是二叉搜索树，它作为递归退出条件）然后先看左子树是否是二叉搜索树，如果不是，直接返回False；反之如果是，再看当前节点值是否比lastV大，如果不是，也直接返回False；如果是，那么先记录当前值root.val给lastV，然后再看右子树是否是二叉搜索树。

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

class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        def myfun(nums,l,r