(树)二叉树的遍历

参考大佬的讲解：代码随想录，总结的很好

 

107. 二叉树的层次遍历 II

解题思路

采用自顶向下，一层一层遍历，然后逆转就是自底向上。

1.一层一层遍历树，这里用到的是队列来做，以root开始

2.将root放进队列，第一层就只有root这一个节点，当队列不为空，读取队列中的长度size，表示的是一层节点的数目，第一层的话是size = 1。

3.然后遍历这一层每一个节点，用临时变量node存储当前节点,并将队列中该元素pop出去，然后判断当前节点是否为空，不为空则继续（为空的话没必要继续啊，值都没有）

4.将当前节点的值存起来放到levelNum，然后判断当前节点的左右孩子是否为空，不为空就放进队列，作为下一层

5.将size--，回到3执行，表示进行这一层的下一个节点

6.size==0,表示这一层所有节点都遍历完了，那么就要把levelNum的值放入结果res存储，并把它清空，作为遍历下一层时存储使用。

7.回到2执行，表示开始遍历下一层，队列为空时，表示遍历完所有层，结束

8.逆序reverse

 

自底向上：

/**2-层次遍历：自底向上
 * 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<vector<int>> levelOrderBottom(TreeNode* root) {
      if(root == nullptr) return{};
      vector<vector<int>> res;
      vector<int> level;
      queue<TreeNode*> que;
      que.push(root);
      while(!que.empty()){
          int size = que.size();
          for(int i=0; i<size; i++){
              TreeNode *node = que.front();
              que.pop();
              level.push_back(node->val);
              if(node->left) que.push(node->left);
              if(node->right) que.push(node->right);
          }
          res.push_back(level);
          level.clear();
      }
      reverse(res.begin(), res.end());
      return res;
    }
};

自定向下：

/**1-层次遍历：自定向下 
 * 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<vector<int>> levelOrder(TreeNode* root) {
        if(root == nullptr) return {};
        vector<vector<int>> res;
        vector<int> level;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i<size; i++){
                TreeNode* node = que.front();
                que.pop();
                level.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(level);
            level.clear();
        }
        return res;
    }
};

 

下面是一些层次遍历的应用，你会发现其实都是一样的套路，只是对节点的处理从打印进行变换罢了~

 

遍历右子树：

/**3-层次遍历右子树
 * 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> rightSideView(TreeNode* root) {
        if(root == nullptr) return{};
        vector<int> res;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i=0; i<size; i++){
                TreeNode *node = que.front();
                que.pop();
                if(i == size-1) res.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};

每层求平均值：

/**4-层次遍历求每层平均值
 * 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<double> averageOfLevels(TreeNode* root) {
        if(root == nullptr) return{};
        vector<double> res;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            double sum = 0;
            for(int i=0; i<size; i++){
                TreeNode *node = que.front();
                que.pop();
                sum += node->val;
                if(i == size-1) res.push_back(sum/size);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};

遍历N叉树：

/*5-层次遍历N叉树：自顶向下
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

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

找每一层最大值：

/**7--层次遍历方式：找一层中最大值
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        if(root == nullptr) return{};
        vector<int> res, temp;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i=0; i<size; i++){
                TreeNode *node = que.front();
                que.pop();
                temp.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);

            }
            sort(temp.begin(), temp.end());
            res.push_back(temp.back());
            temp.clear();
        }
        return res;
    }
};