medium 剑指 Offer 从上到下打印二叉树 III 层序遍历 BFS

---

整层翻转：

c++ STL

vector reverse 原地反转

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root == nullptr){
            return res;
        }
        queue<TreeNode*> que;
        que.push(root);
        bool flag = false;
        while(!que.empty()){
            int n = que.size();  // 这一层中元素的个数
            vector<int> layer;  // 不能初始化layer(n)，否则没有左(右)节点会填充0
            while(n){
                TreeNode* node = que.front();  // 队顶元素
                layer.push_back(node->val);
                que.pop();
                //该层元素的左右节点(下一层)进入队列
                if(node->left != nullptr){
                    que.push(node->left);
                }
                if(node->right != nullptr){
                    que.push(node->right);
                }
                n--; // 这一层中元素的个数-1
            }
            if(flag){
                reverse(layer.begin(), layer.end());
            }
            flag = !flag;
            res.push_back(layer);
        }
        return res;
    }
};

python

[::-1] 非原地反转，必须接收返回值

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        if not root:
            return res
        q = collections.deque([root])   # 创建python双端队列，并放入p
        flag = False
        while q:
            n = len(q)
            layer = []
            while n:
                node = q.popleft()
                n -= 1
                layer.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            if flag:
                layer = layer[::-1]  # 切片反转无法原地,必须接收返回值
            flag = bool(1-flag) # python 对布尔值进行取反
            res.append(layer)
        return res

---

layer push_back, push_front:

c++

vector没有push_front()，应该是layer.insert(layer.begin(),node->val); //push_front

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root == nullptr){
            return res;
        }
        queue<TreeNode*> que;
        que.push(root);
        bool flag = true;
        while(!que.empty()){
            int n = que.size();  // 这一层中元素的个数
            vector<int> layer;  // 不能初始化layer(n)，否则没有左(右)节点会填充0
            while(n){
                TreeNode* node = que.front();  // 队顶元素
                if(flag){
                    layer.push_back(node->val);
                }else{
                    layer.insert(layer.begin(),node->val);  //push_front
                }
                que.pop();
                //该层元素的左右节点(下一层)进入队列
                if(node->left != nullptr){
                    que.push(node->left);
                }
                if(node->right != nullptr){
                    que.push(node->right);
                }
                n--; // 这一层中元素的个数-1
            }

            flag = !flag;
            res.push_back(layer);
        }
        return res;
    }
};

python

layer.insert(0,node.val) # push_front()

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        if not root:
            return res
        q = collections.deque([root])   # 创建python双端队列，并放入p
        flag = True
        while q:
            n = len(q)
            layer = []
            while n:
                node = q.popleft()
                n -= 1
                if flag:
                    layer.append(node.val)
                else:
                    layer.insert(0,node.val)  # push_front()
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            flag = bool(1-flag) # python 对布尔值进行取反
            res.append(layer)
        return res

---