二叉树的遍历（Java，前序、中序、后序、递归and非递归）

package com.cuitccol.claymore;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import java.util.ArrayList;
import java.util.Map;

public class BTree {

private BinaryTreeNode root;
/**
* 前序递归
* @param current
*/
public void PreOrder(BinaryTreeNode current){
if(current!=null){
System.out.println(current.getInfo());
PreOrder(current.lchild);
PreOrder(current.rchild);
}
}
/**
* 中序递归
* @param current
*/
public void inOrder(BinaryTreeNode current){
if(current!=null){
inOrder(current.lchild);
System.out.println(current.getInfo());
inOrder(current.rchild);
}
}
/**
* 后序递归
* @param current
*/
public void postOrder(BinaryTreeNode current){
if(current!=null){
postOrder(current.lchild);
postOrder(current.rchild);
System.out.println(current.getInfo());
}
}
/**
* 深度递归
* @param current
* @return deep
*/
public int deepth(BinaryTreeNode current){
if(current == null){
return 0;
}else{
int dep1 = deepth(current.lchild);
int dep2 = deepth(current.rchild);
return dep1>dep2?dep1+1:dep2+1;
}
}

/**
* 前序非递归
* @param current
*/
public void preOrderNonRecursive(BinaryTreeNode current){
Stack<BinaryTreeNode> stack = new Stack<BTree.BinaryTreeNode>();
while((current!=null)||(stack.isEmpty())){
if(current!=null){
System.out.println(current.getInfo());
stack.push(current);
current = current.lchild;
}else{
current = stack.peek();
stack.pop();
current = current.rchild;
}
}
}
/**
* 中序非递归
* @param current
*/
public void inOrderNonRecursive(BinaryTreeNode current){
Stack<BinaryTreeNode> stack = new Stack<BTree.BinaryTreeNode>();
while((current!=null)||(stack.isEmpty())){
if(current!=null){
stack.push(current);
current = current.lchild;
}else{
current = stack.peek();
stack.pop();
System.out.println(current.getInfo());
current = current.rchild;
}
}
}
/**
* 后续非递归
* @param current
*/
public void postOrderNonRecursive(BinaryTreeNode current){
Stack<BinaryTreeNode> stack = new Stack<BTree.BinaryTreeNode>();
while((current!=null)||(stack.isEmpty())){
if(current!=null){
current.isFirst = true;
stack.push(current);
current = current.lchild;
}else{
current = stack.peek();
stack.pop();
if(current.isFirst){
current.isFirst = false;
stack.push(current);
current = current.rchild;
}else{
System.out.println(current.getInfo());
current = null;
}
}
}
}

public void bfs(BinaryTreeNode current){
Queue<BinaryTreeNode> queue = new LinkedList<BTree.BinaryTreeNode>();
while((current!=null)||queue.isEmpty()){
if(current!=null){
System.out.println(current.getInfo());
queue.add(current.lchild);
queue.add(current.rchild);
current = queue.poll();
}else{
current = queue.poll();
}
}
}

public class BinaryTreeNode{
private BinaryTreeNode lchild = null;
private BinaryTreeNode rchild = null;
private int info;
private boolean isFirst;
public int getInfo() {
return info;
}
public void setInfo(int info) {
this.info = info;
}
}

}