【python】Leetcode（Tree）

最新推荐文章于 2022-02-25 17:03:02 发布
最新推荐文章于 2022-02-25 17:03:02 发布
阅读量323 收藏
点赞数 1
分类专栏： Python 文章标签： Leetcode tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bryant_meng/article/details/100610109
版权

文章目录

104. 二叉树的最大深度（递归最大深度）

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

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

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

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

      3
 / \
9  20
  /  \
 15   7

返回它的最大深度 3 。

递归左右子树，计算就可以，进一层，加1

# 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
        """
        if root == None:
            return 0
        else:
            l = self.maxDepth(root.left)+1
            r = self.maxDepth(root.right)+1
            return max(l,r)

111. 二叉树的最小深度（递归最大深度）

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

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

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

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

      3
 / \
9  20
  /  \
 15   7

返回它的最小深度 2.

还是和求最大深度的思路一样，只是 max 换成 min，但是要注意只有一个 方向的分支的情况！这个时候如果仅仅把 max 换成 min，会输出 1 的，显然不是我们想要的！为了避免这种情况，加了 if 讨论

# 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 minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root == None:
            return 0
        else:
            l = self.minDepth(root.left)+1
            r = self.minDepth(root.right)+1
            if l == 1: # 防止一个方向的二叉树
                return r
            elif r == 1:
                return l
            else:
                return min(l,r)

559. N叉树的最大深度（递归最大深度）

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

例如，给定一个 3叉树 :
在这里插入图片描述
我们应返回其最大深度，3。

  • 说明:
    树的深度不会超过 1000。
    树的节点总不会超过 5000。

这里的子树就不是 left 和 right 了，是 children，是一个列表，还是 DFS 那套

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val, children):
        self.val = val
        self.children = children
"""
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: Node
        :rtype: int
        """
        if root == None: # 空树
            return 0
        elif root.children == []: # 只有根节点
            return 1
        else: #递归个个子树，然后返回最深的结果
            return max(self.maxDepth(i) for i in root.children) + 1

注意，self.maxDepth(i) for i in root.children 如果写成 self.maxDepth(i for i in root.children) 就是 generator 了！

110. 平衡二叉树（递归最大深度）

给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

  • 示例 1:

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

      3
 / \
9  20
  /  \
 15   7

    返回 true 。

  • 示例 2:
    给定二叉树 [1,2,2,3,3,null,null,4,4]

         1
    / \
   2   2
  / \
 3   3
/ \
4   4

    返回 false 。

# 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 isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        # 递归算法从叶节点往根节点推
        # 先找到最后的叶子结点，从叶子结点开始一步步返回是否平衡
        if root == None:
            return True
        elif abs(self.height(root.left) - self.height(root.right)) > 1: # 根节点左右子树不平衡，false
            return False
        else: # 可能存在子树不平衡的情况，递归下去
            return self.isBalanced(root.left) and self.isBalanced(root.right)
        
    # 递归求树的最大深度
    def height(self, root):
        if root == None:
            return 0
        else:
            l = self.height(root.left) + 1
            r = self.height(root.right) + 1
            return max(l,r)

513. 找树左下角的值（递归 BFS）

给定一个二叉树，在树的最后一行找到最左边的值。

  • 示例 1:
    输入:

      2
 / \
1   3

输出:
1

  • 示例 2:

输入:

    1
   / \
  2   3
 /   / \
4   5   6
   /
  7

输出:
7

思路：树的层次遍历，每进入下一层，清空记录的值，返回最后一层的第一个元素

# 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 findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        root_list = [root] #第一层的根节点
        while(root_list):
            tmp_root_list = [] #每一层的根节点列表
            value = [] #记录元素的值，每一层都清空
            for node in root_list:
                if node.left:
                    tmp_root_list.append(node.left)
                if node.right:
                    tmp_root_list.append(node.right)
                value.append(node.val)
            root_list = tmp_root_list
        return value[0] # 返回最后一层的第一个元素

144. 二叉树的前序遍历（前序遍历）

给定一个二叉树，返回它的 前序 遍历。

示例:

输入: [1,null,2,3]

   1
    \
     2
    /
   3

输出: [1,2,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 preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        val = []
        if root == None:
            return val
        else:
            val.append(root.val)
            val.extend(self.preorderTraversal(root.left))
            val.extend(self.preorderTraversal(root.right))
        return val

589. N叉树的前序遍历（前序遍历）

给定一个 N 叉树，返回其节点值的前序遍历。

例如，给定一个 3叉树 :

在这里插入图片描述
返回其前序遍历: [1,3,5,6,2,4]。

1）递归

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val, children):
        self.val = val
        self.children = children
"""
class Solution(object):
    def preorder(self, root):
        """
        :type root: Node
        :rtype: List[int]
        """
        value = [] # 存放遍历后的值
        if root == None: # 为空返回 []
            return value
        else:
            value.append(root.val) # 保存根节点的值
            for node in root.children: # 遍历每个子节点，递归调用先序遍历
                value.extend(self.preorder(node))
        return value

