【数据结构与算法】二叉树的前中后递归与非递归遍历

结点类

public class  TreeNode {
		int val;
		TreeNode left;
		TreeNode right;
		TreeNode(int x) {val=x;}	
}

树类

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Solution {

	static int index;
	//先序递归遍历
	public void preOrder(TreeNode root) {
		if(root==null) {
			return;
		}
		System.out.print(root.val);
		preOrder(root.left);
		preOrder(root.right);
	}
	
	//中序递归遍历
	public void inOrder(TreeNode root) {
		if(root==null) {
			return;
		}
		inOrder(root.left);
		System.out.print(root.val);
		inOrder(root.right);
	}
	
	//后序递归遍历
	public void postOrder(TreeNode root) {
		if(root==null) {
			return;
		}
		postOrder(root.left);
		postOrder(root.right);
		System.out.print(root.val);
	}
	
	//非递归前序遍历
	public List<Integer> preorderTraversal(TreeNode root) {

        ArrayList<Integer> res = new ArrayList<Integer>();
        if(root == null)
            return res;

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            if(cur != null){
                res.add(cur.val);
                stack.push(cur);
                cur = cur.left;
            }
            else{
                cur = stack.pop();
                cur = cur.right;
            }
        }
        return res;
    }
	
	//非递归中序遍历
	public List<Integer> inorderTraversal(TreeNode root) {

        ArrayList<Integer> res = new ArrayList<Integer>();
        if(root == null)
            return res;

        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.empty()){

            if(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            else{
                cur = stack.pop();
                res.add(cur.val);
                cur = cur.right;
            }
        }
        return res;
    }
	
	//非递归后序遍历
	public List<Integer> postorderTraversal(TreeNode root) {

        ArrayList<Integer> res = new ArrayList<Integer>();
        if(root == null)
            return res;

        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;
        TreeNode cur = root;

        while(cur != null || !stack.empty()){

            if(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            else{
                cur = stack.pop();
                if(cur.right == null || pre == cur.right){
                    res.add(cur.val);
                    pre = cur;
                    cur = null;
                }
                else{
                    stack.push(cur);
                    cur = cur.right;
                }
            }
        }
        return res;
    }
	
	//先序创建二叉树
	public TreeNode CreateBinaryTree(int []a) {
		TreeNode root = null;
		if(a[index]!=0) {
			root = new TreeNode(a[index]); 
			index++;
			root.left=	CreateBinaryTree(a);
			index++;
			root.right=	CreateBinaryTree(a);
		}
		return root;
	}
	
	public static void main(String[] args) {
		Solution tree = new Solution();
		int[] a = new int[]{1,2,3,0,0,4,0,0,5,6,0,0,0 };
		TreeNode root;
		root=tree.CreateBinaryTree(a);
		
		System.out.print("先序递归遍历：");
		tree.preOrder(root);
		System.out.println();
		
		System.out.print("中序递归遍历：");
		tree.inOrder(root);
		System.out.println();
		
		System.out.print("后序递归遍历：");
		tree.postOrder(root);
		System.out.println();
		
		System.out.print("非递归先序遍历");
		System.out.println(tree.preorderTraversal(root));
		
		System.out.print("非递归中序遍历");
		System.out.println(tree.inorderTraversal(root));
		
		System.out.print("非递归后序遍历");
		System.out.println(tree.postorderTraversal(root));

	}
}

运行如下：