102. Binary Tree Level Order Traversal

二叉树的层序遍历分别实现层序顺序输出，层序反向输出，层序计算每一层的平均值。

• Forward Output
• Inverse Output
• Average of Levels
• Zigzag Level Order Traversal

二叉树的层序遍历接借助了两个队列来实现相应的功能，首先判断根节点是否为空，如果根节点为空的话直接返回，不为空，则首先将根节点放入第一个队列里面，然后访问第一个队列里面的元素，将所有第一个队列里面的节点的子节点放入第二个队列，然后将元素从第一个队列弹出直至空，之后再访问第二个队列里的元素，同样的将第二个队列元素的子节点放入第一个队列，弹出直至为空，这样一直循环直到二叉树的末尾。反向输出的话只需要借助栈，将正向输出的结果存储下来，就可以了。

假设二叉树拥有N个节点的话，这个程序的时间复杂度是O（N），还是比较理想的。

Forward Output

题目1：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>> vec;
        queue<struct TreeNode*> que1;
        queue<struct TreeNode*> que2;
        struct TreeNode* temp = NULL;
        if (root == NULL)
            return vec;
        que1.push(root);
        while (!que1.empty() || !que2.empty()) {
            if (!que1.empty()) {
                vector<int> vec_temp;
                while (!que1.empty()) {
                    temp = que1.front();
                    vec_temp.push_back(temp->val);
                    if (temp->left != NULL)
                        que2.push(temp->left);
                    if (temp->right != NULL)
                        que2.push(temp->right);
                    que1.pop();
                }
                vec.push_back(vec_temp);
            }
            else if (!que2.empty()) {
                vector<int> vec_temp;
                while (!que2.empty()) {
                    temp = que2.front();
                    vec_temp.push_back(temp->val);
                    if (temp->left != NULL)
                        que1.push(temp->left);
                    if (temp->right != NULL)
                        que1.push(temp->right);
                    que2.pop();
                }
                vec.push_back(vec_temp);
            }
        }
        return vec;
    }
};

Inverse Output

题目2：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]
]

相比较从上往下的输出，这个唯一不同的是借助了栈来实现
以下是程序：

/**
 1. Definition for a binary tree node.
 2. struct TreeNode {
 3.     int val;
 4.     TreeNode *left;
 5.     TreeNode *right;
 6.     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 7. };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        stack<vector<int>> sta;
        vector<std::vector<int>> vec;
        queue<struct TreeNode*> que1;
        queue<struct TreeNode*> que2;
        struct TreeNode* temp;
        if (root == NULL)
            return vec;
        que1.push(root);
        while (!que1.empty() || !que2.empty()) {
            if (!que1.empty()) {
                vector<int> vec_temp;
                while(!que1.empty()) {
                    temp = que1.front();
                    if (temp != NULL) {
                        if (temp -> left != NULL)
                            que2.push(temp -> left);
                        if (temp -> right != NULL)
                            que2.push(temp -> right);
                        vec_temp.push_back(temp -> val);
                    }
                    que1.pop();
                }
                sta.push(vec_temp);
            } else if (!que2.empty()) {
                vector<int> vec_temp;
                while (!que2.empty()) {
                    temp = que2.front();
                    if (temp != NULL) {
                        if (temp -> left != NULL)
                            que1.push(temp -> left);
                        if (temp -> right != NULL)
                            que1.push(temp -> right);
                        vec_temp.push_back(temp -> val);
                    }
                    que2.pop();
                }
                sta.push(vec_temp);
            }
        }
        while (!sta.empty()) {
            vec.push_back(sta.top());
            sta.pop();
        }
        return vec;
    }
};

Average of Levels

Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.
Example 1:
Input:
3
/ \
9 20
/ \
15 7
Output: [3, 14.5, 11]
Explanation:
The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11. Hence return [3, 14.5, 11].
Note:
The range of node’s value is in the range of 32-bit signed integer.

/**
 * 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) {
        vector<double> vec;
        queue<struct TreeNode*> que1;
        queue<struct TreeNode*> que2;
        struct TreeNode* temp;
        double num = 0;
        double sum = 0;
        if (root == NULL)
            return vec;
        que1.push(root);
        while (!que1.empty() || !que2.empty()) {
            if (!que1.empty()) {
                num = 0.0;
                sum = 0.0;
                while (!que1.empty()) {
                    temp = que1.front();
                    if (temp -> left != NULL)
                        que2.push(temp -> left);
                    if (temp -> right != NULL)
                        que2.push(temp -> right);
                    num += 1;
                    sum += temp -> val;
                    que1.pop();
                }
                if (num != 0.0)
                    vec.push_back((double)sum / 
                                (double)num);
            }
            if (!que2.empty()) {
                num = 0.0;
                sum = 0.0;
                while (!que2.empty()) {
                    temp = que2.front();
                    if (temp ->left != NULL)
                        que1.push(temp -> left);
                    if (temp -> right != NULL)
                        que1.push(temp -> right);
                    num += 1;
                    sum += temp -> val;
                    que2.pop();
                }
                if (num != 0.0)
                    vec.push_back((double)sum /
                                 (double)num);
            }
        }
        return vec;
    }
};

这道题从本质上来讲和上面的没有什么区别，值得注意的是数据类型需要使用双精度类型才能通过测试，因为每一个数据都是32位的带符号的整数，那么sum表示的范围肯定要大于32位，试过float，最后还是double才通过了测试

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]
]

以下是代码：
除了使用了栈来实现反向输出以外与前面的并没有什么不同

/**
 * 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>> zigzagLevelOrder(TreeNode* root) {
        vector<std::vector<int>> vec;
        queue<struct TreeNode*> que1;
        queue<struct TreeNode*> que2;

        struct TreeNode* temp;
        if (root == NULL)
            return vec;
        que1.push(root);
        while (!que1.empty() || !que2.empty()) {
            if (!que1.empty()) {
                vector<int> vec_temp;
                while(!que1.empty()) {
                    temp = que1.front();
                    if (temp != NULL) {
                        if (temp -> left != NULL)
                            que2.push(temp -> left);
                        if (temp -> right != NULL)
                            que2.push(temp -> right);
                        vec_temp.push_back(temp -> val);
                    }
                    que1.pop();
                }
                vec.push_back(vec_temp);
            } else if (!que2.empty()) {
                vector<int> vec_temp;
                stack<int> sta;
                while (!que2.empty()) {
                    temp = que2.front();
                    if (temp != NULL) {
                        if (temp -> left != NULL)
                            que1.push(temp -> left);
                        if (temp -> right != NULL)
                            que1.push(temp -> right);
                        sta.push(temp -> val);
                    }
                    que2.pop();
                }
                while (!sta.empty()) {
                    vec_temp.push_back(sta.top());
                    sta.pop();
                }
                vec.push_back(vec_temp);
            }
        }

        return vec;
    }
};