算法通关村——二叉树的迭代遍历

迭代实现二叉树的遍历

144.二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root == null) {
            return res;
        }
        //辅助栈
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        //
        TreeNode cur = root;

        while(!stack.isEmpty() || node != null) {
            //一路向左下处理
            while(node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            //当没有左孩子时，取出栈中的节点，向右孩子处理
            //下一次循环即为，处理右子树
            node = stack.pop();
            node = node.right;
        }
    }
}

94.二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root == null) {
            return res;
        }
        //辅助栈
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        //
        TreeNode node = root;
        //首次进入循环，会出现stack为空的情况
        while(!stack.isEmpty() || node != null) {
            //一路向左下，不访问
            while(node != null) {
                stack.push(node);
                node = node.left;
            }
			//核心
            //如果节点没有右子树（node = node.right,之后由第一个循环进行判断）
            //说明以该节点作为根节点的树，已经遍历结束
            //会继续回溯
            node = stack.pop();
            res.add(node.val);
            node = node.right;
        }
        return res;
    }
}

145.二叉树的后序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root == null) {
            return res;
        }
        //辅助栈
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        //
        TreeNode pre = root;
        while(!stack.isEmpty() || root != null) {
            while(root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            //当前没有左子树了，判断是处理右子树，还是处理当前节点
            //右子树已经遍历过的两种情况：
            //没有右子树
            //右子树刚刚被遍历
            if(root.right == null || pre == root.right) {
                //访问节点
                res.add(root.val);
                //记录上一个访问的节点
                pre = root;
                //这里有个大坑
                //每次遍历完左子树
                //如果不做置空操作
                //则会重新入栈左子树
                root = null;
            } else {
                //处理右子树
                //将当前节点入栈
                //root指向右子树根节点
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }
}