leetcode107&102&103

1、Binary Tree Level Order Traversal II
Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right, level by level from leaf to root).
For example:
Given binary tree [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
return its bottom-up level order traversal as:
[
[15,7],
[9,20],
[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:
    void function(TreeNode* root,int level,vector<vector<int>> &result){
        if(!root) return;
        if(level>result.size())
            result.push_back(vector<int>());
        result[level-1].push_back(root->val);
        function(root->left,level+1,result);
        function(root->right,level+1,result);
    }
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        function(root,1,result);
        reverse(result.begin(),result.end());
        return result;
    }

};

思路：要区分开每一层，每往下层递归一次，要有个标志加1，写function完成。
result.size() 为当前result存在的层数，level为当前节点所在层数，若level>size，当前节点所在层数大于存在层数，则result添加一层vector，若level=size,则当前节点所在层数等于存在层数，就直接push_back在当前层就好了。
相当于从左到右顺着一条路走到底，存在的节点，放到对应的层，不存在了就换一条路(右边的路嗯)
注意：vector<vector<int>> &result这里必须用引用，不然function形成的result不会被返回。
～～引用就是某一变量的一个别名，对引用的操作与对变量直接操作完全一样。使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作。
传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

2、 Binary Tree Level Order Traversal
Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).
For example:
Given binary tree [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
return its level order traversal as:
[
[3],
[9,20],
[15,7]
]

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        function(root,1,result);
        return result;
    }
    void function(TreeNode* root, int level, vector<vector<int>> &result){
        if(!root) return;
        if(level>result.size()){
            result.push_back(vector<int>());
        }
        result[level-1].push_back(root->val);
        function(root->left,level+1,result);
        function(root->right,level+1,result);
    }
};

就是和上面顺序相反输出而已。。。

3、Binary Tree Zigzag Level Order Traversal
Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
return its zigzag level order traversal as:
[
[3],
[20,9],
[15,7]
]

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> result;
        function(root,1,result);
        for(int i=1;i<result.size();i+=2){
            reverse(result[i].begin(),result[i].end());
        }
        return result;
    }
    void function(TreeNode* root,int level,vector<vector<int>> &result){
        if(!root) return;
        if(level>result.size())
            result.push_back(vector<int>());
        result[level-1].push_back(root->val);
        function(root->left,level+1,result);
        function(root->right,level+1,result);
    }
};

偷个懒，在上题的返回的result的基础上，隔层取反～是比下面算法慢一些的，不过好理解呀嘻嘻～

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> result;
        function(root,1,result,true);
        return result;
    }
    void function(TreeNode* root, size_t level, vector<vector<int>> &result, bool a){
        if(!root) return;
        if(level>result.size())
            result.push_back(vector<int>());

        if(a)
            result[level-1].push_back(root->val);
        else
            result[level-1].insert(result[level-1].begin(),root->val);
        function(root->left,level+1,result,!a);
        function(root->right,level+1,result,!a);
    }
};

如果要对不同层按照不同顺序存入，就又要多一个判断了，每运行一次function就代表进入下一层，则判断取反，上层从左到右，下层就从右到左了（通过insert函数实现的，不造调整递归能不能行）。

1、C++容器的insert()函数有以下三种用法
在指定位置it前“插入”值为val的元素,返回指向这个元素的迭代器。
iterator insert( iterator it, const type &val );
（和push_bach(const type &val) 的顺序刚好相反哒～～）
在指定位置it前“插入”num个值为val的元素
void insert( iterator it, size_type num, const TYPE &val );
在指定位置it前“插入”区间[start, end)的所有元素.
void insert( iterator it, input_iterator start, input_iterator end );
2、reverse函数的作用是：反转一个容器内元素的顺序。函数参数：reverse(first,last);
first为容器的首迭代器，last为容器的末迭代器。它没有任何返回值。