基础算法001---二叉树遍历 Java

源代码：

https://github.com/SunnyLoveMaggie/Algorithm/tree/master/src/Algorithm/Basic/BTree

Node:

public class Node<T extends Comparable<T>> {
	private T data;
	private Node<T> lNode;
	private Node<T> rNode;
	Node(T data){
		this.data = data;
		this.lNode = null;
		this.rNode = null;
	}
	/**
	 * @return the data
	 */
	public T getData() {
		return data;
	}
	/**
	 * @param data the data to set
	 */
	public void setData(T data) {
		this.data = data;
	}
	/**
	 * @return the lNode
	 */
	public Node<T> getlNode() {
		return lNode;
	}
	/**
	 * @param lNode the lNode to set
	 */
	public void setlNode(Node<T> lNode) {
		this.lNode = lNode;
	}
	/**
	 * @return the rNode
	 */
	public Node<T> getrNode() {
		return rNode;
	}
	/**
	 * @param rNode the rNode to set
	 */
	public void setrNode(Node<T> rNode) {
		this.rNode = rNode;
	}
	
}

Tree:

public class BTree<T extends Comparable<T>> {
	private Node<T> root;
	private BTreeTravelable<T> travelMethod;
	public void insert(T data){
		Node<T> node = new Node<T>(data);
		if(root == null){
			root = node;
			return;
		}
		Node<T> cur = root;
		Node<T> preNode = null;
		while(cur!=null){
			if(cur.getData().compareTo(node.getData()) < 0){
				preNode = cur;
				cur = cur.getrNode();
			} else if(cur.getData().compareTo(node.getData()) > 0){
				preNode = cur;
				cur = cur.getlNode();
			} else {
				return; // Have already include the data, no need to insert
			}
		}
		if(preNode.getData().compareTo(node.getData()) < 0){
			preNode.setrNode(node);
		} else{
			preNode.setlNode(node);
		}
	}

	public void travelTree(){
		travelMethod.travel(root);
	}

	public void setTravelMethod(BTreeTravelable<T> method){
		travelMethod = method;
	}
}

遍历接口：

public interface BTreeTravelable<T extends Comparable<T>> {
	public void travel(Node<T> root);
}

前序遍历（非递归）：

public class PreOrder <T extends Comparable<T>> implements BTreeTravelable<T>{

	/* (non-Javadoc)
	 * <p>Title: travel</p> 
	 * <p>Description: </p> 
	 * @param root 
	 * @see Algorithm.BTree.BTreeTravelable#travel(Algorithm.BTree.Node) 
	 */
	@Override
	public void travel(Node<T> root) {
		LinkedList<Node <T>> stack = new LinkedList<Node <T>>();
		stack.push(root);
		while(!stack.isEmpty()){
			Node<T> node = stack.poll();
			if(node != null) {
				System.out.print(node.getData() + "\t");
				stack.push(node.getrNode());
				stack.push(node.getlNode());
			}
		}
	}
	
}

前序遍历（递归）：

public class PreOrderRec <T extends Comparable<T>> implements BTreeTravelable<T>{

	/* (non-Javadoc)
	 * <p>Title: travel</p> 
	 * <p>Description: </p> 
	 * @param root 
	 * @see Algorithm.BTree.BTreeTravelable#travel(Algorithm.BTree.Node) 
	 */
	@Override
	public void travel(Node<T> root) {
		if(root != null){
			System.out.print(root.getData() + "\t");
			travel(root.getlNode());
			travel(root.getrNode());
		}
	}
	
}

中序遍历（非递归）：

public class InOrder <T extends Comparable<T>> implements BTreeTravelable<T>{

