1. 二叉树的递归遍历

// 前序遍历·递归·LC144_二叉树的前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);
        return result;
    }

    public void preorder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preorder(root.left, result);
        preorder(root.right, result);
    }
}
// 中序遍历·递归·LC94_二叉树的中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }

    void inorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inorder(root.left, list);
        list.add(root.val);             // 注意这一句
        inorder(root.right, list);
    }
}
// 后序遍历·递归·LC145_二叉树的后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }

    void postorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        postorder(root.left, list);
        postorder(root.right, list);
        list.add(root.val);             // 注意这一句
    }
}

2. 二叉树的迭代遍历

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    if (root == null) {
        return result;
    }
    ArrayDeque<TreeNode> stack = new ArrayDeque<>();
    stack.push(root);
    //当stack不为空时就进行循环
    while (!stack.isEmpty()) {
        TreeNode treeNode = stack.pop();
        result.add(treeNode.val);
        //先将右结点放入stack再放入左节点是因为stack先进后出的性质。
        //那么在stack取出结点时，就是先取出左节点再取出右结点
        if (treeNode.right != null) {
            stack.push(treeNode.right);
        }

        if (treeNode.left != null) {
            stack.push(treeNode.left);
        }
    }
    return result;
}


public List<Integer> inorderTraversal(TreeNode root) {
    Deque<TreeNode> stack = new ArrayDeque<>();
    List<Integer> result = new ArrayList<>();
    TreeNode cur = root;
    if (root == null) {
        return result;
    }
    //如果当前treenode不为null或stack不为空那么就进行循环
    while (cur != null || !stack.isEmpty()) {
        //若当前treenode不为null，那么就将当前结点放入stack中，并让cur指向当前结点的左孩子
        if (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }else {
            //若当前treenode为null，那么就将stack中的第一个元素弹出来并将其值放入到结果中，让cur指针指向当前结点的右孩子
            cur = stack.pop();
            result.add(cur.val);
            cur = cur.right;
        }
    }
    return result;
}

    

public List<Integer> postorderTraversal(TreeNode root) {
    ArrayDeque<TreeNode> stack = new ArrayDeque();
    List<Integer> result = new ArrayList<>();
    if (root == null) {
        return result;
    }
    stack.push(root);
    //若stack不为空那么就进行循环
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        result.add(node.val);
        //若当前结点的左右不为null，那么就将结点的左右给放入stack中
        if (node.left != null) {
            stack.push(node.left);
        }
        if (node.right != null) {
            stack.push(node.right);
        }
    }
    //将result进行反转
    Collections.reverse(result);
    return result;
}