二叉树的层序遍历

102 二叉树的层序遍历

这个题目和书上不一样的地方就是不同的层的放在一个vector中，每层可以区分开。于是，我们可以定义一个count，用来计算每一层的结点数。

用队列来存放树的结点。

C++代码：

/**
 * 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>> levelOrder(TreeNode* root) {
        vector<vector<int>> v1;
        
        if(root==NULL){//首先判断根节点是否为空
            return v1;
        }
        
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int count = q.size();//当下面的循环结束一次，此时queue中的所有结点刚好是下一层的是所有结点，计算数量。
            vector<int> v;
            while(count > 0){//这个循环完，就相当于一层结束。
                TreeNode* cur = q.front();
                v.push_back(cur->val);//要是没有前面判断root根节点是否为空的操作，当根节点为空时，这一步就会出现空指针现象。
                
                q.pop();
                
                if(cur->left != NULL){
                    q.push(cur->left);
                }
                if(cur->right != NULL){
                    q.push(cur->right);
                }
                count--;
            }
            v1.push_back(v);
        }
        return v1;
    }
};

Java代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root == null){
            return new ArrayList<>();
        }
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int count = queue.size();
            List<Integer> list = new ArrayList<Integer>();
            while(count>0){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
                count--;
            }
            res.add(list);
        }
        return res;
    }
}

Java中对于Queue来说，就是一个FIFO（先进先出）的队列，添加元素只能在队尾，移除只能在队首。

对于这一组方法，成功返回true，在操作失败时抛出异常，这是与下面一组方法的主要区别。

add(E e)：添加一个元素到队尾

remove()：获取队首的元素，并从队列中移除

element()：获取队首的元素，但不从队列中移除

这一组，成功返回true，失败时返回一个特殊值(取决于操作，为NULL或false)，offer(E e)操作是专为容量受限的队列实现而设计的；在大多数实现中，插入操作不会失败。

offer(E e)：添加一个元素到队尾

poll()：获取队首的元素，并从队列中移除

peek()：获取队首的元素，但不从队列中移除