Java实现二叉树遍历(递归，非递归)

public class BinaryTree {
class TreeNode<T>{
private T data;
private TreeNode<T> leftNode;
private TreeNode<T> rightNode;

public TreeNode(T data, TreeNode<T> leftNode, TreeNode<T> rightNode){
this.data = data;
this.leftNode = leftNode;
this.rightNode = rightNode;
}
}
//新建二叉树
public TreeNode<String> init(){
TreeNode<String> K = new TreeNode<String>("K", null, null);
TreeNode<String> J = new TreeNode<String>("J", null, null);
TreeNode<String> I = new TreeNode<String>("I", null, null);
TreeNode<String> H = new TreeNode<String>("H", null, null);
TreeNode<String> G = new TreeNode<String>("G", K, null);
TreeNode<String> F = new TreeNode<String>("F", null, J);
TreeNode<String> E = new TreeNode<String>("E", H, I);
TreeNode<String> D = new TreeNode<String>("D",null,null);
TreeNode<String> C = new TreeNode<String>("C",F,G);
TreeNode<String> B = new TreeNode<String>("B",D,E);
TreeNode<String> A = new TreeNode<String>("A",B,C);

return A;
}

//先序遍历(递归)
public void preorderTraverse(TreeNode<String> root){
if(root == null)
return;

System.out.print(root.data + " ");
preorderTraverse(root.leftNode);
preorderTraverse(root.rightNode);
}

//中序遍历(递归)
public void inorderTraverse(TreeNode<String> root){
if(root == null)
return;

inorderTraverse(root.leftNode);
System.out.print(root.data + " ");
inorderTraverse(root.rightNode);
}

//后序遍历(递归)
public void postorderTraverse(TreeNode<String> root){
if(root == null)
return;

preorderTraverse(root.leftNode);
preorderTraverse(root.rightNode);
System.out.print(root.data + " ");
}

//先序遍历(非递归)
public void preorderTraverse_stack(TreeNode<String> root){
if(root == null)
return;
Stack<TreeNode<String>> stack = new Stack<TreeNode<String>>();
while(root != null || !stack.isEmpty()){
while(root != null){
System.out.print(root.data + " ");
stack.push(root);
root = root.leftNode;
}

root = stack.pop();
root = root.rightNode;
}
}

//中序遍历(非递归)
public void inorderTraverse_stack(TreeNode<String> root){
if(root == null)
return;
Stack<TreeNode<String>> stack = new Stack<TreeNode<String>>();
while(root != null || !stack.isEmpty()){
while(root != null){
stack.push(root);
root = root.leftNode;
}

root = stack.pop();
System.out.print(root.data + " ");
root = root.rightNode;
}
}

//后续遍历(非递归)
public void postOrderTraverse_stack(TreeNode<String> root){
if(root == null)
return;
Stack<TreeNode<String>> stack = new Stack<TreeNode<String>>();
Map<TreeNode<String>,Boolean> map = new HashMap<>();
stack.push(root);
while(!stack.isEmpty()){
TreeNode<String> temp = stack.pop();
if(temp.leftNode != null && !map.containsKey(temp.leftNode)){
temp = temp.leftNode;
while(temp != null){
if(map.containsKey(temp))
break;
else
stack.push(temp);
temp =temp.leftNode;
}

continue;
}

if(temp.rightNode != null && !map.containsKey(temp.rightNode)){
stack.push(temp.rightNode);
continue;
}

TreeNode<String> t = stack.pop();
map.put(t, true);
System.out.println(t.data);
}
while(root != null || !stack.isEmpty()){
while(root != null){
stack.push(root);
root = root.leftNode;
}

root = stack.pop();

}
}
//层序遍历
public void levelTraverse(TreeNode<String> root){
if(root == null)
return;
Queue<TreeNode<String>> queue = new LinkedList<TreeNode<String>>();
queue.add(root);
while(!queue.isEmpty()){
TreeNode<String> temp = queue.poll();
System.out.print(temp.data + " ");
if(temp.leftNode!=null)
queue.add(temp.leftNode);
if(temp.rightNode != null)
queue.add(temp.rightNode);
}
}
public static void main(String[] args){
BinaryTree binaryTree = new BinaryTree();
TreeNode<String> root = binaryTree.init();
System.out.println("先序遍历(递归)");
binaryTree.preorderTraverse(root);
System.out.println();
System.out.println("先序遍历(非递归)");
binaryTree.preorderTraverse_stack(root);
System.out.println();

System.out.println("中序遍历(递归)");
binaryTree.inorderTraverse(root);
System.out.println();
System.out.println("中序遍历(非递归)");
binaryTree.inorderTraverse_stack(root);
System.out.println();

System.out.println("后序遍历(递归)");
binaryTree.postorderTraverse(root);
System.out.println();
System.out.println("后序遍历(非递归)");
binaryTree.postorderTraverse(root);
System.out.println();
System.out.println("层序遍历");
binaryTree.levelTraverse(root);
}
}