二叉树的非递归遍历方式（前序、中序和后序）

最近一直在实习，很久没有更新博客了。看到互联网面试经常考察二叉树的相关知识，所以打算写一期树的系列博客。很多同学较为熟悉递归遍历，但是可能不怎么熟悉非递归算法，所以第一篇总结下二叉树的三种非递归遍历方式。

前序遍历的基本思想：

1、创建栈对象，根节点入栈；

2、当栈非空的时候，弹出栈顶元素，访问栈顶元素

3、右子树非空，右子树入栈（先进后访问，保证根左右的顺序）

4、左子树非空，左子树入栈

5、重复2、3和4中的步骤

代码如下：

/**
 *Definition for a binary tree node.
 *public class TreeNode {
 *    int val;
 *    TreeNode left;
 *    TreeNode right;
 *    TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
   public List<Integer> preorderTraversal(TreeNode root) {
       List<Integer> list=new ArrayList<Integer>();
       if(root==null)
           return list;
       Stack<TreeNode> stack=new Stack<TreeNode>();
       stack.push(root);
       while(!stack.isEmpty()){
           TreeNode p=stack.pop();
           list.add(p.val);
           if(p.right!=null) stack.push(p.right);
           if(p.left!=null) stack.push(p.left);
       }
       return list;
    }
}

 

中序遍历基本思想：

1、根节点入栈

2、当栈非空且根节点非空，左子树节点不断入栈

3、不满足2中条件，弹出栈顶元素，访问该节点，将该节点的右子树入栈

4、重复2和3中步骤

代码如下：

/**
 *Definition for a binary tree node.
 *public class TreeNode {
 *    int val;
 *    TreeNode left;
 *    TreeNode right;
 *    TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
   public List<Integer> inorderTraversal(TreeNode root) {
       List<Integer> list=new LinkedList<Integer>();
       if(root==null) return list;
       TreeNode p=root;
       Stack<TreeNode> stack=new Stack<TreeNode>();
       while(p!=null||!stack.isEmpty()){
           if(p!=null){
                stack.push(p);
                p=p.left;
           }
           else{
                p=stack.pop();
                list.add(p.val);
                p=p.right;
           }
       }
       return list;
    }
}

 

后续遍历：

方法一，使用linkedlist中的addFirst方法

public List<Integer> postorderTraversal(TreeNode root) {
	LinkedList<Integer> ans = new LinkedList<>();
	Stack<TreeNode> stack = new Stack<>();
	if (root == null) return ans;
	
	stack.push(root);
	while (!stack.isEmpty()) {
		TreeNode cur = stack.pop();
		ans.addFirst(cur.val);
		if (cur.left != null) {
			stack.push(cur.left);
		}
		if (cur.right != null) {
			stack.push(cur.right);
		} 
	}
	return ans;
}

方法二 标记已经访问过得节点

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<Integer>();
    if (root == null) {
        return res;
    }
    
    Set<TreeNode> visited = new HashSet<TreeNode>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode node = root;
    while(true) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        
        if (stack.isEmpty()) {
            break;
        }
        
        node = stack.peek().right;
        if (node == null || visited.contains(node)) {
        //只访问右孩子为空或者已经访问过得节点
            node = stack.pop();
            res.add(node.val);
            visited.add(node);
            node = null;
        }
    }
    
    return res;
}