二叉树学习之旅——层次遍历

层次遍历

先修知识点

二维容器：

1. vector<vector<int>> A;vector<int> B；A.push_back(B)。插入元素，元素的类型。
2. int len = A.size();int len = A[i].size();vector A 的长度(元素的个数)；vector A中元素i的长度。
3. 访问元素和二维数组一样。A[i][j]

迭代器定义：vector::iterator iter1;

queue队列容器：只能访问 queue<T> 容器适配器的第一个和最后一个元素。FIFO的选择（先进先出）

1. std::queue<std::string> words;
2. std::queue<std::string> copy_words {words}; // A duplicate of words
3. std::queue<std::string, std::list<std::string>>words;

queue函数：【和 stack 一样，queue 也没有迭代器。】

• front()：返回 queue 中第一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。//copy与引用区别：普通的赋值copy：int a=1; int b=a;b++ a不变。引用 int b=&a;b++ a也变。
• back()：返回 queue 中最后一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
• push(const T& obj)：在 queue 的尾部添加一个元素的副本。这是通过调用底层容器的成员函数 push_back() 来完成的。
• push(T&& obj)：以移动的方式在 queue 的尾部添加元素。这是通过调用底层容器的具有右值引用参数的成员函数 push_back() 来完成的。
• pop()：删除 queue 中的第一个元素。
• size()：返回 queue 中元素的个数。
• empty()：如果 queue 中没有元素的话，返回 true。 用于queue循环的判断条件，while(!q.empty)或if(!q.empty)
• emplace()：用传给 emplace() 的参数调用 T 的构造函数，在 queue 的尾部生成对象。
• swap(queue<T> &other_q)：将当前 queue 中的元素和参数 queue 中的元素交换。它们需要包含相同类型的元素。也可以调用全局函数模板 swap() 来完成同样的操作。

问题描述

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

给定二叉树 [3,9,20,null,null,15,7]
返回其自底向上的层次遍历为：[  [15,7],  [9,20],  [3] ]。

解题思路

返回的层次遍历是一个二维容器（我自己想的名字不知道是不是叫这个），看到函数返回值类型也可以知道，需要定义一个二维容器vector<vector<int>> level。

利用队列先进先出的原则，先把根存进队列，此时队列的长度为1，只需要进行一次循环将此时队列中的根的值取出，并访问根将根的左右子树存到队列中。此时队列长度为2，进行两次循环，

1. 在类中定义二维容器level作为返回值赋值。vector<vector<int>> level
2. 在函数中，首先先定义一个树节点队列queue<TreeNode*> q;用于存储每层的节点。然后进行二叉树判断if(root)，不为空，则将根节点的信息存入堆栈q.push(root);之后就，开始层序遍历的循环。
3. 循环以队列是否为空来判断，若为空则停，不为空则继续：while(!q.empty()){}；此为层次循环，不空则表示还有层次。
4. 开始层次循环先建立一维容器vector<int>用来存储当前层次的节点数值val；然后读取当前队列的长度int len=q.size();来作为每层应该进行的循环次数，开始每一层的一维容器建立，并保存下一层的信息到队列之中。
5. 在当前层的循环之中，先建立树节点变量来存储当前队列的第一个元素（由于queue队列的FIFO原则，元素顺序就是层次节点的顺序）——当前节点：TreeNode* my_root=q.front();之后把第一个元素清除q.pop();把当前节点的数值用push_back()函数存入一维容器之中a.push_back(my_root->val);然后将当前节点的左右子树信息存入队列中q.push(my_root->left);q.push(my_root->right);
6. 完成当前层循环之后，将一维容器的数据插入到二维容器之中（由于是自底而上，所以迭代器为begin()）插入函数使用的是insert：level.insert(level.begin(),a);
7. 最后返回层次遍历的结果。return level;

/**
 * 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>> level;
    vector<vector<int>> levelOrderBottom(TreeNode* root) 
    {
        queue<TreeNode*> q;
        if(root)
        {
            q.push(root);            
            while(!q.empty())
            {
                vector<int> a;
                int len=q.size();
                for(int i=0;i<len;i++)
                {
                    TreeNode* my_root=q.front();
                    q.pop();
                    a.push_back(my_root->val);
                    if(my_root->left)
                        q.push(my_root->left);
                    if(my_root->right)
                        q.push(my_root->right);
                }
                level.insert(level.begin(),a);
            }
        }
        return level;
    }
};

需要记住的点：

1. if(root)；而return level 是在if 之后。
2. 层次循环的条件是队列不为空。while(!q.empty());
3. 每一层单独建立一维容器。vector<int> a;
4. 建立树节点存储完当前队列的一个元素后，将第一个元素清除。my_root=q.front();q.pop();
5. 当前层的一维容器插入到二位容器中用的是插入函数insert()。level.insert(level.begin()，a);这里要记住。如果是从上而下，用的迭代器是end()，在前一层后面添加；而如果是如题是自下而上，用的迭代器是begin()，添加在前一层前面。