【数据结构】二叉树遍历

二叉树结构

/**
* Created by novax_000 on 2016/5/1.
*/
public class BinaryTree<T> {
public T value;
public BinaryTree<T> left;
public BinaryTree<T> right;

public BinaryTree(T value, BinaryTree<T> left, BinaryTree<T> right) {
super();
this.value = value;
this.left = left;
this.right = right;
}

public BinaryTree(){
super();
}

}


二叉树的遍历：
1、先序遍历（递归）

//递归先序遍历
public void preOrderRecursive(BinaryTree<T> root)
{
if(root==null)
{
return;
}
//先访问根节点
System.out.println(root.value);
//然后访问左孩子
preOrderRecursive(root.left);
//然后访问右孩子
preOrderRecursive(root.right);
}

2、中序遍历（递归）
//递归中序遍历
public void inOrderRecursive(BinaryTree<T> root)
{
if(root==null)
{
return;
}
//先访问左孩子
inOrderRecursive(root.left);
//再访问根节点
System.out.println(root.value);
//再访问右孩子
inOrderRecursive(root.right);
}3、后序遍历（递归）
//递归后序遍历
public void postOrderRecursive(BinaryTree<T> root)
{
if(root==null)
{
return;
}
//先访问左孩子
postOrderRecursive(root.left);
//再访问右孩子
postOrderRecursive(root.right);
//最后访问根节点
System.out.println(root.value);
}

4、先序遍历（非递归）
//非递归先序遍历
public void preOrderNonRecursive(BinaryTree<T> root)
{
if(root==null)
{
return;
}
Stack<BinaryTree> stack = new Stack<BinaryTree>();

stack.push(root);
//当栈不为空时
while(!stack.isEmpty())
{
//先弹出根节点
BinaryTree<T> temp = stack.pop();
System.out.println(temp.value);
//把右孩子压入栈
if(temp.right!=null)
{
stack.push(temp.right);
}
//把左孩子压入栈
if(temp.left!=null)
{
stack.push(temp.left);
}
}
}

5、中序遍历（非递归）
//非递归中序遍历
public void inOrderNonRecursive(BinaryTree<T> root)
{
if(root==null)
{
return;
}
Stack<BinaryTree> stack = new Stack<BinaryTree>();
BinaryTree<T> current = root;
while(current!=null||!stack.isEmpty())
{
//一路向左入栈
while(current!=null)
{
stack.push(current);
current = current.left;
}
if(!stack.isEmpty())
{
current = stack.peek();
stack.pop();
System.out.println(current.value);
current = current.right;
}
}
}

6、后序遍历（非递归）
//非递归后序遍历
public void postOrderNonRecursive(BinaryTree<T> root)
{
if(root==null)
{
return;
}
Stack<BinaryTree> stack = new Stack<BinaryTree>();
BinaryTree<T> current = root;
BinaryTree<T> pre = null;
while(current!=null||!stack.isEmpty())
{
while(current!=null)
{
stack.push(current);
current = current.left;
}
current = stack.peek();
//如果当前节点无右孩子或者当前节点的右孩子已经访问过了，就访问当前节点
if((current.right==null)||(current.right==pre))
{
System.out.println(current.value);
//用pre记录已经访问过的节点
pre = current;
stack.pop();
current = null;
}
else
{
current = current.right;
}
}
}

7、后序遍历第二种方法（非递归）
//非递归后序遍历第二种方法，用两个栈
public void postOrderNonRecursiveWithTwoStack(BinaryTree<T> root)
{
Stack<BinaryTree> stack1 = new Stack<BinaryTree>();
Stack<BinaryTree> stack2 = new Stack<BinaryTree>();
BinaryTree<T> current;
stack1.push(root);
while(!stack1.isEmpty())
{
current = stack1.peek();
stack1.pop();
//第二个栈的入栈顺序为先根节点，然后右孩子，然后左孩子
stack2.push(current);
//按先左孩子，后右孩子的顺序压入第一个栈
if(current.left!=null)
{
stack1.push(current.left);

}
if(current.right!=null)
{
stack1.push(current.right);
}

}
//第二个栈的出栈顺序为左孩子，右孩子，根节点
while(!stack2.isEmpty())
{
System.out.println(stack2.peek().value);
stack2.pop();
}
}