二叉树的递归和非递归（栈）遍历

二叉树遍历

递归遍历

前序遍历

根->左->右

public static List<Integer> preOrderTraversal(TreeNode root,List<Integer> result) {
    if (root == null) {
        return result;
    }
    result.add(root.val);
    preOrderdTraveral(root.left,result);
    preOrderdTraveral(root.right,result);
    return result;
}

中序遍历

左->根->右

    public static List<Integer> midOrderTraversal(TreeNode root,List<Integer> result) {
        if (root == null) {
            return result;
        }
        midOrderdTraveral(root.left, result);
        result.add(root.val);
        midOrderdTraveral(root.right, result);
        return result;
    }

后续遍历

左->右->根

    public static List<Integer> lastOrderTraversal(TreeNode root,List<Integer> result) {
        if (root == null) {
            return result;
        }
        lastOrderdTraveral(root.left, result);
        lastOrderdTraveral(root.right, result);
        result.add(root.val);
        return result;
    }

栈遍历

递归遍历实质上属于方法调用，也就是栈的“后进先出”,因此可以借助栈实现二叉树的非递归遍历，每个节点都要入栈一次，根据遍历顺序决定出栈的时机

前序遍历

第一步：借助当前节点和栈的两层循环遍历，从根节点到左子节点依次向下，遍历每个根节点然后入栈，直到左边为空时，执行第二步
第二步：从栈顶取出元素得到右子节点赋值给当前节点，循环第一步

    public static List<Integer> preOrderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(!stack.isEmpty() || cur != null) {
            while (cur != null) {
                result.add(cur.val);
                stack.push(cur);
                cur = cur.left ;
            }
            TreeNode pop = stack.pop();
            cur = pop.right;
        }
        return result;
    }

中序遍历

第一步：借助当前节点和栈的两层循环遍历，从根节点到左子节点依次向下，经过的每个根节点入栈，直到最左边的节点，执行第二步
第二步：从栈顶取出元素得到最左子节点遍历，将右子节点赋值给当前节点，循环第一步

    public static List<Integer> midOrderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root ;
        while(cur !=null || !stack.isEmpty()){
            while (cur != null) {
                stack.push(cur);
                cur = cur.left ;
            }
            TreeNode pop = stack.pop();
            result.add(pop.val);
            cur = pop.right ;
        }
        return result;
    }

后续遍历

第一步：借助当前节点和栈的两层循环遍历，从根节点到左子节点依次向下，经过的每个根节点入栈，直到最左边的节点，执行第二步
第二步：得到栈顶节点，判断右子树是否为空并且是否为上一次遍历的节点，若是，则说明当前的根节点的左右子节点都遍历过，可以遍历当前的根节点；若不满足以上条件，若右节点不为空，则赋值给当前节点，否则从栈顶弹出并遍历得到左子节点，重复步骤一，可以先将右子节点放入栈顶，并遍历，最后遍历根节点

    public static List<Integer> lastOrderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root ;
        TreeNode pre = null ;
        while(cur != null || !stack.isEmpty()){
            while (cur != null) {
                stack.push(cur);
                cur = cur.left ;
            }
            TreeNode pop = stack.peek();
            if (pop.right != null && pop.right == pre) {
                TreeNode parent = stack.pop();
                result.add(parent.val);
                pre = parent ;
            }else{
                if (pop.right != null) {
                    cur = pop.right ;
                }else {
                    cur = stack.pop();
                    result.add(cur.val);
                    pre = cur ;
                    cur = null ;
                }
            }
        }
        return result;
    }