三刷94

Author: diguage

docs/0000-data-structure-tree.adoc

@@ -40,6 +40,8 @@ image::images/0000-ds-tree-02.gif[{image_attr}]
 . 归并排序和二叉树后根遍历的递归顺序是一样的。
 
 
+
+[#morris-traversal]
 == Morris 遍历
 
 二叉搜索树相关的的一些题目，很可能就会利用中序遍历是升序序列的特性来处理一下问题。那么，在时间复杂度相同，但空间复杂度都特别优秀的 Morris 遍历就是一个很好的选择。
@@ -49,6 +51,8 @@ image::images/0000-ds-tree-01.jpg[{image_attr}]
 . xref:0098-validate-binary-search-tree.adoc[98. Validate Binary Search Tree]
 . xref:0099-recover-binary-search-tree.adoc[99. Recover Binary Search Tree]
 
+在 https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/96765/dong-hua-yan-shi-94-er-cha-shu-de-zhong-xu-bian-li/[94. 二叉树的中序遍历 - 动画演示+三种实现^] 中的“变形”莫尔斯算法则展示了莫尔斯算法的另一种 有趣用法。
+
 == 树形 DP 套路
 
 树形 DP 套路使用前提：如果题目求解目标是 S 规则，则求解流程可以定成以每一个节点为头节点的子树在 S 规则下的每一个答案，并且最终答案一定在其中。

docs/0094-binary-tree-inorder-traversal.adoc

@@ -1,28 +1,57 @@
 [#0094-binary-tree-inorder-traversal]
-= 94. Binary Tree Inorder Traversal
+= 94. 二叉树的中序遍历
+
+https://leetcode.cn/problems/binary-tree-inorder-traversal/[LeetCode - 94. 二叉树的中序遍历^]
+
+给定一个二叉树的根节点 `root` ，返回 _它的 *中序* 遍历_。
+
+*示例 1：*
+
+image::images/0094-01.jpg[{image_attr}]
+
+....
+输入：root = [1,null,2,3]
+输出：[1,3,2]
+....
+
+*示例 2：*
+
+....
+输入：root = []
+输出：[]
+....
+
+*示例 3：*
+
+....
+输入：root = [1]
+输出：[1]
+....
+
+*提示：*
+
+* 树中节点数目在范围 `[0, 100]` 内
+* `+-100 <= Node.val <= 100+`
+
+*进阶:* 递归算法很简单，你可以通过迭代算法完成吗？
+
+
+== 思路分析
 
-{leetcode}/problems/binary-tree-inorder-traversal/[LeetCode - Binary Tree Inorder Traversal^]
 
 迭代的方式，还不是很理解，还需要再思考思考。
 
-Given a binary tree, return the _inorder_ traversal of its nodes' values.
+迭代的办法就是用栈来模拟递归：有左节点就入栈；没有左节点就出栈，然后把有节点再入栈；以此类推。注意，入栈左右子树节点时，要把上下级的关联给斩断，否则会造成死循环。
 
-*Example:*
+TIP: 看官方题解，如果使用两层循环就不需要改变树的结构。自己想一想怎么实现？
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* [1,null,2,3]
-   1
-    \
-     2
-    /
-   3
+image::images/0094-10.gif[{image_attr}]
 
-*Output:* [1,3,2]
-----
+“变形”莫里斯算法也是非常有趣：
 
-*Follow up:* Recursive solution is trivial, could you do it iteratively?
+image::images/0094-11.gif[{image_attr}]
 
+NOTE: 详细介绍见： <<morris-traversal>>。
 
 [[src-0094]]
 [tabs]
@@ -53,5 +82,20 @@ include::{sourcedir}/_0094_BinaryTreeInorderTraversal_Recur.java[tag=answer]
 include::{sourcedir}/_0094_BinaryTreeInorderTraversal_Stack.java[tag=answer]
 ----
 --
+
+三刷::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0094_BinaryTreeInorderTraversal_3.java[tag=answer]
+----
+--
 ====
 
+
+== 参考资料
+
+. https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/25220/yan-se-biao-ji-fa-yi-chong-tong-yong-qie-jian-ming/[94. 二叉树的中序遍历 - 颜色标记法，一种通用且简明的树遍历方法^]
+. https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/96765/dong-hua-yan-shi-94-er-cha-shu-de-zhong-xu-bian-li/[94. 二叉树的中序遍历 - 动画演示+三种实现^]
+. https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/412886/er-cha-shu-de-zhong-xu-bian-li-by-leetcode-solutio/[94. 二叉树的中序遍历 - 官方题解^]

docs/images/0094-01.jpg

@@ -1904,6 +1904,11 @@ endif::[]
 |{doc_base_url}/0098-validate-binary-search-tree.adoc[题解]
 |✅ 树形DP套路或中序遍历
 
+|{counter:codes2503}
+|{leetcode_base_url}/binary-tree-inorder-traversal/[94. 二叉树的中序遍历^]
+|{doc_base_url}/0094-binary-tree-inorder-traversal.adoc[题解]
+|✅ 深度优先+栈。递归法非常简单；迭代法则是用栈来模拟递归；而“变形”莫尔斯解法则非常有趣。
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

docs/images/0094-10.gif

@@ -0,0 +1,63 @@
+package com.diguage.algo.leetcode;
+
+import com.diguage.algo.util.TreeNode;
+import com.diguage.util.TreeNodes;
+
+import java.util.*;
+
+public class _0094_BinaryTreeInorderTraversal_3 {
+  // tag::answer[]
+
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-11-13 23:12:08
+   */
+  public List<Integer> inorderTraversal(TreeNode root) {
+    if (root == null) {
+      return Collections.emptyList();
+    }
+    List<Integer> result = new ArrayList<>();
+    Deque<TreeNode> stack = new LinkedList<>();
+    stack.push(root);
+    while (!stack.isEmpty()) {
+      TreeNode peek = stack.peek();
+      if (peek.left != null) {
+        stack.push(peek.left);
+        peek.left = null;
+      } else {
+        TreeNode pop = stack.pop();
+        result.add(pop.val);
+        if (pop.right != null) {
+          stack.push(pop.right);
+          pop.right = null;
+        }
+      }
+    }
+    return result;
+  }
+  // end::answer[]
+
+  static void main() {
+    new _0094_BinaryTreeInorderTraversal_3()
+      .inorderTraversal(TreeNodes.buildTree(Arrays.asList(1, 2, 3, 4, 5, null, 8, null, null, 6, 7, 9)));
+  }
+
+//  }
+//  public List<Integer> inorderTraversal(TreeNode root) {
+//    if (root == null) {
+//      return Collections.emptyList();
+//    }
+//    List<Integer> result = new ArrayList<>();
+//    inorder(root, result);
+//    return result;
+//  }
+//
+//  private void inorder(TreeNode root, List<Integer> result) {
+//    if (root == null) {
+//      return;
+//    }
+//    inorder(root.left, result);
+//    result.add(root.val);
+//    inorder(root.right, result);
+//  }
+}