1二叉树左下角的值

左下角的值：最后一层最左侧的节点的值

递归

from collections import deque
class TreeNode:
    def __init__(self,val,left=None,right=None):
        self.val = val
        self.left = left
        self.right = right

class solution:
    def leftBottomNode(self,root):
        self.maxdepth=0
        self.result=None
        self.travelsal(root,0)
        return self.result

    def travelsal(self,root:TreeNode,depth):
        # 终止条件：遍历到深度最大的节点了
        if root.left is None and root.right is None:
            if depth >self.maxdepth:
                self.maxdepth=depth
                self.result= root.val

        # 单层递归逻辑
        # 左 因为这里的return不在中，即没有处理中的逻辑，而我们需要记录递归时的深度，所以深度这个变量不是从上一层返回递增的，而是需要回溯
        if root.left:
            depth+=1
            self.travelsal(root.left,depth)
            depth-=1

        if root.right:
            depth+=1
            self.travelsal(root.right,depth)
            depth-=1

层序遍历

每层队列第一个popleft的值就是每层最左边的值，不断更新这个result找到左下角的值

   def leftBottomNode2(self,root):
        if root is not None:
            que=deque()
            que.append(root)
            result=0
            while len(que)>0:
                size=len(que)
                vec = []
                while size:
                    result=que.popleft().val
                    size-=1
                    if root.left:que.append(root.left)
                    if root.right:que.append(root.right)

2路径总和

第一种递归函数需要返回值的情况：力扣

该题在遍历过程中需要及时返回true 或者false以停止继续搜索

def findSumTree(self,root:TreeNode,count)->bool:
    # 终止条件 按照count--的做法
    if root is None:
        return False
    if root.left is None and root.right is None and count==0:
        return True
    if root.left is None and root.right is None and count!=0:
        return False

    if root.left:
        count-=root.left.val
        # 什么时候需要返回值，什么时候不需要返回值
        if (self.findSumTree(root.left,count)):
        # 递归时需要及时返回
            return True
        count+=root.left.val
    if root.right:
        count-=root.right.val
        if (self.findSumTree(root.right,count)):
            return True
        count+=root.right.val

第二种递归函数不需要返回值的情况：

class solution2:
    def __init__(self):
        self.result=[]
        self.path=[]

    def findSumTree2(self,root:TreeNode,count)->bool:
        # 终止条件 按照count--的做法
        if root is None:
            return False
        if root.left is None and root.right is None and count==0:
            # Python里不写[:]代表的是传的是引用，会变，带上就是拷贝的结果，相当于快照
            self.result.append(self.path[:])
            return self.result

        if root.left is None and root.right is None and count!=0:
            return False

        if root.left:
            count-=root.left.val
            self.path.append(root.left.val)
            # 什么时候需要返回值，什么时候不需要返回值
            self.findSumTree2(root.left,count)
            count+=root.left.val  # 两次回溯
            self.path.pop()

        if root.right:
            count-=root.right.val
            self.path.append(root.right.val)
            self.findSumTree2(root.right,count)
            count+=root.right.val
            self.path.pop()

        return self.result

    def getSumTree(self,root,sum):
        if root is None:
            return 0
        self.path.append(root.val)
        return self.findSumTree2(root,sum-root.val)

3构造二叉树

中序和后序可以构造二叉树
中序和前序也可以构造二叉树
但是前序和后序不能构造二叉树，因为找不到根节点的位置

from typing import List
from collections import deque
class TreeNode:
    def __init__(self,val,left=None,right=None):
        self.val = val
        self.left = left
        self.right = right

class solution:
    # 中序和后序
    def createTree(self,inorder:List[int],postorder:List[int]):
        # 终止条件
        if len(inorder) == 0:
            return None

        # 先从后序数组里找中节点
        root = TreeNode(postorder[-1])
        # 然后找到中序数组里中节点的index
        index = inorder.index(root.val)
        # 确定中序数组的左子树和右子树
        inorder_left=inorder[:index]
        inorder_right=inorder[index+1:]
        # 然后递归处理左子树和右子树
        '''
        一定要保证递归的两个数组的长度是相同的
        '''
        root.left = self.createTree(inorder[:index],postorder[:len(inorder_left)])
        # 正常来讲 postorder应该从len(inorder_left)+1开始，但是要保证二者的长度相同，所以从len(inorder_left)开始
        root.right = self.createTree(inorder[index+1:],postorder[len(inorder_left):-1])
        return root


    def bulidTree(self,preorder,inorder):
        if len(preorder) == 0:
            return None

        # 从前序数组里找根节点
        root = TreeNode(preorder[0])
        index = inorder.index(root.val)
        '''
               一定要保证递归的两个数组的长度是相同的
               '''
        root.left = self.bulidTree(preorder[1:index+1],inorder[:index])
        root.right = self.bulidTree(preorder[index+1:],inorder[index+1:])
        return root
    def preorderPrint(self, root:TreeNode):
        if root is None:
            return []
        print(root.val)
        left=self.preorderPrint(root.left)
        right=self.preorderPrint(root.right)

    def travelsal(self,root:TreeNode):
        if root is not None:
            que=deque()
            que.append(root)
            result=[]
            # 一定是while，不是if
            while len(que)>0:
                size=len(que)
                vec = []
                while size:
                    root=que.popleft()
                    vec.append(root.val)
                    size-=1
                    if root.left:que.append(root.left)
                    if root.right:que.append(root.right)
                result.append(vec)
        return result