二叉树的前序中序后序的递归和非递归遍历

一、二叉树的数据结构

1.1 定义树节点

public class TreeNode {
String val;
TreeNode left;
TreeNode right;

public TreeNode(String val) {
this.val = val;
}

public String getVal() {
return val;
}

public void display() {
System.out.print(val + "\t");
}

}

1.2 定义二叉树

public class BinaryTree {

private TreeNode root = null;

public BinaryTree(String val) {
root = new TreeNode(val);
root.left = null;
root.right = null;
}
public void inOrderTraverse(TreeNode node) {}
public void preOrderTraverse(TreeNode node) {}
public void postOrderTraverse(TreeNode node) {}
public void inOrderByStack(TreeNode node) {}
public void preOrderByStack(TreeNode node) {}
public void postOrderByStack(TreeNode node) {}
}

二、递归遍历

2.1 中序递归遍历

public void inOrderTraverse(TreeNode node) {
if (node == null) {
return;
}
inOrderTraverse(node.left);
node.display();
inOrderTraverse(node.right);
}

2.2 前序递归遍历

public void preOrderTraverse(TreeNode node) {
if (node == null) {
return;
}
node.display();
preOrderTraverse(node.left);
preOrderTraverse(node.right);
}

2.3 后序递归遍历

public void postOrderTraverse(TreeNode node) {
if (node == null) {
return;
}
postOrderTraverse(node.left);
postOrderTraverse(node.right);
node.display();
}

三、非递归遍历

3.1 中序非递归遍历

public void inOrderByStack(TreeNode node) {

if(node == null){ return;}
Stack<TreeNode> stack = new Stack<TreeNode>();
while(!stack.isEmpty() || node!=null){
if(node!=null){
stack.push(node);
node=head.left;
}else{
node = stack.pop();
System.out.print(node.val+"\t")
node = node.right;
}
}

}

3.2 前序非递归遍历

public void preOrderByStack(TreeNode node) {
if(node == null){
return ;
}
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.add(node);
TreeNode cur=null;
while(!stack.isEmpty()){
cur = stack.pop();
System.out.println(cur.val);
if(cur.right != null){
stack.add(cur.right);
}
if(cur.left !=null ){
stack.add(cur.left)
}
}
}

3.3 后序非递归遍历

public void postByStack(TreeNode node) {
if (node == null) {
return;
}
Stack<TreeNode> s1 = new Stack<TreeNode>();
Stack<TreeNode> s2 = new Stack<TreeNode>();
s1.push(node);
while (!s1.isEmpty()) {
node = s1.pop();
s2.push(node);
if(node.left!=null){
s1.push(node.left);
}

if(node.right!=null){
s1.push(node.right);
}
}

while(!s2.isEmpty()){
System.out.print(s2.pop().val+"\t");
}
}

四、测试

a
/   \
b      c
/   \   /  \
d    e  f    g
/
h
\
i

public class Main1 {

public static void main(String[] args) {

BinaryTree btree = new BinaryTree("a");

TreeNode node1 = new TreeNode("b");
TreeNode node2 = new TreeNode("c");
TreeNode node3 = new TreeNode("d");
TreeNode node4 = new TreeNode("e");
TreeNode node5 = new TreeNode("f");
TreeNode node6 = new TreeNode("g");
TreeNode node7 = new TreeNode("h");
TreeNode node8 = new TreeNode("i");

btree.root.left = node1;
btree.root.right = node2;
node1.left = node3;
node1.right = node4;
node2.left = node5;
node2.right = node6;
node4.left = node7;
node7.right = node8;

System.out.println("中序非递归遍历:");
btree.inOrderTraverse(btree.root);

System.out.println("\n中序递归遍历:");
btree.inOrderByStack(btree.root);

System.out.println("\n前序非递归遍历:");
btree.preOrderTraverse(btree.root);
System.out.println("\n前序递归遍历:");
btree.preOrderByStack(btree.root);

System.out.println("\n后序非递归遍历:");
btree.postOrderTraverse(btree.root);
System.out.println("\n后序递归遍历:");
btree.postByStack(btree.root);
}
}

中序非递归遍历:
d   b   h   i   e   a   f   c   g
中序递归遍历:
d   b   h   i   e   a   f   c   g
前序非递归遍历:
a   b   d   e   h   i   c   f   g
前序递归遍历:
a   b   d   e   h   i   c   f   g
后序非递归遍历:
d   i   h   e   b   f   g   c   a
后序递归遍历:
d   i   h   e   b   f   g   c   a