leecode 二叉树的前中后序遍历

144. 二叉树的前序遍历

94. 二叉树的中序遍历

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> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preorder(root,res);
        return res;
    }

    private void preorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        res.add(root.val);
        preorder(root.left,res);
        preorder(root.right,res);
    }
}


中序遍历：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res=new ArrayList<Integer>();
        inorder(root,res);
        return res;
    }
    void inorder(TreeNode root,ArrayList<Integer> res){
        if(root==null)return;
        inorder(root.left,res);
        res.add(root.val);
        inorder(root.right,res);
    }
}
//中序遍历是俩个月前写的，代码看起来很丑。

后序遍历：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        postorder(root, res);
        return res;
    }
    
    private void postorder(TreeNode root, List<Integer> res) {
        if (root == null) return;
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

迭代：

前序遍历：
//前序遍历顺序：中-左-右，入栈顺序：中-右-左

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
//创建栈来遍历元素入栈出栈。
        Deque<TreeNode> test = new LinkedList<>();
        if (root == null) return res;
//先把头元素入栈
        test.push(root);
//栈不为空时一直循环遍历直到所有元素遍历结束
        while (!test.isEmpty()) {
//创一个node接住出栈元素用来向res中放值，同时方便操作当前元素的左右子树。
            TreeNode node = test.pop();
            res.add(node.val);
//这里先判断的右子树，因为右子树先入栈则后出栈，符合中前后的前序遍历顺序。
//还有一点，这里之前有个疑问，如果一个root中的左右子树的左右子树都有值，
//但是pop()的操作只进行了一次，那右子树的子树怎么放入。
//修改代码后发现了错误，在向res放入根节点之后，会判断左右子树不为空的话，则向栈中继续放入左右子树，
//最后左子树全部拿出来后会接着判断右子树是否还有子树，如果有会进行入栈操作接着进行，逻辑就清晰了。
            if(node.right != null) {
                test.push(node.right);
            }
            if(node.left != null) {
                test.push(node.left);
            }
        }
        return res;
    }
}


中序遍历：

//迭代和递归不同，只需要修改顺序就可以改变遍历方式，中序遍历顺序: 左-中-右 入栈顺序： 左-右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
//当前根节点不为空或者栈不为空，为了在第一次循环时栈中为空时开始循环，
//最后一个root元素遍历后root为空的时候可以使循环继续进行。
        while (root != null || !stk.isEmpty()) {
//判断根节点是否为空，不为空则循环将所有节点左子树放入栈中。
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
//中序遍历按照左中右顺序，所以先取出左子树的值放入res中
            root = stk.pop();
            res.add(root.val);
//这步是取得右子树的关键，判断当前节点是否有右子树，有则进入继续重复遍历，
//没有则回到循环操作节点：root = stk.pop()，继续判断是否有右子树。
            root = root.right;
        }
        return res;
    }
}

后序遍历：
//和前序遍历类似，后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
//准确说就是在前序遍历基础上改变了两点，一个是先入栈左子树后入栈右子树，一个是最后需要对结果翻转
//前序遍历是中左右，前序遍历的左右子树改变后是中右左，翻转后是左右中，
//这正好是后序遍历的顺序，就好理解了，记住就好。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new LinkedList<>();
        if (root == null) return res;
        stk.push(root);
        while (!stk.isEmpty()) {
            TreeNode node = stk.pop();
            res.add(node.val);
            if (node.left != null) {
                stk.push(node.left);
            }
            if (node.right != null) {
                stk.push(node.right);
            }
        }
        Collections.reverse(res);
        return res;
    }
}