[LeetCode] 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,#,#,15,7},

    3
   / 
  9  20
    /  
   15   7

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

 

 

 

1 BFS迭代，借用之前min depth和maxdepth of bianry tree 的框架

struct newNode{
    TreeNode * node;
    int         dep; // current depth
};

class Solution {
    public:
        vector< vector<int> > levelOrder(TreeNode *root) {
            vector<vector<int> > result;
            if(root == NULL) return result;

            vector<int> levelRes;
            queue<newNode*> que;
            int curDep ;

            newNode *p = new newNode;
            p->node = root;
            curDep =  p->dep = 1;
            que.push(p);

            while( !que.empty())
            {
                p= que.front();
                que.pop();

                TreeNode *pNode = p->node;
                int dep = p->dep;

                if(curDep == dep)
                {
                    levelRes.push_back(pNode->val);
                }
                else
                {
                    result.push_back(levelRes);
                    levelRes.clear();
                    levelRes.push_back(pNode->val);
                    curDep++;
                }

                if(pNode->left != NULL)
                {
                    newNode *tmp = new newNode;
                    tmp->node = pNode->left;
                    tmp->dep = dep + 1;
                    que.push(tmp);
                }

                if(pNode->right != NULL)
                {
                    newNode *tmp = new newNode;
                    tmp->node = pNode->right;
                    tmp->dep = dep + 1;
                    que.push(tmp);
                }

            }

            // add the last level
            result.push_back(levelRes);

            return  result;
        }

};

2 DFS 也可以解决，就是在DFS中每次要传入一个dep，然后根据dep将数据加入到对应的vector中。

 DFS 递归（使用前序遍历框架）

class Solution {
    private:
        vector<vector<int> > m_result;
    public:
        void solve(int dep, TreeNode *root)
        {   
            if (root == NULL)
                return;

            if (m_result.size() > dep)
            {   
                m_result[dep].push_back(root->val);
            }   
            else
            {   
                vector<int> tmp;
                tmp.push_back(root->val);
                m_result.push_back(tmp);
            }   

            solve(dep + 1, root->left);
            solve(dep + 1, root->right);
        }   

        vector<vector<int> > levelOrder(TreeNode *root) {
            // Start typing your C/C++ solution below
            // DO NOT write int main() function
            m_result.clear();
            solve(0, root);

            return m_result;
        }   
};

DFS 迭代

struct newNode{
    TreeNode * node;
    int         dep; // current depth
};

class Solution {
    private:
    //vector<vector<int> > retsult;
    public:
        vector< vector<int> > levelOrder(TreeNode *root) {

            vector<vector<int> > result;
            if(root == NULL) return result;

            vector<int> levelRes;
            stack<newNode*> s;

            newNode *p = new newNode;
            p->node = root;
            p->dep = 0;
            s.push(p);

            while (!s.empty()) {
                p = s.top();
                s.pop();

                TreeNode *pNode = p->node;
                int dep = p->dep;

                if( dep + 1 > result.size() ) // new a vector
                {
                    vector<int> tmp;
                    tmp.push_back(pNode->val);
                    result.push_back(tmp);
                }
                else // vector exists
                {
                    result[dep].push_back(pNode->val);
                }
　　　　　　　　　　//注意先压入右子树，再压入左子树，弹出的时候先弹出左子树，在弹出右子树，实现前序遍历，Root->left->right
                if(pNode->right != NULL)
                {
                    newNode *tmp = new newNode;
                    tmp->node = pNode->right;
                    tmp->dep = dep + 1;
                    s.push(tmp);
                }

                if(pNode->left != NULL)
                {
                    newNode *tmp = new newNode;
                    tmp->node = pNode->left;
                    tmp->dep = dep + 1;
                    s.push(tmp);
                }
            }
            return result;
        }
};

 3 双queue法

class Solution {
    public:
        vector<vector<int> > levelOrder(TreeNode *root)
        {
            queue<TreeNode*> q1;
            queue<TreeNode*> q2;
            vector<vector<int> > res;

            if(root != NULL)
            {
                q1.push(root);
                res.push_back(vector<int> ());
            }

            int depth = 0;
            

            while(!q1.empty())
            {
                TreeNode * p = q1.front();
                q1.pop();

                res[depth].push_back(p->val);

                if(p->left)
                    q2.push(p->left);
                if(p->right)
                    q2.push(p->right);
                if(q1.empty() && !q2.empty())
                {
                    swap(q1, q2);
                    depth ++;
                    res.push_back(vector<int> ());
                }
            }   
            return res;
        }   
};