二叉树的遍历算法（递归与非递归）

public class BSTTraversal {

public static class Node{
private int value;
private Node leftNode;
private Node rightNode;
public Node(int value, Node leftNode, Node rightNode){
this.value = value;
this.leftNode = leftNode;
this.rightNode = rightNode;
}
}

//递归先序遍历
public void preOrder(Node node){
if(node==null) return;
printNode(node);
if(node.leftNode!=null) preOrder(node.leftNode);
if(node.rightNode!=null) preOrder(node.rightNode);
}

//递归中序遍历
public void inOrder(Node node){
if(node==null) return;
if(node.leftNode!=null) inOrder(node.leftNode);
printNode(node);
if(node.rightNode!=null) inOrder(node.rightNode);
}

//递归后序遍历
public void postOrder(Node node){
if(node==null) return;
if(node.leftNode!=null) postOrder(node.leftNode);
if(node.rightNode!=null) postOrder(node.rightNode);
printNode(node);
}

//非递归先序遍历
public void preOrderNoRecursion(Node node){
if(node==null) return;
Stack<Node> stack = new Stack<Node>();
stack.push(node);
while(!stack.isEmpty()){
Node t = stack.pop();
printNode(t);
if(t.rightNode!=null) stack.push(t.rightNode);
if(t.leftNode!=null) stack.push(t.leftNode);
}
}

//非递归中序遍历
public void inOrderNoRecursion(Node node){
if(node==null) return;
Stack<Node> stack = new Stack<Node>();
Node p = node;
while(p!=null||!stack.isEmpty()){
if(p!=null){
stack.push(p);
p = p.leftNode;
}else{
p = stack.pop();
printNode(p);
p = p.rightNode;
}
}
}

//非递归后序遍历
public void postOrderNoRecursion(Node node){
if(node==null) return;
Stack<Node> stack = new Stack<Node>();
//这里flag来标记是栈顶出栈或者左孩子进栈
boolean flag = true;
Node p = node;
//这里pre来记录最近出栈的节点（用于判断pre是否是p的右孩子，如果是，才可访问p节点）
Node pre = p;
while(p!=null||!stack.isEmpty()){
if(p!=null&&flag){
stack.push(p);
p = p.leftNode;
}else{
if(stack.isEmpty()) return;
p = stack.peek();
if(p.rightNode!=null&&p.rightNode!=pre){
p = p.rightNode;
flag = true;
}else{
p = stack.pop();
printNode(p);
flag = false;
pre = p;
}
}
}
}

private void printNode(Node node) {
System.out.print(node.value+" ");
}

public static void main(String[] args) {
Node node1 = new Node(4,null,null);
Node node2 = new Node(8,null,null);
Node node3 = new Node(12,null,null);
Node node4 = new Node(16,null,null);
Node node5 = new Node(6,node1,node2);
Node node6 = new Node(14,node3,node4);
Node node7 = new Node(10,node5,node6);
BSTTraversal bst = new BSTTraversal();
System.out.print("先序递归:");bst.preOrder(node7);
System.out.print("先序非递归:");bst.preOrderNoRecursion(node7);
System.out.print("中序递归:");bst.inOrder(node7);
System.out.print("中序非递归:");bst.inOrderNoRecursion(node7);
System.out.print("后序递归:");bst.postOrder(node7);
System.out.print("后序非递归:");bst.postOrderNoRecursion(node7);
}

}