2）迭代
bryant

94. 二叉树的中序遍历（中序遍历）

给定一个二叉树，返回它的中序 遍历。

示例:

输入: [1,null,2,3]

   1
    \
     2
    /
   3

输出: [1,3,2]

思路：调换一下前序遍历的顺序即可

# 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        val = []
        if root == None:
            return val
        else:
            val.extend(self.inorderTraversal(root.left))
            val.append(root.val)
            val.extend(self.inorderTraversal(root.right))
        return val

230. 二叉搜索树中第K小的元素（中序遍历）

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。

示例 1:

输入: root = [3,1,4,null,2], k = 1

   3
  / \
 1   4
  \
   2

输出: 1

思路：中序遍历二叉搜索树可以得到有序（从小到大）的结果，然后返回第 k 个值

# 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 kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        def inorderTraversal(root): # 定义中序遍历函数
            val = []
            if root == None:
                return val
            else:
                val.extend(inorderTraversal(root.left))
                val.append(root.val)
                val.extend(inorderTraversal(root.right))
            return val
        return inorderTraversal(root)[k-1]

145. 二叉树的后序遍历（后序遍历）

给定一个二叉树，返回它的 后序 遍历。

示例:

输入: [1,null,2,3]

   1
    \
     2
    /
   3

输出: [3,2,1]

思路：调整下前序遍历的顺序即可

# 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 postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        val = []
        if root == None:
            return val
        else:
            val.extend(self.postorderTraversal(root.left))
            val.extend(self.postorderTraversal(root.right))
            val.append(root.val)
        return val

590. N叉树的后序遍历（后序遍历）

给定一个 N 叉树，返回其节点值的后序遍历。

例如，给定一个 3叉树 :
在这里插入图片描述
返回其后序遍历: [5,6,3,2,4,1].

思路：在二叉树后续遍历的基础上，循环遍历 children 即可

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val, children):
        self.val = val
        self.children = children
