按照书上的解题思路，采用两个栈做辅助数据容器，逐层打印。

And，清空vector的三种方法都可以使用，layer.clear() 最简洁。

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> ret;
        if(!pRoot) return ret;
        
        //奇数层节点，压入奇数栈，子节点从左向右压入偶数栈；偶数层相反:从右向左；
        stack<TreeNode*> stack_odd, stack_even;
        stack_odd.push(pRoot);
        
        while(!stack_odd.empty() || !stack_even.empty()) {
            
            vector<int> layer;
            while(!stack_odd.empty()) {
                TreeNode* node = stack_odd.top();
                stack_odd.pop();
                layer.push_back(node->val);
                if(node->left) stack_even.push(node->left);
                if(node->right) stack_even.push(node->right);
            }
            if(!layer.empty()) ret.push_back(layer);
            
            vector<int> ().swap(layer);
            while(!stack_even.empty()) {
                TreeNode* node = stack_even.top();
                stack_even.pop();
                layer.push_back(node->val);
                if(node->right) stack_odd.push(node->right);
                if(node->left) stack_odd.push(node->left);
            }
            if(!layer.empty()) ret.push_back(layer);
        }
        return ret;
    }
};

通过的代码中排序第一的C++程序，思路大体上与我的思路相同： 

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> > res;
        if(pRoot == nullptr) return res;
        stack<TreeNode*> stackL;
        stack<TreeNode*> stackR;
        TreeNode* popNode;
        vector<int> tmp;
        tmp.push_back(pRoot->val);
        res.push_back(tmp);
        tmp.clear();
        stackL.push(pRoot);
        while(!stackL.empty() || !stackR.empty()){
            while(!stackL.empty()){
                popNode = stackL.top();
                stackL.pop();
                if(popNode->right){
                    stackR.push(popNode->right);
                    tmp.push_back(popNode->right->val);               
                }
                if(popNode->left){
                    stackR.push(popNode->left);
                    tmp.push_back(popNode->left->val);
                }
            }
            if(!tmp.empty()) {
                res.push_back(tmp);
                tmp.clear();
            }
            while(!stackR.empty()){
                popNode = stackR.top();
                stackR.pop();
                if(popNode->left){
                    stackL.push(popNode->left);
                    tmp.push_back(popNode->left->val);
                }
                if(popNode->right){
                    stackL.push(popNode->right);
                    tmp.push_back(popNode->right->val);
                }
            }
            if(!tmp.empty()){
                res.push_back(tmp);
                tmp.clear();
            }
        }
        return res;
         
    }
     
};