手撕二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if (root != nullptr) {
            que.push(root);
        }
        while (!que.empty()) {
            vector<int> vec;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            } 
            res.push_back(vec);
        }
        return res;
    }
};

 思路：需要先建立一个队列。现将二叉树的头结点入队列，然后出队列，访问该节点，如果它有左子树，则左子树的根节点入队列，如果它有右子树，则将它的右子树的根节点入队列。然后再出队列，对队列结点进行访问。如此反复，直至队列为空。

注意：每层while循环中定义的size，不能用que.size()，因为在每层while循环中它在变，所以得自己定义一个size记录当时队列的大小。

类似题型

LeetCode-107

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if (root != nullptr) {
            que.push(root);
        }
        while (!que.empty()) {
            vector<int> vec;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            res.push_back(vec);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if (root != nullptr) {
            que.push(root);
        }
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                vec.push_back(node->val);
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            res.push_back(vec);
        }
        vector<int> result;
        for (int i = 0; i < res.size(); i++) {
            result.push_back(res[i].back());
        }
        return result;
    }
};

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if (root != nullptr) {
            que.push(root);
        }
        while (!que.empty()) {
            vector<int> vec;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            res.push_back(vec);
        }
        vector<double> result;
        for (int i = 0; i < res.size(); i++) {
            double sum = 0;
            for (int j = 0; j < res[i].size(); j++) {
                sum += res[i][j];
            }
            result.push_back(sum/res[i].size());
        }
        return result;
    }
};

 

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> res;
        queue<Node*> que;
        if (root != NULL) {
            que.push(root);
        }
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                Node* node = que.front();  
                que.pop();
                vec.push_back(node->val);
                for (Node* n : node->children) {
                    que.push(n);
                }      
            }
            res.push_back(vec);
        }
        return res;
    }
};

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> res;
        if (root != nullptr) {
            que.push(root);
        }
        while (!que.empty()) {
            int max = INT_MIN;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->val > max) {
                    max = node->val;
                }    
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);            
            }
            res.push_back(max);
        }
        return res;
    }
};

 

 

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) {
            que.push(root);
        }
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                if (i < size - 1) {
                    node->next = que.front();
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};