4-4 剑指Offer32-I&II 从上到下打印二叉树I&II C++ python力扣刷题笔记

剑指Offer32-I 从上到下打印二叉树

1.读题

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

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

返回其层次遍历结果

2.思路

本题要求将二叉树进行一哥层序遍历 从上至下按层打印
又称为二叉树的广度优先搜索(BFS)

BFS通常借助“队列”的先入先出特性来实现

算法流程

参考力扣大佬Krahets
思路太清晰了吧！

1.特例处理 设置退出条件
树的根节点为空——直接返回[]
2.初始化——
打印结果列表 res=[]
包含根节点的队列 queue = [root]
3.BFS循环（队列queue为空时跳出）
【1】出队 队首元素出队——记为node

【2】打印 将node.val添加至结果列表res尾部

【3】添加子节点 若node的左（右）子节点不为空 将其左（右）子节点加入队列queue

4.返回结果列表res

3.C++代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
     
public:
    vector<int> levelOrder(TreeNode* root) {
     
        vector<int> ans;
        if(!root)
            return ans;//特例处理
        queue<TreeNode*> q;//初始化队列q
        q.push(root);//二叉树根的入队
        while(q.size()) {
     //BFS循环
            TreeNode* node = q.front();//获取队列q的队首元素
            q.pop();//队列里的元素出队 
            ans.push_back(node->val);//队列中的元素压入到结果数组ans中
            if(node->left)
                q.push(node->left);//如果节点的左子树不为空 则将其左子树入队列！
            if(node->right)
                q.push(node->right);//同理 节点右子树不为空 也扔到队列里去~
        }
        return ans;
    }
};

4.python代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: return [] #特例处理
        res, queue = [], collections.deque() #初始化 创建空结果列表 队列
        queue.append(root) #节点入队
        while queue:#结点非空 则继续循环
            node = queue.popleft()#队首元素出队
            res.append(node.val)#元素添加到结果列表末尾
            if node.left: queue.append(node.left)# 添加子节点的操作 
            #等新一轮循环就可以添加到结果列表末尾了
            if node.right: queue.append(node.right)
        return res

剑指Offer32-II 从上到下打印二叉树II

1.读题

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

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

返回其层次遍历结果

2.思路

本题与上题有微小差别
将每一层打印到一行
输出一个二维数组ans

vector<vector<int>> ans

依旧是参考Krahets大佬的解题思路

3.C++代码

胡船长的代码也是香得不行啊！
这段儿消化了蛮久的（我也是太菜了）
感觉很香！

尤其是这个分层打印的方法~
总之
递归思想真的是很简单且很香！（怕自己乱 先不看迭代了嘤嘤嘤）

class Solution {
     
public:
    void getResult(TreeNode *root, int depth, vector<vector<int>> &ans){
     //深度优先搜索
        //这个是用于每一层打印结果的函数
	    if (root == NULL) return;//特例处理
	    if (depth == ans.size()) {
      //在当前层数与最终结果（二维动态）数组的长度相同时
            ans.push_back(vector<int>());//新建一行~
            //在二维数组没有对应行的时候 新建这一行————就这作用~
        }
	    ans[depth].push_back(root->val);//向结果数组的尾部中加入根节点
	    getResult(root->left, depth+1, ans);//逐层进行递归 
	    getResult(root->right,depth+1, ans);
        return;
        }
    vector<vector<int>> levelOrder(TreeNode* root) {
     
        vector<vector<int>> ans;
        getResult(root, 0, ans);//从第零层开始遍历
        return ans;
    }
};

4.python代码

不得不感慨一句 这个代码实在是太特么清晰了

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return [] #特例处理
        res, queue = [], collections.deque() #初始化队列
        queue.append(root) #把根压入队列
        while queue: #队列只要不为空 就一直循环
            tmp = [] #初始化临时列表
            for _ in range(len(queue)): #当前层打印循环
                node = queue.popleft() #队首元素进行出队 记为node
                tmp.append(node.val) #将node加到结果列表中
                if node.left: queue.append(node.left) #左子节点如果非空 加入队列末尾
                if node.right: queue.append(node.right) #右子节点如果非空 加入队列末尾
            res.append(tmp) #将这一层的结果打印出来 加到最后的二维结果数组中~
        return res