二叉树的遍历（Java实现）

主要是二叉树的遍历，包括递归遍历和非递归遍历

package util;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

public class BinaryNode<T> {
	/**
	 * 泛型BinaryNode类
	 */
	public T item;
	
	public BinaryNode<T> left,right;//左右子树
	
	public BinaryNode(T item)
	{
		this.item = item;
		left = right = null;
	}	
	public BinaryNode (T item, BinaryNode<T> left, BinaryNode<T> right)
	{
		this.item = item;
		this.left = left;
		this.right = right;
	}

	public T getNodeValue() {
		return item;
	}
	public void setNodeValue(T item) {
		this.item = item;
	}
	public BinaryNode<T> getLeft() {
		return left;
	}
	public void setLeft(BinaryNode<T> left) {
		this.left = left;
	}
	public BinaryNode<T> getRight() {
		return right;
	}
	public void setRight(BinaryNode<T> right) {
		this.right = right;
	}
	
	//判断是否为叶子
	public boolean isLeaf(){
		return (left==null)&&(right==null);
	}
	
	//前序遍历二叉树(递归)
	public List<BinaryNode<T>> toStringPreorder(BinaryNode<T> node){
		List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
		list.add(node);
		if (node.left!=null) {
			list.addAll(toStringPreorder(node.left));
		}
		if (node.right!=null) {
			list.addAll(toStringPreorder(node.right));
		}
		return list;
	}
	//前序遍历二叉树(非递归)
	public List<BinaryNode<T>> toStringPreorderNoRec(BinaryNode<T> node){
		List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
		ArrayDeque<BinaryNode<T>> stack=new ArrayDeque<BinaryNode<T>>();
		while ((node!=null)||!stack.isEmpty()) {
			if (node!=null) {
				list.add(node);
				stack.push(node);
				node=node.left;
			} else {
				node=stack.peek();			
				stack.pop();
				node=node.right;
			}
		}		
		return list;
	}
	
	//中序遍历二叉树
	public List<BinaryNode<T>> toStringInorder(BinaryNode<T> node){
		List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
		if (node.left!=null) {
			list.addAll(toStringPreorder(node.left));
		}
		list.add(node);
		if (node.right!=null) {
			list.addAll(toStringPreorder(node.right));
		}
		return list;
	}
	//中序遍历二叉树(非递归)
	public List<BinaryNode<T>> toStringInorderNoRec(BinaryNode<T> node){
		List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
		ArrayDeque<BinaryNode<T>> stack=new ArrayDeque<BinaryNode<T>>();
		while ((node!=null)||!stack.isEmpty()) {
			if (node!=null) {				
				stack.push(node);
				node=node.left;
			} else {
				node=stack.peek();
				list.add(node);
				stack.pop();
				node=node.right;
			}
		}		
		return list;
	}
	
	//后序遍历二叉树
	public String toStringPostorder(){
		String result="";
		if (left!=null) {
			result += left.toStringPostorder();
		}		
		if (right!=null) {
			result += right.toStringPostorder();
		}
		result += item;
		return result;
	}
	//后序遍历二叉树(非递归)
	/**
	 * 先遍历树的逆后序遍历(根、右、左),在翻转逆后序遍历就是后序遍历二叉树(左、右、根)
	 * @return result栈
	 */
	public ArrayDeque<BinaryNode<T>> toStringPostorderNoRec(BinaryNode<T> node){
		ArrayDeque<BinaryNode<T>> stack=new ArrayDeque<BinaryNode<T>>();
		ArrayDeque<BinaryNode<T>> result=new ArrayDeque<BinaryNode<T>>();
		while ((node!=null)||!stack.isEmpty()) {
			if (node!=null) {
				result.push(node);
				stack.push(node);
				node=node.right;
			} else {
				node=stack.peek();
				stack.pop();
				node=node.left;
			}
		}		
		return result;
	}
	
	//层序遍历(广度优先遍历)
	public List<BinaryNode<T>> toStringLevelOrder(){
		List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
		Queue<BinaryNode<T>> queue=new ArrayDeque<BinaryNode<T>>();
		queue.offer(this);//root
		while (!(queue.isEmpty())) {
			list.add(queue.peek());
			BinaryNode<T> node=queue.poll();			
			if (node.left != null) {
				queue.offer(node.left);
			}
			if (node.right != null) {
				queue.offer(node.right);
			}
		}
		return list;
	}
	
}