更简单的非递归遍历二叉树

递归方式

前序遍历

public List<Integer> res = new ArrayList<Integer>();
public List<Integer> postorderTraversal(TreeNode root) {//递归写法
    if(root == null)
        return res;
    res.add(root.val);
    postorderTraversal(root.left);
    postorderTraversal(root.right);    
    return res;
}

中序遍历

public List<Integer> res = new ArrayList<Integer>();
public List<Integer> postorderTraversal(TreeNode root) {//递归写法
    if(root == null)
        return res;
    postorderTraversal(root.left);
    res.add(root.val);
    postorderTraversal(root.right);    
    return res;
}

后序遍历

public List<Integer> res = new ArrayList<Integer>();
public List<Integer> postorderTraversal(TreeNode root) {//递归写法
    if(root == null)
        return res;
    postorderTraversal(root.left);    
    postorderTraversal(root.right); 
    res.add(root.val);   
    return res;
}

非递归方式

前序遍历

教科书

public void preorderTraversal(TreeNode root) {       
        Stack<TreeNode> stack = new Stack<>();
        do{
            while(root!=null){
                System.out.println(root.val);
                stack.push(root);
                root = root.left;
            }
            if(stack.size()!=0){
                root = stack.pop();
                root = root.right;
            }
        }while(stack.size()!=0 || root!=null);
       
    }

更简单的方法

 public void preorderTraversal(TreeNode root) {       
        Stack<TreeNode> stack = new Stack<>();        
        if(root == null){
            return;
        }
        //第一步是将根节点压入栈中
        stack.push(root);       
        //当它的孩子不为空时，将孩子压入栈，一定是先压右孩子再压左孩子
        while(!stack.isEmpty()){            
            root = stack.pop();
            System.out.println(root.val);
            if(root.right != null) stack.push(root.right);
            if(root.left != null) stack.push(root.left);
        }
        
    }

中序遍历

教科书

    /**
     * 非递归中序遍历
     * */
   public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        do{
            while(root!=null){
                stack.push(root);
                root = root.left;
            }
            if(stack.size()!=0){
                root = stack.pop();
                list.add(root.val);
                root = root.right;
            }
            
        }while(stack.size()!=0 || root!=null);
        
        return list;
    }

更简单的方法

 public List<Integer> iteration(TreeNode root) {
        if (root == null) return new ArrayList<>();
        List<Integer> results = new ArrayList<>();
        Stack<TreeNode> stack=new Stack();
        TreeNode node = root;
        while (node != null || stack.size() != 0) {
            if (node != null) {
                stack.push(node);//压栈操作
                node = node.left;//优先向左
            } else {
                node = stack.pop();//出处理节点值
                results.add(node.val);//左方肯定已经处理完了，再向右
                node = node.right;
            }
        }
        return results;
    }

后序遍历

教科书

    /**
     * 非递归后序遍历
     * */
    public List<Integer> postOrderNonCur(TreeNode root){
        List<Integer> resultList=new ArrayList<>();
        if(root==null)
            return resultList;
        Map<TreeNode,Integer> visitedMap=new HashMap<>();
        Stack<TreeNode> toBeVisitedStack=new Stack<>();
        toBeVisitedStack.push(root);
        while(!toBeVisitedStack.isEmpty()){
            TreeNode tempNode=toBeVisitedStack.peek(); //注意这里是peek而不是pop
            if(tempNode.left==null && tempNode.right==null){ //如果没有左右孩子则访问
                resultList.add(tempNode.val);
                visitedMap.put(tempNode, 1);
                toBeVisitedStack.pop();
                continue;
            }else if(!((tempNode.left!=null&&visitedMap.get(tempNode.left)==null )|| (tempNode.right!=null && visitedMap.get(tempNode.right)==null))){
                //如果节点的左右孩子均已被访问            
                resultList.add(tempNode.val);
                toBeVisitedStack.pop();
                visitedMap.put(tempNode, 1);
                continue;
            }
            if(tempNode.left!=null){
                while(tempNode.left!=null && visitedMap.get(tempNode.left)==null){//左孩子没有被访问
                    toBeVisitedStack.push(tempNode.left);
                    tempNode=tempNode.left;
                }
            }
            if(tempNode.right!=null){
                if(visitedMap.get(tempNode.right)==null){//右孩子没有被访问
                    toBeVisitedStack.push(tempNode.right);
                }               
            }
        }
        return resultList;
    }

更简单的方法

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<Integer>();
    if(root == null)
        return res;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(root);
    while(!stack.isEmpty()){
        TreeNode node = stack.pop();
        if(node.left != null) stack.push(node.left);//和传统先序遍历不一样，先将左结点入栈
        if(node.right != null) stack.push(node.right);//后将右结点入栈
        res.add(0,node.val);                        //逆序添加结点值
    }     
    return res;
}