二叉树的前中后序遍历

package binaryTree;

import java.util.*;

/*
* 二叉树的递归与非递归版本
*/
public class Traverse {
//递归版本
public static void preTraverse(TreeNode node) {
if(node == null)
return;

System.out.println(node.value);//或其他操作

preTraverse(node.left);
preTraverse(node.right);
}

public static void inTraverse(TreeNode node) {
if(node == null)
return;

inTraverse(node.left);

System.out.println(node.value);//或其他操作

inTraverse(node.right);
}

public static void postTraverse(TreeNode node) {
if(node == null)
return;

postTraverse(node.left);
postTraverse(node.right);

System.out.println(node.value);//或其他操作
}

//非递归版本
public static void rePreTraverse(TreeNode node) {
if(node == null)
return;

Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(node);
while(!stack.isEmpty()) {
TreeNode tmp = stack.pop();
System.out.println(tmp.value);//或其他操作

if(tmp.right != null)
stack.push(tmp.right);
if(tmp.left != null)
stack.push(tmp.left);
}
}

public static void reInTraverse(TreeNode node) {
if(node == null)
return;

Stack<TreeNode> stack = new Stack<TreeNode>();
while(node != null || !stack.isEmpty()) {
if(node != null) {
stack.push(node);
node = node.left;
} else {
node = stack.pop();

System.out.println(node.value);//或其他操作

node = node.right;
}
}
}

public static void rePostTraverse(TreeNode node) {
Stack<TreeNode> s = new Stack<TreeNode>();
TreeNode p = node;
//pre标记最近出栈的节点，用于判断是否是p节点的右孩子，如果是的话，就可以访问p节点
TreeNode pre = p;
//flag标记是出栈还是继续将左孩子进栈：true标记进栈；false标记出栈；
boolean flag = true;
while(p!=null || !s.isEmpty()) {
if(p!=null && flag) {
s.push(p);
p = p.left;
}
else {
if(s.isEmpty()) return;
p = s.peek();
if(p.right != null && p.right!=pre) {
p = p.right;
flag = true;
}
else {
p = s.pop();
System.out.println(p.value);
flag = false;
pre = p;
}
}
}
}
}