和二叉树相伴的美好时光~@labuladong Day4 - 构造

文章目录

  • 写在前面
  • 二叉树思考学习记录
    • Day4 二叉树的构造
    • Day4 [练习](https://alidocs.dingtalk.com/document/edit?dentryKey=6nVlMBkawC4ZXXAq#%20%E3%80%8C%E7%AC%AC%E5%9B%9B%E5%A4%A9%E4%BD%9C%E4%B8%9A%E3%80%8D)
      • 1.1 [合并两个二叉树](https://leetcode-cn.com/problems/merge-two-binary-trees)
      • 1.2 [删除指定叶子节点](https://leetcode-cn.com/problems/delete-leaves-with-a-given-value)
      • 1.3 [二叉树剪枝](https://leetcode-cn.com/problems/binary-tree-pruning)
      • 2. [二叉树的序列化与反序列化](https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/)
      • 3.1 [从前序与中序遍历序列构造二叉树](https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)
      • 3.2 [从中序与后序遍历序列构造二叉树](https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/)
    • Day4 的思考与补充

写在前面

本篇全部集中在二叉树相关问题上,是参考东哥的思路进行的练习和思考。东哥有《labuladong 的算法小抄》以及宝藏微信公众号 labuladong,github 也有项目,自来水推荐购买和关注。

二叉树思考学习记录

Day4 二叉树的构造

  • 所有的迭代操作都可以改用递归形式来写;
  • 本篇重点围绕使用递归的方式、借助之前遍历二叉树的代码框架,来实现二叉树的增、删、改、造。(Φ皿Φ)吓人~

Day4 练习

我宣布我爱上了递归~ 1.x 这些问题我看了以前的提交都是写的 helper,现在直接在函数签名下面完成函数功能,感觉有点想“装”一下哈哈O(∩_∩)O

1.1 合并两个二叉树

看了以前的写法,思路也还是遍历,但是单独写的 helper。针对这个问题,可以直接使用原题函数签名。

    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        # 使用递归的形式,通过遍历的思路来合并两棵树
        # 本函数需要返回合并后的结果,此结果还需要一定要有指针来接收
        if not root1: return root2
        if not root2: return root1
        root1.val += root2.val
        root1.left = self.mergeTrees(root1.left, root2.left)
        root1.right = self.mergeTrees(root1.right, root2.right)
        return root1

1.2 删除指定叶子节点

    def removeLeafNodes(self, root: TreeNode, target: int) -> TreeNode:
        # 借助递归的形式,使用遍历二叉树的思路,来删除指定叶子节点
        # 没路了,原地折回
        if not root: return None
        #递归左右子树,一定要接收返回值
        root.left = self.removeLeafNodes(root.left, target)
        root.right = self.removeLeafNodes(root.right, target)
        # 目标出现,斩掉连接,撤退~
        if not root.left and not root.right and root.val == target:
            return None
        return root

1.3 二叉树剪枝

    def pruneTree(self, root: TreeNode) -> TreeNode:
        # 借助递归的形式,通过遍历二叉树,来完成指定剪枝
        # 到头儿了,往回拐
        if not root: return None
        # 递归左右子树,返回值要有人接
        root.left = self.pruneTree(root.left)
        root.right = self.pruneTree(root.right)
        # 目标出现,切掉,撤退~
        if not root.left and not root.right and root.val == 0:
            return None
        # 返回需要有人接的 root,root 而来,root 而去
        return root

2. 二叉树的序列化与反序列化

前序思路从前往后拿,依次是 root left 和 right;
后序思路从后往前拿,依次是 root right 和 left;
前序后序都可以用递归来做,理论上好像中序也可以类似思路,但是中序思路祖宗 root 藏木于林,我布吉岛它在哪儿,所以无法序列化;

前序:

	# 使用前序遍历的思路进行序列化和反序列化
    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
		# 需要额外定义函数来实现前序遍历序列化,空节点都为 '#'
        def my_serialize(root, res):
            if not root: 
                res.append('#')
                return 
            res.append(str(root.val))
            my_serialize(root.left, res)
            my_serialize(root.right, res)
            return res
        
        res = my_serialize(root, [])
        if not res: return ''
        return ','.join(res)

        

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if not data: return None
        res = collections.deque(data.split(','))
        # 需要额外定义函数来实现中序遍历反序列化
        # 要有返回值,还一定有人接
        def my_deserialize(res):
            if not res: return None
            cur = res.popleft()
            if cur == '#': return None
            root = TreeNode(int(cur))
            root.left = my_deserialize(res)
            root.right = my_deserialize(res)
            return root
        
        return my_deserialize(res)

中序:

    # 使用中序遍历的思路进行序列化和反序列化
    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        # 需要额外定义函数来实现中序遍历序列化,空节点都为 '#'
        def my_serialize(root, res):
            if not root: 
                res.append('#')
                return 
            my_serialize(root.left, res)
            res.append(str(root.val))
            my_serialize(root.right, res)
            return res
        
        res = my_serialize(root, [])
        if not res: return ''
        return ','.join(res)

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if not data: return None
        res = collections.deque(data.split(','))
        print(res)
        # 需要额外定义函数来实现中序遍历反序列化
        # 要有返回值,还一定有人接
        def my_deserialize(res):
            if not res: return None
            # 谁能告诉我根节点在哪里?没有人。
            # 那算了,溜了溜了,不干了
        #     cur = res.pop() 
        #     if cur == '#': return None
        #     root = TreeNode(int(cur))
        #     # 需要先重建右子树,再重建左子树
        #     root.right = my_deserialize(res)
        #     root.left = my_deserialize(res)
        #     return root
        
        # return my_deserialize(res)
        

后序:


	# 使用后序遍历的思路进行序列化和反序列化
    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        # 需要额外定义函数来实现后序遍历序列化,空节点都为 '#'
        def my_serialize(root, res):
            if not root: 
                res.append('#')
                return 
            my_serialize(root.left, res)
            my_serialize(root.right, res)
            res.append(str(root.val))
            return res
        
        res = my_serialize(root, [])
        if not res: return ''
        return ','.join(res)

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if not data: return None
        res = collections.deque(data.split(','))
        # 需要额外定义函数来实现后序遍历反序列化
        # 要有返回值,还一定有人接
        def my_deserialize(res):
            if not res: return None
            cur = res.pop()
            if cur == '#': return None
            root = TreeNode(int(cur))
            root.right = my_deserialize(res)
            root.left = my_deserialize(res)
            return root
        
        return my_deserialize(res)

3.1 从前序与中序遍历序列构造二叉树

关于计算左子树尺寸,你愿意计算右子树尺寸来做也完全可以。这个维护边界的样子和排序算法如出一辙。

    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        # 借助递归的形式,使用遍历二叉树的思路(反过来),构造二叉树
        # 因为过程中 preorder 和 inorder 完全没有变
        # 只是在不断维护左右子树在 preorder 和 inorder 中的区间,所以需要重新写个函数
        def my_build_tree(pre_start, pre_end, in_start, in_end):
            # 树为空啊,没有内容
            if pre_start > pre_end: return None
            # 根节点拿出来
            root = TreeNode(preorder[pre_start])
            # 借助中序遍历计算左子树的 size
            idx = inorder.index(root.val)
            left_tree_size = idx - in_start
            # 根节点下一个就是左子树的左边界,根据左子树 size 推出来右边界
            root.left = my_build_tree(pre_start + 1, pre_start + left_tree_size, in_start, idx - 1)
            # 左子树右边界下个位置就是右子树的左边界,它俩挨着坐的嘛
            root.right = my_build_tree(pre_start + left_tree_size + 1, pre_end, idx + 1, in_end)
            return root
        
        n = len(preorder)
        return my_build_tree(0, n - 1, 0, n - 1)

3.2 从中序与后序遍历序列构造二叉树

    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        # 借助递归的形式,使用遍历二叉树的思路(反过来),构造二叉树
        # 因为过程中 postorder 和 inorder 完全没有变
        # 只是在不断维护左右子树在 postorder 和 inorder 中的区间,所以需要重新写个函数
        def my_build_tree(post_start, post_end, in_start, in_end):
            # 树为空啊,没有内容
            if post_start > post_end: return None
            # 根节点拿出来
            root = TreeNode(postorder[post_end])
            # 借助中序遍历计算左子树的 size
            idx = inorder.index(root.val)
            left_tree_size = idx - in_start
            # 左子树左边界还是在最前面不变,根据左子树 size 推出来右边界
            root.left = my_build_tree(post_start, post_start + left_tree_size - 1, in_start, idx - 1)
            # 左子树右边界下个位置就是右子树的左边界,它俩挨着坐的嘛,然后右边界不能触碰爸爸 root
            root.right = my_build_tree(post_start + left_tree_size, post_end - 1, idx + 1, in_end)
            return root
        
        n = len(postorder)
        return my_build_tree(0, n - 1, 0, n - 1)

Day4 的思考与补充

Leetcode 的层序遍历,一个屏幕放不下,幸好我还有个竖屏~
从老到少按辈分都依次装进麻袋;
另外一头开个口子,老祖宗先出来,然后依次在麻袋口守着等自己孩子;
领完的就走了,当上一个辈分正好都领完,麻袋边上排队的正好是下一个辈分。

    # 使用层序遍历的思路进行序列化和反序列化
    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        # 需要额外定义函数来实现层序遍历序列化,空节点都为 '#'
        if not root: return ''
        res = [str(root.val)]
        que = collections.deque()
        que.append(root)
        
        while que:
            le = len(que)
            temp = []
            has_node = False
            for i in range(le):
                cur = que.popleft()
                if not cur.left: 
                    temp.append('#')
                else:
                    has_node = True
                    temp.append(str(cur.left.val))
                    que.append(cur.left)
                if not cur.right:
                    temp.append('#')
                else:
                    has_node = True
                    temp.append(str(cur.right.val))
                    que.append(cur.right)
            # 全为空节点的最后一层不配进家谱
            if has_node: res.extend(temp)
        return ','.join(res)


    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if not data: return None
        res = collections.deque(data.split(','))
        root = TreeNode(int(res.popleft()))

        level_que = collections.deque()
        level_que.append(root)
        # 从老到少都依次在队里了,现在一个个拿出来
        # 之前已出队的非空节点才有孩子可以领
        while res:
            parent = level_que.popleft()
            left = res.popleft()
            if left == '#':
                parent.left = None
            else:
                parent.left = TreeNode(int(left))
                level_que.append(parent.left)
            
            right = res.popleft()
            if right == '#':
                parent.right = None
            else:
                parent.right = TreeNode(int(right))
                level_que.append(parent.right)
        return root


你可能感兴趣的:(算法,二叉树,算法)