JAVA 二叉树的层序遍历

什么是层序遍历 ？

今天在做题时发现原来二叉树还有一种遍历叫做 层序遍历

最直接就是直接拆字，按一层一层的顺序遍历的就叫做层序遍历

---

便捷实现二叉树层序遍历：

需要用到队列Queue

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

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int value) {
        this.value = value;
    }
}

public class Main {
	//levelOrder创建层序遍历方法
    public static void levelOrder(TreeNode root) {
        if (root == null) return;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);//offer() 方法用于将元素插入到队列中
        
        while (!queue.isEmpty()) {//当队列不为空时
            TreeNode node = queue.poll();
            //queue.poll() 是从队列 queue 中移除并返回队列的头部元素。第一次执行时，将根节点取出。
            System.out.print(node.value + " ");

            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

    public static void main(String[] args) {
        // 构造一个示例二叉树
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(7);

        System.out.println("层序遍历结果：");
        levelOrder(root);//调用层序方法
    }
}

 关于如何理解这个levelorder方法：

例如我们输入1作为root

第一次那么TreeNode node = queue.poll();这个node相当于一个tep，此时queue中只有root，那么输出root的value即1。

第二次，查看root的子节点是否为空，例如其分别为2、3，那么将2、3载入queue，接着输出2 。

第三次，检查2、3的子节点，例如为4、5、6、7，然后将其载入queue，输出3 。

第四次，假设我们只有三层，那么输入4，然后两个if就都不运行了。

第五第六第七次，输出5、6、7，层序遍历完成

---

深入二叉树层序遍历（快速建立二叉树并层序输出）

 通常我们不会使用如上那样的办法去创建一个二叉树

快速建立二叉树并层序输出 可以分为几个部分

创建一个二叉树类

创建一个快读类

写一个层序输出方法

写一个创建二叉树方法

import java.util.Queue;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.LinkedList;

class TreeNode{
	int value;
	TreeNode left;
	TreeNode right;
	TreeNode(int value){
		this.value = value;
	}
}
public class Main{
	public static void levelOrder(TreeNode root) {
		if(root==null)return;
		
		Queue<TreeNode> queue = new LinkedList<TreeNode>();
		queue.offer(root);
		
		while(!queue.isEmpty()) {
			TreeNode node = queue.poll();
			System.err.print(node.value);
			if(node.left!=null) {
				queue.offer(node.left);
			}
			if(node.right!=null) {
				queue.offer(node.right);
			}
		}
	}
	public static TreeNode BuildTree(int[] values) {
		if(values.length==0) return null;            //若数组为空，则停止运行
		
		TreeNode root = new TreeNode(values[0]);
		Queue<TreeNode> queue = new LinkedList<TreeNode>();
		queue.offer(root);                           //其实操作和层序遍历差不多，都是使用队列将其储存起来
		
		for (int i = 1; i < values.length-1; i+=2) {
			TreeNode node = queue.poll();
			node.left = new TreeNode(values[i]);
			queue.offer(node.left);
			if(i+1<values.length) {                  //保证数组不会出错
				node.right = new TreeNode(values[i+1]);
				queue.offer(node.right);
			}
		}
		return root;
	}
	public static void main(String[] args)throws IOException {
		Read r = new Read();                         //创建快读对象
		
		int n = r.NextInt();
		int[] nums = new int[n];
		for (int i = 0; i < nums.length; i++) {
			int num = r.NextInt();
			nums[i]=num;
		}                                           //用创建的数组中的数据建立一个二叉树
		TreeNode tree1 = BuildTree(nums);           //调用建立二叉树方法
		
		levelOrder(tree1);                          //调用层序遍历方法
	}
}

//快读类
class Read{
	StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	public int NextInt()throws IOException {
		st.nextToken();
		return (int)st.nval;
	}
}