fixes:#1806

Author: sam28u

Sorts/MorrisTraversal.js

@@ -0,0 +1,53 @@
+/**
+ * Morris Traversal (Inorder)
+ *
+ * This algorithm performs an inorder traversal of a binary tree
+ * without using recursion or a stack. Instead, it creates temporary
+ * "threads" in the tree to traverse nodes in O(N) time and O(1) space.
+ *
+ * Time Complexity: O(N) (each edge visited at most twice)
+ * Space Complexity: O(1)
+ *
+ * @param {TreeNode} root - Root node of the binary tree
+ * @returns {number[]} - The inorder traversal as an array
+ */
+
+export class TreeNode {
+  constructor(val, left = null, right = null) {
+    this.val = val
+    this.left = left
+    this.right = right
+  }
+}
+
+export function morrisTraversal(root) {
+  const result = []
+  let current = root
+
+  while (current !== null) {
+    if (current.left === null) {
+      // Case 1: No left child → visit current node
+      result.push(current.val)
+      current = current.right
+    } else {
+      // Case 2: Find inorder predecessor
+      let predecessor = current.left
+      while (predecessor.right !== null && predecessor.right !== current) {
+        predecessor = predecessor.right
+      }
+
+      if (predecessor.right === null) {
+        // Create a temporary thread from predecessor to current
+        predecessor.right = current
+        current = current.left
+      } else {
+        // Thread already exists → remove it and visit current
+        predecessor.right = null
+        result.push(current.val)
+        current = current.right
+      }
+    }
+  }
+
+  return result
+}

Sorts/test/MorrisTraversal.test.js

@@ -0,0 +1,62 @@
+import { morrisTraversal, TreeNode } from '../MorrisTraversal'
+
+describe('morrisTraversal (Inorder)', () => {
+  it('should return an empty array for an empty tree', () => {
+    expect(morrisTraversal(null)).toEqual([])
+  })
+
+  it('should return a single node when tree has only one node', () => {
+    const root = new TreeNode(10)
+    expect(morrisTraversal(root)).toEqual([10])
+  })
+
+  it('should correctly traverse a simple balanced tree', () => {
+    /**
+     *    2
+     *   / \
+     *  1   3
+     */
+    const root = new TreeNode(2, new TreeNode(1), new TreeNode(3))
+    expect(morrisTraversal(root)).toEqual([1, 2, 3])
+  })
+
+  it('should handle a left-skewed tree', () => {
+    /**
+     *   3
+     *  /
+     * 2
+     * /
+     *1
+     */
+    const root = new TreeNode(3, new TreeNode(2, new TreeNode(1)))
+    expect(morrisTraversal(root)).toEqual([1, 2, 3])
+  })
+
+  it('should handle a right-skewed tree', () => {
+    /**
+     * 1
+     *  \
+     *   2
+     *    \
+     *     3
+     */
+    const root = new TreeNode(1, null, new TreeNode(2, null, new TreeNode(3)))
+    expect(morrisTraversal(root)).toEqual([1, 2, 3])
+  })
+
+  it('should correctly traverse a larger tree', () => {
+    /**
+     *        4
+     *       / \
+     *      2   5
+     *     / \
+     *    1   3
+     */
+    const root = new TreeNode(
+      4,
+      new TreeNode(2, new TreeNode(1), new TreeNode(3)),
+      new TreeNode(5)
+    )
+    expect(morrisTraversal(root)).toEqual([1, 2, 3, 4, 5])
+  })
+})