三种非递归遍历二叉树的方法
就以这个树为例，来讲讲二叉树的非递归遍历。
先序遍历： 先序遍历结果为3 4 6 5 8 9，就拿树的左枝为例，3是根，打印，4是3的左孩子，打印，6是4的左孩子，打印，6的左孩子为空，所以返回到4，然后去找4的右孩子，4的右孩子也为空，返回到3，这就是左子树遍历的过程。然后非递归主要用到栈来存储结点，栈先进后出，所以应该是右孩子先入栈，左孩子后入栈，这样pop就能先得到左孩子。先将根结点3入栈，接下来就是开始循环，循环结束的条件就是栈为空，先弹出栈顶，再打印栈顶，如果栈顶的右孩子不为null，就把右孩子放进栈中，如果栈顶的左孩子不为null，就把左孩子放入栈中。
用下面一幅图来说明整个过程
void pretravel2(TreeNode root) {
if (root == null) return;
Stack<TreeNode> s = new Stack<TreeNode>();
s.push(root);
while (!s.isEmpty()) {
TreeNode node = s.pop();
System.out.print(node.val+" ");
if (node.right != null) {
s.push(node.right);
}
if (node.left != null) {
s.push(node.left);
}
}
}
中序遍历：中序遍历的结果为6 4 3 8 5 9，其实就是左遍历完了，弹出根，找根的右结点，整个过程是先一路找左结点，找到左结点为null的6，然后找6的根4，接着找4的右，为null，接着找4的根3，接着一路找3的左，直到结点的左孩子为null，这就找到了8，然后找8的根5，再找5的右9，这样就找完了。他们的入栈出栈顺序：根结点入栈，左孩子直接入栈，并且标记这个结点已经走过，以防后面再走，当发现哪个结点的左孩子为null的时候，就打印这个结点，并且将这个结点出栈，让他的右孩子入栈
void intravel2(TreeNode root) {
if(root==null)
return ;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
//使用list来标记结点是否走过
List<TreeNode> list=new ArrayList<>();
while(!stack.isEmpty()) {
//只需要拿到根结点，不需要pop出来
TreeNode peek = stack.peek();
//如果左孩子不为null并且左孩子没有被走过，就把他放到栈里，并且标记为走过
if(peek.left!=null&& !list.contains(peek.left)) {
stack.push(peek.left);
list.add(peek.left);
}
else {//左孩子为空，打印根结点，根结点出栈，右孩子进栈
TreeNode pop = stack.pop();
System.out.print(pop.val+" ");
if(pop.right!=null)
stack.push(pop.right);
}
}
}
中序遍历还有另外一种写法：
void intravel3(TreeNode root) {
Stack<TreeNode> stack=new Stack<>();
TreeNode p=root;
while(p!=null||!stack.isEmpty()) {
while(p!=null) {
stack.push(p);
p=p.left;
}
//左孩子遍历完了，根结点弹出，打印根结点，遍历右孩子
if(!stack.isEmpty()) {
TreeNode temp=stack.pop();
System.out.print(temp.val+" ");
p=temp.right;
}
}
}
后序遍历： 后序遍历的结果为6 4 8 9 5 3，一路找左结点到6，然后找到右孩子为null，退到根4，4的右为null，然后3的左孩子遍历完了，到右孩子，一路找左孩子到8，右孩子9，根5，右孩子遍历完，最后到4。他们的进栈出栈顺序为：根结点入栈，左孩子一路入栈，当有个结点的左孩子为null的时候，就将它的右孩子入栈，如果右孩子也为null，才打印根结点。
void postrval2(TreeNode root) {
if(root==null)
return ;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
List<TreeNode> list=new ArrayList<>();
while(!stack.isEmpty()) {
TreeNode peek=stack.peek();
//先一路走左，左走完了才到右
if(peek.left!=null&&!list.contains(peek.left)) {
//如果左结点不为null并且左结点没有走过
//就将其压入栈中，并且标记已经走过
stack.push(peek.left);
list.add(peek.left);
}
else {
if(peek.right!=null&&!list.contains(peek.right)) {
//如果右结点为不为null并且右结点没有走过
//就将右结点压入栈中，标记已经走过
stack.push(peek.right);
list.add(peek.right);
}
else {
//如果右孩子为null，就打印根结点
TreeNode pop = stack.pop();
System.out.print(pop.val+" ");
}
}
}
}
递归遍历，非递归遍历的代码
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.*;
class TreeNode {
int val;
TreeNode left=null;
TreeNode right=null;
TreeNode(){}
TreeNode(int val) {
this.val=val;
}
}
public class Main {
public static void main(String[] args) {
Main main = new Main();
TreeNode root=null;
root=main.createTree();
System.out.println("先序遍历：");
main.pretravel(root);
System.out.println("");
System.out.println("中序遍历：");
main.intravel(root);
System.out.println("");
System.out.println("后序遍历：");
main.postravel(root);
System.out.println("");
System.out.println("迭代先序遍历：");
main.pretravel2(root);
System.out.println("");
System.out.println("迭代中序遍历1(类似于回溯算法):");
main.intravel2(root);
System.out.println("");
System.out.println("迭代中序遍历2:");
main.intravel3(root);
System.out.println("");
System.out.println("迭代后序遍历:");
main.postrval2(root);
System.out.println("");
System.out.println("层序遍历:");
main.levelOrder(root);
}
//建树
TreeNode createTree(){
Scanner sc=new Scanner(System.in);
int temp=sc.nextInt();
if(temp<=0)return null;
TreeNode root=new TreeNode();
root.val=temp;
root.left=createTree();
root.right=createTree();
return root;
}
//先序
void pretravel(TreeNode root){
if(root==null)return;
System.out.print(root.val+" ");
pretravel(root.left);
pretravel(root.right);
}
//中序
void intravel(TreeNode root){
if(root==null)return;
intravel(root.left);
System.out.print(root.val+" ");
intravel(root.right);
}
//后序
void postravel(TreeNode root){
if(root==null)return;
postravel(root.left);
postravel(root.right);
System.out.print(root.val+" ");
}
//迭代先序
void pretravel2(TreeNode root) {
if (root == null) return;
Stack<TreeNode> s = new Stack<TreeNode>();
s.push(root);
while (!s.isEmpty()) {
TreeNode node = s.pop();
System.out.print(node.val+" ");
if (node.right != null) {
s.push(node.right);
}
if (node.left != null) {
s.push(node.left);
}
}
}
void intravel2(TreeNode root) {
if(root==null)
return ;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
List<TreeNode> list=new ArrayList<>();
while(!stack.isEmpty()) {
TreeNode peek = stack.peek();
if(peek.left!=null&& !list.contains(peek.left)) {
stack.push(peek.left);
list.add(peek.left);
}
else {//左孩子为空，打印根结点，根结点出栈，右孩子进栈
TreeNode pop = stack.pop();
System.out.print(pop.val+" ");
if(pop.right!=null)
stack.push(pop.right);
}
}
}
void intravel3(TreeNode root) {
Stack<TreeNode> stack=new Stack<>();
TreeNode p=root;
while(p!=null||!stack.isEmpty()) {
while(p!=null) {
stack.push(p);
p=p.left;
}
if(!stack.isEmpty()) {
TreeNode temp=stack.pop();
System.out.print(temp.val+" ");
p=temp.right;
}
}
}
void postrval2(TreeNode root) {
if(root==null)
return ;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
List<TreeNode> list=new ArrayList<>();
while(!stack.isEmpty()) {
TreeNode peek=stack.peek();
if(peek.left!=null&&!list.contains(peek.left)) {
stack.push(peek.left);
list.add(peek.left);
}
else {
if(peek.right!=null&&!list.contains(peek.right)) {
stack.push(peek.right);
list.add(peek.right);
}
else {
TreeNode pop = stack.pop();
System.out.print(pop.val+" ");
}
}
}
}
//层序
void levelOrder(TreeNode root) {
List<TreeNode> list=new ArrayList<>();
list.add(root);
while(list.size()!=0) {
TreeNode temp=list.get(0);
if(temp.left!=null) list.add(temp.left);
if(temp.right!=null) list.add(temp.right);
list.remove(0);
System.out.print(temp.val+" ");
}
}
}
输入是按照先序序列输，输一个打一个回车，结点为null的时候输入-1，表示为空，叶子节点要输两个-1，表示左右孩子均为空。
