二叉树层次遍历

题目描述
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
思路 二叉树的层次遍历，利用栈的先进后出的特性。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
        vector<vector<int> > Print(TreeNode* pRoot) {
            vector<vector<int> > res;
            if(pRoot==NULL) return res;
            stack<TreeNode*> s;
            s.push(pRoot);
            while(!s.empty())
            {
                stack<TreeNode*> m;
                vector<int> temp;
                while(!s.empty())//这里我想不出循环结束条件了，就又加了一个辅助栈，作为换行的标志
                {
                    TreeNode* t = s.top();s.pop();
                    temp.push_back(t->val);
                    if(t->left) m.push(t->left);
                    if(t->right) m.push(t->right);
                    
                }
                res.push_back(temp);
                while(!m.empty())//m中是从左往右入栈，这里把它反过来，s中是从右往左入栈，确保从左往右输出
                {
                    s.push(m.top());
                    m.pop();
                }
            }
            return res;
        }
    
};```

按照惯例，去学习了大神的写法

class Solution {
public:
        vector<vector<int> > Print(TreeNode* pRoot) {
            vector<vector<int> > vec;
            if(pRoot == NULL) return vec;
 
            queue<TreeNode*> q;//先进先出应该用队列，我怎么想的。。。。
            q.push(pRoot);
 
            while(!q.empty())
            {
                int lo = 0, hi = q.size();
                vector<int> c;
                while(lo++ < hi)//这里机智，用size作为换行的依据
                {
                    TreeNode *t = q.front();
                    q.pop();
                    c.push_back(t->val);
                    if(t->left) q.push(t->left);
                    if(t->right) q.push(t->right);
                }
                vec.push_back(c);
            }
            return vec;
        }
};
**发现几种递归的写法**

 1. `

class Solution {
public:
vector<vector > res;
void dfs(TreeNode root, int deep){
if(root==nullptr)return;
if(deep+1>res.size())res.resize(deep+1);
res[deep].push_back(root->val);
dfs(root->left,deep+1);
dfs(root->right,deep+1);
}
vector<vector > Print(TreeNode pRoot) {
res.clear();
dfs(pRoot,0);
return res;
}

};`

自己在VS2015 上测试了一下，

TreeNode* root =new TreeNode(1);
TreeNode* r1 = new TreeNode(2);
TreeNode* r2 = new TreeNode(3);
TreeNode* r3 = new TreeNode(4);
TreeNode* r4 = new TreeNode(5);
TreeNode* r5 = new TreeNode(6);
TreeNode* r6 = new TreeNode(7);
root->left = r1;
root->right = r2;
r1->left = r3;
r1->right = r4;
r2->left = r5;
r2->right = r6;
vector<vector<int> >res = Print(root);

递归顺序如下 1 2 4 5 3 6 7，用deep记录递归深度，大概就是这样。