二叉树之层次遍历

题目：

给出一棵二叉树，返回其节点值的层次遍历（逐层从左往右访问）

您在真实的面试中是否遇到过这个题？ 

Yes

样例

给一棵二叉树 {3,9,20,#,#,15,7} ：

  3
 / \
9  20
  /  \
 15   7

返回他的分层遍历结果：

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

思路：使用队列aQueue，一开始先把根节点插进去，定义i=1，j=0，当aQueue不为空时，提取出来队列头结点并删掉头结点，如果这个结点为空，i++，不为空，则把值插入到ss中，并且将左右结点插入到aQueue，接下来如果i等于ss中数据个数加j，也就是这一层已经遍历完了，就把ss插入到aa中去，清空ss，i=i*2，j=j*2,。最后返回aa。

代码：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */
 
 
class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Level order a list of lists of integer
     */
public:
    /*vector<int> ss;
    vector<vector<int>> aa;*/
    vector<vector<int>> levelOrder(TreeNode *root) {
        // write your code here
        vector<int> ss;
        vector<vector<int>> aa;
        queue<TreeNode *> aQueue;
        if(root==NULL) return aa;
        aQueue.push(root);
        int i=1,j=0;
        while(!aQueue.empty())
        { TreeNode *p=aQueue.front();
          aQueue.pop();
          if(p==NULL)
          { j++;}
          else {
              ss.push_back(p->val);
              aQueue.push(p->left);
              aQueue.push(p->right);
          }
          if(i==(ss.size()+j)&&ss.size()!=0)
          { aa.push_back(ss);
            ss.clear();
            i=i*2;
            j=j*2;
          }
        }
        return aa;
    }
};
        /*queue<TreeNode *> bQueue;
        TreeNode *pointer=root;
        if(pointer)
           bQueue.push(pointer);
        while(!bQueue.empty())
        { aQueue=bQueue;
        while(!aQueue.empty())
        { pointer=aQueue.front();
        aQueue.pop();
            ss.push_back(pointer->val);
        if(pointer->left)
           bQueue.push(pointer->left);
        if(pointer->right)
           bQueue.push(pointer->right);
        }
        aa.push_back(ss);
        }
        return aa;*/
        /*TreeNode *pointer=root;
        if(pointer)
           aQueue.push(pointer);
        while(1)
        {  TreeNode *T=aQueue.front();
            while(!aQueue.empty())
            {//if(aQueue.front()==T) break;
             pointer=aQueue.front();
              //aQueue.pop();
                ss.push_back(pointer->val);
              if(aQueue.front()==T) {aQueue.pop();break;}
              aQueue.pop();
              if(pointer->left)
                  aQueue.push(pointer->left);
              if(pointer->right)
                  aQueue.push(pointer->right);
            }
            aa.push_back(ss);
            if(aQueue.empty()&&ss.size()!=1){ss.clear(); break;}
        }
        return aa;
    }
};*/

感想：一开始想着使用两个队列做，就省去了i和j的判断等，但是内存超限制了，于是又修改了一下，不用俩个队列了，但还是内存超限制了，最后不得已用了这个算法，过了。感觉以后应该以最优为目标，而不是以省事为目标。