【校招算法】1-1二叉树的打印（遍历）

二叉树打印

二叉树打印一般通过队列完成
下面的二叉树普通打印（不换行）结果：12345678
按层打印（换行，有层号）结果：
Level1:1
Level2:23
Level3:456
Level4:78

队列补充知识

1. 队列先进先出，队尾入队，队头出队；
2. 常用函数：
   （1）queue.offer(element) //队尾插入元素，返回true/false，插入成功返回true
   （2）queue.poll() //删除队头元素，返回被删除的元素值
   （3）queue.peek() //返回队头元素，但不删除队头
   （4）queue.size() //队列大小
   （5）queue.isEmpty() //队列判空
3. Java中，Queue接口通过LinkedList类实现，
   创建队列对象形式：Queue<参数类型> queue=new LinkedList<参数类型>();

普通打印（不换行）

1. 创建队列存放树结点，将根结点插入进去；
2. 定义一个临时变量，代表当前的队头元素
3. 输出当前队头元素（即2中的临时变量），
   若队头元素有左/右结点，就把左/右结点从队尾插入，
   不断输出当前队头元素，直到队列为空
4. 最终输出的序列即为二叉树的打印结果（一整行打印出来）

按层打印（换行）

按层打印的关键是表示出何时换行，使用变量last和nlast表示出换行
last: 当前正在打印行的最右结点
nlast: 下一行的最右结点----->nlast是队列中最新插入的元素
当root=last，说明接下来需要换行了
换行之后，令 last=nlast ，即可继续下一行的打印

1. 先将根结点弹出队里，输出，这就是第一行
   若根结点左/右结点不为空吗，就插入队列，记得将队尾元素赋值给nlast !!!
   2.当 root=last且队列非空就换行，换行后令last=nlast，即可继续下一行的打印。

实现代码

TreeNode类：（定义树结构）

package BinaryTree;

//树结构定义，供整个包的类使用
public class TreeNode {

	int val=0;
	TreeNode left=null;
	TreeNode right=null;
	TreeNode(int val){
		this.val=val;
	}
}

BT_print类：（实现普通打印和按层打印）

package BinaryTree;

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

//打印（遍历）二叉树------普通打印+按层打印
public class BT_print {

	//普通打印函数，不换行
	public static void common_print(TreeNode root) {
		if(root==null) return;
		Queue<TreeNode> q=new LinkedList<TreeNode>();   //创建队列 存放二叉树结点
		q.offer(root);                                  //将根结点加入队列中
		TreeNode curNode;                               //定义临时结点--代表当前队首元素
		
		while(!q.isEmpty()) {              //队列空了代表遍历结束
			curNode=q.poll();              //当前队首元素出队，并输出出队的元素值
			System.out.print(curNode.val);
			
			if(curNode.left!=null) {       //当前队首元素存在左结点，就将之加入队列
				q.offer(curNode.left);
			}
			if(curNode.right!=null) {      //当前队首元素存在右结点，就将之加入队列
				q.offer(curNode.right);
			}
		}
		
	}
	
	//按层打印，每层结束会换行接着打印-----关键是表示出  何时换行
	public static void sequence_print(TreeNode root) {
        if(root==null) return;
        Queue<TreeNode> q=new LinkedList<TreeNode>();
        q.offer(root);
        int level=1;     //每层的序号
        System.out.print("Level"+(level++)+":");
        
        TreeNode last=root;       //正在打印的当前行最右边结点----遇到last说明该换行了
        TreeNode nlast=null;      //下一行的最右结点----队列中最新加入的结点
                                  //换行之后，只要令  last=nlast ，就可以继续下一行的打印
        while(!q.isEmpty()) {
        	root=q.poll();
        	System.out.print(root.val+" ");
        	if(root.left!=null) {
        		q.offer(root.left);
        		nlast=root.left;             //nlast是队列中最新插入的元素
        	}
        	if(root.right!=null) {
        		q.offer(root.right);
        		nlast=root.right;
        	}
        	//遍历到当前行的最右结点，换行
        	if(root==last && !q.isEmpty()) {   //root==last说明需要换行了
        		System.out.print("\nLevel"+(level++)+":"); 
        		last=nlast;  //记录下一行的最右结点，继续下一行的打印
        	}
        }
        
        
        
	}
	
	
	

	/*二叉树：
	 *        1
	 *    2        3
	 * 4        5      6
	 *        7   8
	 */
	//测试
	public static void main(String[] args) {
		//创建8个结点
		TreeNode node1=new TreeNode(1);
		TreeNode node2=new TreeNode(2);
		TreeNode node3=new TreeNode(3);
		TreeNode node4=new TreeNode(4);
		TreeNode node5=new TreeNode(5);
		TreeNode node6=new TreeNode(6);
		TreeNode node7=new TreeNode(7);
		TreeNode node8=new TreeNode(8);
		
		//连接结点
		node1.left=node2;
		node1.right=node3;
		node2.left=node4;
		node3.left=node5;
		node3.right=node6;
		node5.left=node7;
		node5.right=node8;
		
		//调用函数
		common_print(node1);
        System.out.println();
		sequence_print(node1);
	}

}

输出结果：
12345678
Level1:1
Level2:2 3
Level3:4 5 6
Level4:7 8