从0开始的秋招刷题路，记录下所刷每道题的题解，帮助自己回顾总结

94. 二叉树的中序遍历（Easy）

• 给定一个二叉树的根节点 root ，返回它的 **中序 **遍历。

• 示例 1：

  

  输入：root = [1,null,2,3]
  输出：[1,3,2]

• 示例 2：

  输入：root = []
  输出：[]

• 示例 3：

  输入：root = [1]
  输出：[1]

• 示例 4：

  

  输入：root = [1,2]
  输出：[2,1]

• 示例 5：

  

  输入：root = [1,null,2]
  输出：[1,2]

• 提示：

  树中节点数目在范围 [0, 100] 内
  -100 <= Node.val <= 100

• 进阶: 递归算法很简单，你可以通过迭代算法完成吗？

• 递归

  // 前序遍历·递归·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);             // 注意这一句
      }
  }
  

• 迭代

  // 前序遍历顺序：中-左-右，入栈顺序：中-右-左
  class Solution {
      public List<Integer> preorderTraversal(TreeNode root) {
          List<Integer> result = new ArrayList<>();
          if (root == null){
              return result;
          }
          Stack<TreeNode> stack = new Stack<>();
          stack.push(root);
          while (!stack.isEmpty()){
              TreeNode node = stack.pop();
              result.add(node.val);
              if (node.right != null){
                  stack.push(node.right);
              }
              if (node.left != null){
                  stack.push(node.left);
              }
          }
          return result;
      }
  }
  
  // 中序遍历顺序: 左-中-右 入栈顺序： 左-右
  class Solution {
      public List<Integer> inorderTraversal(TreeNode root) {
          List<Integer> result = new ArrayList<>();
          if (root == null){
              return result;
          }
          Stack<TreeNode> stack = new Stack<>();
          TreeNode cur = root;
          while (cur != null || !stack.isEmpty()){
             if (cur != null){
                 stack.push(cur);
                 cur = cur.left;
             }else{
                 cur = stack.pop();
                 result.add(cur.val);
                 cur = cur.right;
             }
          }
          return result;
      }
  }
  
  // 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
  class Solution {
      public List<Integer> postorderTraversal(TreeNode root) {
          List<Integer> result = new ArrayList<>();
          if (root == null){
              return result;
          }
          Stack<TreeNode> stack = new Stack<>();
          stack.push(root);
          while (!stack.isEmpty()){
              TreeNode node = stack.pop();
              result.add(node.val);
              if (node.left != null){
                  stack.push(node.left);
              }
              if (node.right != null){
                  stack.push(node.right);
              }
          }
          Collections.reverse(result);
          return result;
      }
  }