二叉树_层次遍历

1.普通层次遍历/广度优先遍历（栈）

1）根入队列
2）持续到队列为空结束
     I.取队首元素
     II.把取出来结点的左右孩子结点入队列

import java.util.LinkedList;
import java.util.Queue;

public class LevelOrder {
    private static class Node {
        char val;
        Node left;
        Node right;
        Node(char val) {
            this.val = val;
        }
    }
    
    public static void levelOrder(Node root) {
        if (root == null) {
            return;
        }
        Queue<Node> queue = new LinkedList<>(); //用链表充当队列
        queue.offer(root);   //尾插/入队
        while (!queue.isEmpty()) {   //队列不为空不能写成 queue！=null
            Node front = queue.poll();   //取队首元素
            System.out.println(front.val);
            
            //孩子节点入队列
            if (front.left != null) {
                queue.offer(front.left);
            }
            if (front.right != null) {
                queue.offer(front.right);
            }
        }
    }
    
   public static Node buildTree() {
        Node a = new Node('A');
        Node b = new Node('B');
        Node c = new Node('C');
        Node d = new Node('D');
        Node e = new Node('E');
        Node f = new Node('F');
        Node g = new Node('G');
        Node h = new Node('H');

        a.left = b; a.right = c;
        b.left = d; b.right = e;
        c.left = f; c.right = g;
        e.right = h;
        
        return a;
    }
    
   public static void main(String[] args) {
        Node root = buildTree();
        levelOrder(root);
    }
}

测试结果：

注意：队列不为空不能写成 queue != null ，queue = null表示 queue 没有指向任何一个引用。

在此程序最开始Queue< Node > queue = new LinkedList<>(); queue有明确指向，永远不可能 = null；如果要判断队列中没有任何一个元素，应该调用queue.isEmpty() 来判断。

2.层次遍历，并返回层数

public class LevelOrder {
 private static class NodeLevel {
        public Node node;
        public int level; //层数
        NodeLevel(Node node, int level) {
            this.node = node;
            this.level = level;
        }
    }
    
   public static void levelOrder2(Node root) {
        if (root == null) {
            return;
        }
        Queue<NodeLevel> queue = new LinkedList<>();
        queue.offer(new NodeLevel(root, 1)); //根入队 层数1
        while (!queue.isEmpty()) {
            NodeLevel front = queue.poll(); //取队首元素
            System.out.print(front.level + ":" + front.node.val + "   "); //打印结点val和所在层数
            if (front.node.left != null) {
                queue.offer(new NodeLevel(front.node.left,front.level + 1)); //孩子结点层数+1
            }
            if (front.node.right != null) {
                queue.offer(new NodeLevel(front.node.right, front.level + 1));
            }
        }
    }
    
    public static void main(String[] args) {
        Node root = buildTree();
        levelOrder2(root);
    }
 }
  

测试结果：

注意：队列插入不能这样写queue.offer(root,1) //报错，应该先new一个NodeLevel的对象出来 ，调构造方法完成对象的创建。

正确写法：queue.offer(new NodeLevel(root, 1))

3.OJ题目：二叉树的层次遍历

题目链接：二叉树的层次遍历

class Solution {
    public static class NL{
            TreeNode node;
            int level;
            NL(TreeNode node,int level){
                this.node=node;
                this.level=level;
            }
        }
    public List<List<Integer>> levelOrder(TreeNode root) {        
        List<List<Integer>> ret = new ArrayList<>();
        Queue<NL> queue = new LinkedList<>();
        if(root==null){
            return ret;
        }
        queue.offer(new NL(root,1));
        while(!queue.isEmpty()){
            NL front = queue.poll();
            if(ret.size()==front.level-1){ 
                ret.add(new ArrayList<Integer>());
            }
            List<Integer> list = ret.get(front.level-1);
            list.add(front.node.val);
            
            if (front.node.left != null) {
                queue.offer(new NL(front.node.left,front.level + 1));
            }
            if (front.node.right != null) {
                queue.offer(new NL(front.node.right,front.level + 1));
            }
        }
        return ret;
    }
}

注意：刚开始的ret是空的，不能直接ret.get(front.level-1); //下标错误，层数-1 = ret.size()，应该插入一个个ArrayList ret.add(new ArrayList< Integer >());。