力扣做题笔记——剑2 32.从上到下打印二叉树Ⅰ&从上到下打印二叉树Ⅱ&从上到下打印二叉树Ⅲ

Ⅰ.从上到下打印二叉树Ⅰ
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如：
给定二叉树：3,9,20,null,null,15,7，

返回：`[3,9,20,15,7]` **提示** 1. `节点总数<=1000`

思路
很平常的广度优先遍历方法，使用一个队列记录每一层的节点。
代码

vector<int> levelOrder(TreeNode* root) {
    vector<int> res;
    if (root == nullptr) return res;
    queue<TreeNode*> line;
    TreeNode* node = root;
    line.push(root);
    print(node, line, res);
    return res;
}
void print(TreeNode* root, queue<TreeNode*>& line, vector<int>& res){
    while(!line.empty()){
        if (line.front()->left != nullptr){
            line.push(line.front()->left);
        }
        if (line.front()->right != nullptr){
            line.push(line.front()->right);
        }         
        res.push_back(line.front()->val);
        line.pop();
    }
}

Ⅱ.从上到下打印二叉树Ⅱ
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如：
给定二叉树：[3,9,20,null,null,15,7]，
返回其层次遍历结果：

[
	[3],
	[9,20],
	[15,7]
]

提示

1. 节点总数<=1000

思路
二叉树的层次遍历可以使用广度优先算法遍历，使用一个队列储存遍历到的节点即可，本题的难点在于如何分辨每一层的节点。

1. 队列的初始化：若队列为空，则将根节点入队；
2. 循环条件：队列不为空时，则进行入队、出队的操作。在循环内部可以使用for循环区分每一层，for循环的循环条件是每一层的节点个数，可以通过求队列的长度获得，因为在每遍历完一层后，本层的节点已经全部出队了，下一层的节点已经全部入队了。

代码

vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> res;
    if (root == nullptr) return res;
    TreeNode* node = root;
    queue<TreeNode*> lst;
    vector<int> temp;
    if (lst.empty()) lst.push(root);
    while (!lst.empty()){
        for (int i = lst.size(); i > 0; i--){
            if (lst.front()->left != nullptr) lst.push(lst.front()->left);
            if (lst.front()->right != nullptr) lst.push(lst.front()->right);
            temp.push_back(lst.front()->val);
            lst.pop();
        }
        res.push_back(temp);
        temp.clear();
    }
    return res;
}

Ⅲ.从上到下打印二叉树Ⅲ
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如给定二叉树：[3,9,20,null,null,15,7]，
返回其层次遍历结果：

[
	[3],
	[20,9],
	[15,7]
]

提示

1. 节点总数<=1000

思路
两种思路：第一种是利用双头队列deque，当前为偶数行时，从队头入队，先左节点后右节点，保存队尾节点值；当前为奇数行时，从队尾入队，先右节点后左节点，保存队头节点值。第二种是在奇数行时利用vector容器的reverse函数将数组反转。
代码

// 方法1
vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> res;
    if (root == nullptr) return res;
    TreeNode* node = root;
    deque<TreeNode*> lst;
    if (lst.empty()) lst.push_back(node);
    int j = 0;
    while (!lst.empty()){
        int n = lst.size();
        vector<int> temp;
        for (int i = n; i > 0; i--){
            if (j % 2 == 0){
                TreeNode* cur = lst.back();
                if (cur->left != nullptr) lst.push_front(cur->left);
                if (cur->right != nullptr) lst.push_front(cur->right);
                temp.push_back(cur->val);
                lst.pop_back();
            }
            else{
                TreeNode* cur = lst.front();
                if (cur->right != nullptr) lst.push_back(cur->right);
                if (cur->left != nullptr) lst.push_back(cur->left);
                temp.push_back(cur->val);
                lst.pop_front();
            }
        }
        j++;
        res.push_back(temp);
    }
    return res;
}

// 方法2
vector<vector<int>> levelOrder(TreeNode* root) {
	vector<vector<int>> res;
   if(!root) return res;
    queue<TreeNode*> q;
    q.push(root);
    bool flag = true;
    while(!q.empty())
    {
        vector<int> tmp;
        int n = q.size();
        for(int i = 0; i < n; i++)
        {
            TreeNode* node = q.front();
            q.pop();
            tmp.push_back(node->val);
            if(node->left) q.push(node->left);
            if(node->right) q.push(node->right);
        }
        if(flag)
        {
            res.push_back(tmp);
        }
        else
        {
            reverse(tmp.begin(), tmp.end());
            res.push_back(tmp);
        }
        flag = !flag;
    }
    return res;
}

本文题目及部分解答来自力扣：I. 从上到下打印二叉树 I 、II. 从上到下打印二叉树 II及III. 从上到下打印二叉树 III。