"""
class Solution(object):
    def postorder(self, root):
        """
        :type root: Node
        :rtype: List[int]
        """
        val = []
        if root == None:
            return val
        else:
            for node in root.children:
                val.extend(self.postorder(node))
            val.append(root.val)
        return val

617. 合并二叉树（递归）

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:
在这里插入图片描述
注意: 合并必须从两个树的根节点开始。

# 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 mergeTrees(self, t1, t2):
        """
        :type t1: TreeNode
        :type t2: TreeNode
        :rtype: TreeNode
        """
        if t1 == None: #这两个判断很关键，弥补了二叉树形状不一样的情况
            return t2
        elif t2 == None:
            return t1
        else:
            t1.val = t1.val+t2.val # 根节点的值相加，保存在t1中
            t1.left = self.mergeTrees(t1.left,t2.left)# 递归左子树
            t1.right = self.mergeTrees(t1.right,t2.right)# 递归右子数
        return t1

注意不等长时候的处理！！！

bryant_meng
关注
专栏目录
leetcode树总结(python
weixin_42723548的博客
09-20 990
做题顺序：144、94、145、102、103、96、95、98、100、101、111、105、106、108、104、110、111、112、113 牛客网【二叉树的下一个节点】 写递归循环的时候，先想基线条件是什么，也就是当只有最简单的情况时（当没有节点或只有一个节点的时候），怎么处理，再想递归条件是什么（当有两个节点或者三个节点的时候）。这样就很容易写出来了，树这里用了很多的递归，都要...
<LeetCode>-Tree 练习 (Python)
JayWang1994的博客
07-05 432
做题之前，先把preorder, inorder 和 postorder的recursive和iterative实现一遍。 前序遍历： 递归实现 # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None...
leetcode-Tree-python
qq_22179091的博客
03-23 216
1、Same TreeGiven two binary trees, write a function to check if they are the same or not.Two binary trees are considered the same if they are structurally identical and the nodes have the same value.E...
Python leetcode tree记录
weixin_34124939的博客
04-24 237
本文记录下在使用刷Leetcode的一些记录，主要使用变成语言为Python3。 tree的定义： Python中二叉树的定义 class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None 复制代码其他编程语言常见的定义： 内存模...
Leetcode题解-数据结构-树（python版）
桑凯旋的博客
03-02 552
文章目录1、递归1.1 树的高度1.2 平衡树1.3 归并两棵树1.4 判断是否存在一条路径和等于一个数1.5 统计路径和等于某个数的路径总数1.6 子树1.7 判断树是否对称1.8 两节点间的最长路径1.9 翻转树1.10 最小路径1.11 统计左叶子结点的和1.12 相同节点的最大路径长度1.13 间隔层序遍历1.14 二叉树中第二小的结点2、层序遍历2.1 二叉树每层节点的平均值2.2 找树左下角的结点2.3 之字形打印二叉树3、前中后序遍历3.1 非递归实现二叉树前序遍历3.2 非递归实现二叉树中序
Python_leetcode.zip
07-04
《Python在LeetCode中的应用深度探索》 在编程学习与面试准备中，LeetCode是一个备受推崇的在线平台，它提供了大量的算法题目供程序员们练习和挑战。本资料包"Python_leetcode.zip"聚焦于Python语言在LeetCode上的...
python-leetcode题解之Binary Search Tree to Greater Sum Tree.py
最新发布
09-21
python python_leetcode题解之Binary Search Tree to Greater Sum Tree.py
python-leetcode题解之101-Symmetric-Tree
09-03
python python_leetcode题解之101_Symmetric_Tree
python-leetcode题解之100-Same-Tree
09-03
python python_leetcode题解之100_Same_Tree
python-leetcode题解之110-Balanced-Binary-Tree
09-04
python python_leetcode题解之110_Balanced_Binary_Tree
leetcodetreenode-leetcode_test:测试你的代码
07-01
leetcode 树节点leetcode 测试 仅使用适用于python 方便本地测试,ListNode和TreeNode类型 # filename leetcode.py from leetcode_test import TreeNode class Solution: def isSymmetric(self, root: TreeNode) -> bool: def symmetric(left, right): if not left and not right: return True if not left or not right: return False return ( left.val == right.val and symmetric(left.left, right.right) and symmetric(left.right, right.left) ) if not root: return True return symmetric(root.left, root.right) def test(): tree = TreeNode.create(
LeetCode (python实现) —— 树
HachiLin的博客
01-13 479
1. 难度：简单 104：二叉树的最大深度 题目描述 给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 例子 给定二叉树 [3,9,20,null,null,15,7]    3   /   \  9    20    /   \    15   7 返回它的最大深度3 ...
Leetcode——初级部分——树部分——Python实现
dta0502的博客
06-20 519
一.二叉树的最大深度给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7返回它的最大深度 3 。我的解答：如果根节点为空，则深度为0，返回0，递归的出口如果根节点不为空，那么深度至少...
【LeetCode】TreeNode类实现解析（java实现）
weixin_33830216的博客
10-15 790
2019独角兽企业重金招聘Python工程师标准>>> ...
leetcode 专题：树 python 版（持续更新中）
Yenpo Ma的博客
04-09 471
目录 二叉树的基础知识： 二叉树的遍历： 二叉搜索树： 堆： 红黑树： Leetcode 100 相同的树 101 对称二叉树 104 二叉树的最大深度 107 二叉树的层次遍历 || 108 将有序数组转换为二叉搜索树 110 平衡二叉树 111 二叉树的最小深度 112 路径总和 226 翻转二叉树 235 二叉搜索树的最近公共祖先 257 二叉树的所有路径 ...
leetcode | 按层访问一棵二叉树 | Python
u012560212的博客
06-14 803
题目： Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level). For example: Given binary tree [3,9,20,null,null,15,7], 3 /
Python实现与LeetCode--树
weixin_30667301的博客
06-27 532
Python实现与LeetCode--树 Python实现 二叉树： # @Time : 2019/7/2 10:50 # @Author : panky_pan # @File : Binary_Tree.py # @Software: PyCharm class BinaryTree(object): def __init__(self, root): self...
LeetCode刷题——树（python语言）
qq_26274961的博客
02-25 1876
LeetCode刷题——树（python语言） 一、树 二、刷题 2.1 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 。 解法一：利用DFS（深度优先搜索），每次向下遍历，深度加一。 设置变量temp记录当前节点深度 将temp作
二叉树的层次遍历反序列化，在本地构建LeetCode中的树（Python）
DamianGao的博客
03-23 198
在本地构建LeetCode中的树（Python） 我最近刷LeetCode，通过率明显低于均值。然而OJ的debug功能基本都要收费，没钱充会员。人又菜，家里又穷。作为自力更生的一小步，有必要自己在本地写一个类似的功能，以方便日后刷题时debug。这篇先上树（？），下次有其他的数据结构再写吧，也第一时间share。
C语言实现二叉树中序遍历-LeetCode题解
资源摘要信息:"c语言-leetcode题解之0094-binary-tree-inorder-traversal.zip" 在深入探讨这个资源之前，我们需要理解几个关键的概念：C语言、leetcode以及二叉树的中序遍历。 C语言是一种广泛使用的高级编程语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值