【队列.】

二叉树层序遍历-力扣 102 题

 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        List<List<Integer>> result = new ArrayList<>();//当root为null时返回的result为初始化的值即为null
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root != null){
            queue.add(root);
        }
        
        while(!queue.isEmpty()){

            int n = queue.size();
            List<Integer> level = new ArrayList<>();
            for(int i =0; i<n; i++){
                TreeNode node = queue.poll();
                level.add(node.val);
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
            }
            result.add(level);
        }
        return result;


    }
}

当root不为空时将root入队，当root为空时则返回的result为初始化的对象默认为null

双端队列

双端队列的实现可以看作队头（链表为头插，数组为索引减1然后存值），类似栈；队尾（链表为尾插，数组为先存值然后索引+1）类似队列。遍历都是从head到tail。
注意点：数组实现的话，如果存储的是基本类型，那么无需考虑内存释放，因为它里面本身存的就是数据本身，不用的话索引别去找就ok，但如果存储的是引用类型，应当设置该位置的引用为 null，以便内存及时释放，因为数组里面存的是引用数据类型，它指向内存的其他地方，不设置为null的话垃圾不能回收，导致内存泄漏。

二叉树 Z 字层序遍历-力扣 103 题

思路：二叉树的层序遍历的改进，每层区分奇数还是偶数，奇数从左到右（双端队列依次尾部加入），偶数从右到左（双端队列依次头部加入）。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {

        List<List<Integer>> result = new ArrayList<>();
        LinkedList<TreeNode> dequeue = new LinkedList<>();
        boolean odd = true;
        int c1 = 1;//当前层节点数
        if(root != null){
            dequeue.offer(root);
        }
        while(!dequeue.isEmpty()){
            
            LinkedList<Integer> level = new LinkedList<>();           
            int c2 = 0;
            for(int i =0; i<c1; i++){
                TreeNode node = dequeue.poll();
                if(odd){
                    level.offerLast(node.val);
                }else{
                    level.offerFirst(node.val);
                }
                

                if(node.left != null){
                    dequeue.offer(node.left);
                    c2++;
                }

                if(node.right != null){
                    dequeue.offer(node.right);
                    c2++;
                }
            }
            odd = !odd;
            c1 = c2;
            result.add(level);
            
        }
        return result;

    }
}

结论：二叉树的层序遍历队列中只会存在本层与下一层的节点，出队时目前只有本层元素，本层元素依次出队，并且对每个出队的元素判断其左右孩子，存在的话入队，所以可以用一个变量计算第n层节点数量，for循环遍历本层节点的同时将下层节点依次入队，此时可以用另一个变量计算下层节点数量。