	/* (non-Javadoc)
	 * <p>Title: travel</p> 
	 * <p>Description: </p> 
	 * @param root 
	 * @see Algorithm.BTree.BTreeTravelable#travel(Algorithm.BTree.Node) 
	 */
	@Override
	public void travel(Node<T> root) {
		LinkedList<Node <T>> stack = new LinkedList<Node <T>>();
		Node<T> node = root;
		while(!stack.isEmpty() || node !=null){
			while(node!=null){
				stack.push(node);
				node = node.getlNode();
			}
			if(!stack.isEmpty()){
				node = stack.pop();
				System.out.print(node.getData() + "\t");
				node = node.getrNode();
			}
		}
	}
	
}

中序遍历（递归）：

public class InOrderRec <T extends Comparable<T>> implements BTreeTravelable<T>{

	/* (non-Javadoc)
	 * <p>Title: travel</p> 
	 * <p>Description: </p> 
	 * @param root 
	 * @see Algorithm.BTree.BTreeTravelable#travel(Algorithm.BTree.Node) 
	 */
	@Override
	public void travel(Node<T> root) {
		if(root != null){
			travel(root.getlNode());
			System.out.print(root.getData() + "\t");
			travel(root.getrNode());
		}
	}
	
}

后序遍历（非递归）：

public class PostOrder <T extends Comparable<T>> implements BTreeTravelable<T>{

	/* (non-Javadoc)
	 * <p>Title: travel</p> 
	 * <p>Description: </p> 当上一个访问的结点是右孩子或者当前结点没有右孩子则访问当前结点
	 * @param root 
	 * @see Algorithm.BTree.BTreeTravelable#travel(Algorithm.BTree.Node) 
	 */
	@Override
	public void travel(Node<T> root) {
		LinkedList<Node <T>> stack = new LinkedList<Node <T>>();
		Node<T> node = root;
		Node<T> rNode = null;  
		while(!stack.isEmpty() || node !=null){
			while(node!=null){
				stack.push(node);
				node = node.getlNode();
			}
			node = stack.pop();
			while(node != null && (node.getrNode() == null || node.getrNode() == rNode)){
				System.out.print(node.getData() + "\t");
				rNode = node;
				if(stack.isEmpty()){
					return;
				}
				node = stack.pop();
			}
			stack.push(node);
			node = node.getrNode();
		}
	}
	
}

后序遍历（递归）：

public class PostOrderRec <T extends Comparable<T>> implements BTreeTravelable<T>{

	/* (non-Javadoc)
	 * <p>Title: travel</p> 
	 * <p>Description: </p> 
	 * @param root 
	 * @see Algorithm.BTree.BTreeTravelable#travel(Algorithm.BTree.Node) 
	 */
	@Override
	public void travel(Node<T> root) {
		if(root != null){
			travel(root.getlNode());
			travel(root.getrNode());
			System.out.print(root.getData() + "\t");
		}
	}
	
}

测试：

public class Test {
	public static void main(String args[]){
		BTree<Integer> tree=new BTree<Integer>();
		tree.insert(49);
		tree.insert(25);
		tree.insert(55);
		tree.insert(10);
		tree.insert(51);
		tree.insert(65);
		System.out.println("前序遍历（递归）:");
		tree.setTravelMethod(new PreOrderRec<Integer>());
		tree.travelTree();
		System.out.println();
		System.out.println("前序遍历（非<span style="font-family: Arial, Helvetica, sans-serif;">递归</span><span style="font-family: Arial, Helvetica, sans-serif;">）:");</span>
		tree.setTravelMethod(new PreOrder<Integer>());
		tree.travelTree();
		System.out.println();
		System.out.println("中序遍历（递归）:");
		tree.setTravelMethod(new InOrderRec<Integer>());
		tree.travelTree();
		System.out.println();
		System.out.println("中序遍历（非递归）:");
		tree.setTravelMethod(new InOrder<Integer>());
		tree.travelTree();
		System.out.println();
		System.out.println("后序遍历（递归）:");
		tree.setTravelMethod(new PostOrderRec<Integer>());
		tree.travelTree();
		System.out.println();
		System.out.println("后序遍历（非递归）:");
		tree.setTravelMethod(new PostOrder<Integer>());
		tree.travelTree();
	}
}