剑指offer 22、23、24

22、从上往下打印二叉树

从上往下打印出二叉树的每个节点,同层节点从左至右打印。

实际就是广度优先搜索 BFS, 借助一个队列就可以实现

这道题就是一个模板题,对队列的使用。因为要满足先进先出的特性。

初始化:一个队列queue, 将root节点入队列q
如果队列不空,做如下操作:
弹出队列头,保存为node,将node的左右非空孩子加入队列
做2,3步骤,知道队列为空

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表,例:[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        if not root:
            return ''
       //一个队列queue, 
        queue = []
        result = []
        //将root节点入队列q
        queue.append(root)
        while len(queue)>0:
        //弹出队列头保存为node,将node的左右非空孩子加入队列
            node = queue.pop(0)
            result.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        return result

23、二叉搜索树的后序遍历序列

输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

python:后序遍历 的序列中,最后一个数字是树的根节点 ,数组中前面的数字可以分为两部分:第一部分是左子树节点 的值,都比根节点的值小;第二部分 是右子树 节点的值,都比 根 节点 的值大,后面用递归分别判断前后两部分 是否 符合以上原则

BST的后序序列的合法序列是,对于一个序列S,最后一个元素是x (也就是根),如果去掉最后一个元素的序列为T,那么T满足:T可以分成两段,前一段(左子树)小于x,后一段(右子树)大于x,且这两段(子树)都是合法的后序序列。完美的递归定义 。

思路:
已知条件:后序序列最后一个值为root;二叉搜索树左子树值都比root小,右子树值都比root大。
1、确定root;
2、遍历序列(除去root结点),找到第一个大于root的位置,则该位置左边为左子树,右边为右子树;
3、遍历右子树,若发现有小于root的值,则直接返回false;
4、分别判断左子树和右子树是否仍是二叉搜索树(即递归步骤1、2、3)。
在这里插入图片描述

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        # 序列为空,返回 False
        if not sequence:
            return False
        # 获取序列的长度和二叉搜索树的根节点
        length = len(sequence)
        root = sequence[-1]
        # 寻找二叉搜索树的左子树
        for i in range(length):
            if sequence[i]>root:
                break
        # 判断二叉树右子树中的每一个元素的值是否都比根节点的大
        for j in range(i,length):
            if sequence[j]<root:
                return False
        # 递归调用,分别查看二叉树的左右子树
        left = right = True
        if i > 0:
            left = self.VerifySquenceOfBST(sequence[0: i])
        if i < length-1 and left:
            right = self.VerifySquenceOfBST(sequence[i: -1])
        # 当左右两子树都返回 True 的时候,结果才是 True
        return left and right

24、二叉树中和为某一值得路径

输入一颗二叉树的根节点和一个整数,按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

在这里插入图片描述
在这里插入图片描述

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表,内部每个列表表示找到的路径
    def FindPath(self, root, expectNumber):
        # write code here
        res = []
        path = []
        if root is None:
            return res
        
        def DFS(proot):
            path.append(proot.val)
            if proot.left is None and proot.right is None:
                if sum(path) == expectNumber:  # Python的好处
                    res.append(path[:])
            if proot.left is not None:
                left = DFS(proot.left)
            if proot.right is not None:
                right = DFS(proot.right)
            path.pop()
        DFS(root)
        res.sort()  # Python的好处
        return res 
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页