【leetcode 层序遍历】Binary Tree Level Order Traversal

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

    3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

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

2、分析

二叉树层序遍历，有递归法和迭代法。

注意到题目的输出要求是按层组织节点的，为了便于理解，我们先放宽要求，假如输出格式是【3，9，20，15，7】，下面用迭代法解决这个问题。

迭代法要用到队列，利用队列先进先出的特点。节点存入队列的顺序是：从上层到下层，每层从左到右。

以上面给出的二叉树为例，描述一下迭代法的算法流程：

（队列用q表示，返回结果用result表示）

1、result[    ]    //空

      q[ 3 ]           //存入节点3

2、result[  3  ]    //取出节点3放入result

      q[ 9 , 20 ]           //将节点3的左右孩子存入队列

3、result[  3  9 ]    //取出节点9放入result

      q[ 20 ]           //将节点9的左右孩子存入队列，因为节点9左右孩子均为空，所以没存

4、result[  3  9 20 ]    //取出节点20放入result

      q[ 15 7  ]           //将节点20的左右孩子存入队列

5、result[  3  9 20 15 ]    //取出节点15放入result

      q[  7  ]           //将节点15的左右孩子存入队列，因为节点15左右孩子均为空，所以没存

6、result[  3  9 20 15 7 ]    //取出节点7放入result

      q[  ]           //将节点的左右孩子存入队列，因为节点7左右孩子均为空，所以没存，q为空，结束

下面是代码：

<span style="font-size:18px;">vector<int> levelOrder(TreeNode *root)
{
    vector<int> result;
    if(!root)  return reuslt;  
    
    queue<TreeNode *> q;
    TreeNode *current=root;
    q.push(current);
    while(!q.empty())
    {
        current=q.front();
        q.pop();
        result.push_back(current->val);        //保存队首节点到result，并将其从队列中删除
        
        if(current->left)  q.push(current->left);    //将队首节点的左、右孩子依次存入队列
        if(current->right)  q.push(current->right);
    }
    return result;
}</span>

当然，本题层序遍历返回的结果是vector<vector<int>>类型的，需要将节点按层组织，这就要求我们的程序能够区分哪些节点是哪层的。所以需要对上面的程序进行更改，方法很简单，只要增加一个next队列就行了。这样就用了两个队列，一个存储当前层节点，一个存储下一层节点，就是说current->left和current->right存储到next队列。具体代码见下面迭代法的代码。

3、代码

#递归法

<span style="font-size:18px;">/**
 * Definition for binary tree
 * 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>> result;
        traverse(root,1,result);   //根节点属第一层
        return result;
    }
private:
       void traverse(TreeNode *root,size_t level,vector<vector<int>> &result)    //必须是result的引用，不然result的值永远不会改变
       {
           if(!root) return;
           /*判断result需不需要新增一层存储传入的节点root，即判断root是不是下一层的*/
           if(level>result.size())   result.push_back(vector<int>());    //vector<int>()表示空的容器，注意()的这种用法
           
           result[level-1].push_back(root->val);  //result[level-1]表示第level层的容器
           traverse(root->left,level+1,result);
           traverse(root->right,level+1,result);
       }
};</span>

#迭代法

<span style="font-size:18px;">/*
层序遍历
迭代法，利用队列，由于这里返回结果是要按层的,所以可以用两个队列current、next，分别存储当前层和下一层节点,每次遍历current队列里的节点，并将下  一层节点存进队列next
*/
class Solution {
public:
    vector<vector<int> > levelOrder(TreeNode *root) {
        vector<vector<int>> result;
        if(!root)  return result;
        vector<int> levelNode;
        queue<TreeNode *> currentQueue,nextQueue;
        TreeNode *currentNode=root;
        currentQueue.push(currentNode);
      while(!currentQueue.empty())
      {
        while(!currentQueue.empty())       /*存放当前层节点的队列不为空，则不断地取出队首节点，同时把下一层节点存进next队列*/
        {
            currentNode=currentQueue.front();
            currentQueue.pop();
            levelNode.push_back(currentNode->val);
            
            if(currentNode->left)  nextQueue.push(currentNode->left);
            if(currentNode->right)  nextQueue.push(currentNode->right);
        }
        
        result.push_back(levelNode);    //将每一层的结果push进result，然后清空，以便存储下一层的节点
        levelNode.clear();
        
        swap(currentQueue,nextQueue);
      }
      
      return result;
    }
};</span>