【数据结构和算法分析】二叉树的遍历

二叉树的遍历

二叉树基本概念：

在计算机科学中，树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按分支关系组织起来的结构。二叉树是每个结点最多有两个子树的有序树。子树通常被称为 “左子树” 和 “右子树”，二叉树常被用于实现二叉查找树和二叉堆。

二叉树的遍历：

二叉树的遍历大致分为先根遍历，中根遍历，后根遍历，层次遍历。按照具体的算法又可分为递归和非递归的，

代码如下：

import java.util.LinkedList;
import java.util.Stack;


public class BinaryTree {
	
	/*
	 * 测试，打印结果
	 */
	public static void main(String[] args){				
		BinaryTreeMade tree = maketree();
		
		System.out.print("先序遍历（非递归）：");
		nonrecursion_preorder(tree.root);
		System.out.println();
		
		System.out.print("先序遍历（递    归）：");
		preorder(tree.root);
		System.out.println();
		
		System.out.print("中序遍历（非递归）：");
		nonrecursion_inorder(tree.root);
		System.out.println();
		
		System.out.print("中序遍历（递    归）：");
		inorder(tree.root);
		System.out.println();
		
		System.out.print("后序遍历（非递归）：");
		nonrecursion_postorder(tree.root);
		System.out.println();
		
		System.out.print("后序遍历（递    归）：");
		postorder(tree.root);
		System.out.println();
		
		System.out.print("层次遍历：");
		level_order(tree.root);
	}
	
	/*
	 * 构造二叉树，根节点是                  a
	 * 根节点的左右节点是              b          c
	 * b,c的左右节点分别是          d     e    f     g
	 */
	public static BinaryTreeMade maketree(){

		BinaryNode a7 = new BinaryNode('g',null,null);
        BinaryNode a6 = new BinaryNode('f',null,null);
        BinaryNode a5 = new BinaryNode('e',null,null);
        BinaryNode a4 = new BinaryNode('d',null,null);
        BinaryNode a3 = new BinaryNode('c',a6,a7);
        BinaryNode a2 = new BinaryNode('b',a4,a5);
        BinaryNode a1 = new BinaryNode('a',a2,a3);
       		
		BinaryTreeMade tree = new BinaryTreeMade(a1);
		return tree;
		
	}
	
	/*
	 * 递归的先根遍历
	 */
	public static void preorder(BinaryNode node){
		if (node!=null) {
			System.out.print(node.element+"  ");
			preorder(node.lefttree);
			preorder(node.righttree);	
		}
	}
	/*
	 * 递归的中根遍历
	 */
	public static void inorder(BinaryNode node){
		if (node!=null) {
			inorder(node.lefttree);
			System.out.print(node.element+"  ");
			inorder(node.righttree);	
		}
	}
	/*
	 * 递归的后根遍历
	 */
	public static void postorder(BinaryNode node){
		if (node!=null) {
			postorder(node.lefttree);
			postorder(node.righttree);
			System.out.print(node.element+"  ");	
		}	
	}
    /*
     * 非递归的先根遍历
     */
	public static void nonrecursion_preorder(BinaryNode node){
		Stack<BinaryNode> stack = new Stack<BinaryNode>();
		BinaryNode b = node;
		while(b!=null||!stack.isEmpty()){
			while (b!=null) {
				System.out.print(b.element+ "  ");
				stack.push(b);
				b = b.lefttree;
			}
			if (!stack.isEmpty()) {
				b = stack.pop();
				b = b.righttree;
			}	
			else {
				return;
			}
		}
	}
    /*
     *非递归的中跟遍历
     */
	public static void nonrecursion_inorder(BinaryNode node){
		Stack<BinaryNode> stack = new Stack<BinaryNode>();
		BinaryNode b = node;
		for ( ; ; ) {
			while (b!=null) {
				stack.push(b);
				b = b.lefttree;
			}
			if (!stack.isEmpty()) {
				b = stack.pop();
				System.out.print(b.element+"  ");
				b = b.righttree;
			}
			else {
				return;
			}
		}
	}
    /*
     * 非递归的后跟遍历
     */
	public static void nonrecursion_postorder(BinaryNode node){
		Stack<BinaryNode> stack = new Stack<BinaryNode>();
		BinaryNode b = node;
		BinaryNode tmp = null;
		while(b!=null||!stack.isEmpty()){	
			while(b!=null){
				stack.push(b);
				b = b.lefttree;
			}
			if (!stack.isEmpty()) {
				tmp = stack.pop();
				if (tmp.isfirst == true) {
					tmp.isfirst = false;
					stack.push(tmp);
					b = tmp.righttree;
				}else {
					System.out.print(tmp.element+"  ");		
				}
			}		
		}	
	}
	/*
	 * 层次遍历
	 */
	public static void level_order(BinaryNode node){

		LinkedList<BinaryNode> linkedList = new LinkedList<BinaryNode>();
		BinaryNode b = node;

		while (b!=null) {
			System.out.print(b.element+"  ");
			if (b.lefttree!=null) {
				linkedList.add(b.lefttree);
			}
			if (b.righttree!=null) {
				linkedList.add(b.righttree);
			}		 		    
			b = linkedList.get(0);		
		    linkedList.remove(0);   
		    if (linkedList.size()==0) {
		    	System.out.print(b.element+"  ");
		    	break;
			}	
		}
	}
}

/*
 * 二叉树的节点类
 */
class BinaryNode{
	Object element;
	BinaryNode lefttree;
	BinaryNode righttree;
	boolean isfirst;
	
    public BinaryNode(Object e,  BinaryNode l, BinaryNode r){
    	element = e;  
    	lefttree = l;  
    	righttree = r; 
    	isfirst = true;
    }	 
}

/*
 * 二叉树的构造类
 */
class BinaryTreeMade{
	BinaryNode root;
	
	public BinaryTreeMade(BinaryNode root){
		this.root = root;
	}	
}