数据结构与算法_剑指Offer23_从上往下打印二叉树_JAVA实现

如果我有幸使你从我写的剑指offer第二题阅读到现在，并尝试了编写，我有一个个人建议就是您可以尝试有序复习前面的题目，并试图在15分钟到25分钟内完成 2020.05.09

题目

从上往下打印出二叉树的每个结点，同一层的结点按照从左向右的顺序打印。
点击链接

解题思路

类似二叉树遍历的思路，设计一个队列，和一个临时结点，将根结点加入到队列后；进行循环，循环的条件就是队列里没有值啦（说明root结点都已经遍历啦），循环里，先将队列头出栈，然后分别加入出栈结点的左结点，右结点，这样就是从左往右输出啦！

package offer23;

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

class Node{
	int value;
	Node leftChild;
	Node rightChild;
	
	public Node(int value) {
		super();
		this.value = value;
	}
	
	public Node() {
		
	}
}

class Tree{
	Node rootNode = null;
	
	public void insert(Node newNode) {
		if(newNode == null) {
		    throw new RuntimeException("输出参数不合法");
		}
		
		if(rootNode == null) {
			rootNode = newNode;
			return;
		}
		
		Node currentNode = rootNode;
		Node parentNode = null;
		
		while (true) {
			parentNode = currentNode;
			if(currentNode.value < newNode.value) {
				currentNode = currentNode.rightChild;
				if(currentNode==null) {
					parentNode.rightChild = newNode;
					return;
				}
			}else {
				currentNode = currentNode.leftChild;
				if(currentNode==null) {
					parentNode.leftChild = newNode;
					return;
				}
			}	
		}
	}
	
	
	public void order(Node rootNode) {
		if(rootNode == null) {
		    throw new RuntimeException("输出参数不合法");
		}
		
		Queue<Node> queue = new LinkedList<Node>();
		Node currentNode = null;
		queue.add(rootNode);
		
		while (!queue.isEmpty()) {
			currentNode = queue.remove();
			System.out.print(currentNode.value + " ");
			if(currentNode.leftChild != null) {
				queue.add(currentNode.leftChild);
			}
			if(currentNode.rightChild != null) {
				queue.add(currentNode.rightChild);
			}
		}
	}
	public void frontOrder(Node rootNode) {
        if(rootNode != null) {
            System.out.print(rootNode.value + " ");
            frontOrder(rootNode.leftChild);
            frontOrder(rootNode.rightChild);
        } 
    }
}

public class Test {
    public static void main(String[] args) {
        //      8
        //    /    \
        //   6     10
        //  / \    / \
        // 5   7  9  11
        Tree tree = new Tree();
        tree.insert(new Node(8));
        tree.insert(new Node(6));
        tree.insert(new Node(10));
        tree.insert(new Node(5));
        tree.insert(new Node(7));
        tree.insert(new Node(9));
        tree.insert(new Node(11));
        
        tree.frontOrder(tree.rootNode);
        System.out.println();
        tree.order(tree.rootNode);
        System.out.println();
        // 0
        //  \
        //   2
        //    \
        //     4
        //      \
        //       6
        //        \
        //         8
        Tree tree1 = new Tree();
        tree1.insert(new Node(0));
        tree1.insert(new Node(2));
        tree1.insert(new Node(4));
        tree1.insert(new Node(6));
        tree1.insert(new Node(8));
        
        tree1.frontOrder(tree1.rootNode);
        System.out.println();
        tree1.order(tree1.rootNode);
        System.out.println();
        //健壮性测试
        tree1.order(null);
    }
}

运行结果

题目扩展

如何广度优先遍历一个有向图？
这同样也可以基于队列实现。树是图的一种特殊退化形式，从上到下按层遍历二叉树，从本质上来说就是广度优先遍历二叉树。