leetcode

题目：Binary Tree Level Order Traversal i ii

i和ii的差别仅在于最后将结果逆序一下就行了，算法上基本相同

个人思路：

1、二叉树的层次遍历，我们一层一层地处理，用一个队列（A队列）将每一层的所有节点按照从左到右的顺序入队

2、待该队列的所有节点都出队，并且用另外一个队列（B队列）接收出队的节点（为下一层节点的处理做准备），则考虑处理下一层节点

3、将B队列的节点逐个出队，考察节点的左孩子和右孩子，若存在则将孩子节点入A队列，如此循环地处理每一层节点，直到A队列为空结束

代码（注释中的代码为i的解）：

#include <stddef.h>
#include <queue>
#include <vector>
#include <deque>
#include <iostream>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution
{
public:
    vector<vector<int> > levelOrder(TreeNode *root)
    {
        /*
        vector<vector<int> > total_result;
        vector<int> level_result;
        queue<TreeNode *> current_level;
        queue<TreeNode *> current_level_bak;

        if (root == NULL)
        {
            return total_result;
        }

        current_level.push(root);

        while (!current_level.empty())
        {
            TreeNode *current_node = current_level.front();
            current_level.pop();
            current_level_bak.push(current_node);
            level_result.push_back(current_node->val);

            if (current_level.empty())
            {
                total_result.push_back(level_result);
                level_result.clear();
                while (!current_level_bak.empty())
                {
                    current_node = current_level_bak.front();
                    current_level_bak.pop();
                    if (current_node->left != NULL)
                    {
                        current_level.push(current_node->left);
                    }
                    if (current_node->right != NULL)
                    {
                        current_level.push(current_node->right);
                    }
                }
            }
        }

        return total_result;
        */

        vector<vector<int> > total_result;
        deque<vector<int> > temp_result;
        vector<int> level_result;
        queue<TreeNode *> current_level;
        queue<TreeNode *> current_level_bak;

        if (root == NULL)
        {
            return total_result;
        }

        current_level.push(root);

        while (!current_level.empty())
        {
            TreeNode *current_node = current_level.front();
            current_level.pop();
            current_level_bak.push(current_node);
            level_result.push_back(current_node->val);

            if (current_level.empty())
            {
                temp_result.push_front(level_result);
                level_result.clear();
                while (!current_level_bak.empty())
                {
                    current_node = current_level_bak.front();
                    current_level_bak.pop();
                    if (current_node->left != NULL)
                    {
                        current_level.push(current_node->left);
                    }
                    if (current_node->right != NULL)
                    {
                        current_level.push(current_node->right);
                    }
                }
            }
        }

        while (!temp_result.empty())
        {
            total_result.push_back(temp_result.front());
            temp_result.pop_front();
        }

        return total_result;
    }
};

int main()
{
    TreeNode *root = new TreeNode(3);
    root->left = new TreeNode(9);
    root->right = new TreeNode(20);
    root->right->left = new TreeNode(15);
    root->right->right = new TreeNode(7);

    Solution s;
    vector<vector<int> > result = s.levelOrder(root);

    for (int i = 0; i < result.size(); ++i)
    {
        vector<int> level = result[i];
        for (int j = 0; j < level.size(); ++j)
        {
            cout << level[j] << ",";
        }
        cout << endl;
    }

    system("pause");

    return 0;
}

网上的思路也大致是这样