day13-数据结构力扣

也是优先掌握递归的方法

110.平衡二叉树

思路

首先了解什么是平衡二叉树

平衡二叉树（Balanced Binary Tree）是一种特殊的二叉搜索树（BST），其左右子树的高度差不超过1 。这种结构确保了树的查询、插入和删除操作的时间复杂度维持在 O(log n) ，避免普通二叉搜索树退化为链表（时间复杂度恶化至 O(n)）。

主要用他左右子树的高度差来解题

确定遍历顺序：后序遍历

递归法：

1.确定传入的东西：根节点

2.确定停止递归的条件：递归的过程中遇到空节点了为终止，返回0

3.单个递归的处理逻辑：

得到左右子树的高度，计算左右子树的差值，大于1，返回-1

如果差值没有大于1，返回树的高度

提交

python 复制代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        return self.gethight(root)>0

    def gethight(self,node):
        if not node:
            return 0
        lefthight=self.gethight(node.left)
        if lefthight==-1:
            return -1
        righthight=self.gethight(node.right)
        if righthight==-1:
            return -1
        if (abs(lefthight-righthight)>1):
            res=-1
        else:
            res=1+max(lefthight,righthight)
        return res

257. 二叉树的所有路径

题目链接 257. 二叉树的所有路径 - 力扣（LeetCode）

思路

没有思路，好像还有用到回溯，更不会了

箭头上面的序号就是我们走的顺序，其实还是能看懂就是不知道代码怎么写

核心思路

要从根走到每一个叶子 ，把路径记下来。必须用 前序遍历（根 → 左 → 右），因为要先把当前节点放进路径，再走孩子。

递归思路

先把当前节点加入路径
如果是叶子节点（左右都空），就把这条路径存进结果
如果有左孩子，递归走左
如果有右孩子，递归走右
返回上一层前，把当前节点从路径删掉（这就是回溯）

总结

遍历：前序
终止：到叶子就存路径
关键：递归走左右，回溯退一步
本质：根到所有叶子的遍历 + 路径回退

提交

python 复制代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        res=[]
        path=[]
        if not root:
            return res
        self.traversal(root,path,res)
        return res

    def traversal(self,cur,path,res):
        path.append(cur.val)
        if not cur.left and not cur.right://叶子结点收集结果
            spath='->'.join(map(str,path))
            res.append(spath)
            return
        if cur.left:
            self.traversal(cur.left,path,res)
            path.pop()//回溯
        if cur.right:
            self.traversal(cur.right,path,res)
            path.pop()//回溯

404.左叶子之和

题目链接404. 左叶子之和 - 力扣（LeetCode）

思路

这个思路并不算很复杂，我说一下自己刚开始写错的地方

1.只判断了node.left就加上他的值，应该还需要判断他是叶子结点，也就是，node.left没有左节点和右结点

2.没写完递归逻辑

python 复制代码

        sum1+=self.count(node.left)
        sum1+=self.count(node.right)

提交

python 复制代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        return self.count(root)

    def count(self,node):
        sum1=0
        if not node:
            return sum1
        if node.left and not node.left.left and not node.left.right:
            sum1+=node.left.val
        sum1+=self.count(node.left)
        sum1+=self.count(node.right)
        return sum1

222.完全二叉树的节点个数

题目链接 222. 完全二叉树的节点个数 - 力扣（LeetCode）

思路

能不能就直接遍历，然后把结果存到数组里面，然后我求数组的大小。

可以

提交

python 复制代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        return len(self.traversal(root))

    def traversal(self,node):
        if not node:
            return []
        return [node]+self.traversal(node.left)+self.traversal(node.right)

这里需要注意的就是，traversal确定返回数组，那就要统一。我刚开始把return那里写成返回0。