axross · axross · Sep 30, 2019 · Sep 30, 2019
diff --git a/solutions/binaryTreeInorderTraversal.test.ts b/solutions/binaryTreeInorderTraversal.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import inorderTraversal from "./binaryTreeInorderTraversal";
 
 describe("94. Binary Tree Inorder Traversal", () => {

diff --git a/solutions/binaryTreeInorderTraversal.ts b/solutions/binaryTreeInorderTraversal.ts
@@ -1,11 +1,13 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 94. Binary Tree Inorder Traversal
 // https://leetcode.com/problems/binary-tree-inorder-traversal/
-export default function inorderTraversal<T>(root: TreeNode<T> | null): T[] {
+export default function inorderTraversal<T>(
+  root: BinaryTreeNode<T> | null
+): T[] {
   const history: T[] = [];
 
-  function traverse(node: TreeNode<T> | null): void {
+  function traverse(node: BinaryTreeNode<T> | null): void {
     if (node === null) return;
 
     traverse(node.left);

diff --git a/solutions/binaryTreeLevelOrderTraversal.test.ts b/solutions/binaryTreeLevelOrderTraversal.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import levelOrder from "./binaryTreeLevelOrderTraversal";
 
 describe("102. Binary Tree Level Order Traversal", () => {

diff --git a/solutions/binaryTreeLevelOrderTraversal.ts b/solutions/binaryTreeLevelOrderTraversal.ts
@@ -1,11 +1,11 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 102. Binary Tree Level Order Traversal
 // https://leetcode.com/problems/binary-tree-level-order-traversal/
-export default function levelOrder<T>(root: TreeNode<T> | null): T[][] {
+export default function levelOrder<T>(root: BinaryTreeNode<T> | null): T[][] {
   const valuesEachLevel: T[][] = [];
 
-  function traverse(node: TreeNode<T> | null, level: number) {
+  function traverse(node: BinaryTreeNode<T> | null, level: number) {
     if (node === null) return;
 
     if (valuesEachLevel[level]) {

diff --git a/solutions/binaryTreePostorderTraversal.test.ts b/solutions/binaryTreePostorderTraversal.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import postorderTraversal from "./binaryTreePostorderTraversal";
 
 describe("145. Binary Tree Postorder Traversal", () => {

diff --git a/solutions/binaryTreePostorderTraversal.ts b/solutions/binaryTreePostorderTraversal.ts
@@ -1,11 +1,13 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 145. Binary Tree Postorder Traversal
 // https://leetcode.com/problems/binary-tree-postorder-traversal/
-export default function postorderTraversal<T>(root: TreeNode<T> | null): T[] {
+export default function postorderTraversal<T>(
+  root: BinaryTreeNode<T> | null
+): T[] {
   const history: T[] = [];
 
-  function traverse(node: TreeNode<T> | null): void {
+  function traverse(node: BinaryTreeNode<T> | null): void {
     if (node === null) return;
 
     traverse(node.left);

diff --git a/solutions/binaryTreePreorderTraversal.test.ts b/solutions/binaryTreePreorderTraversal.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import preorderTraversal from "./binaryTreePreorderTraversal";
 
 describe("144. Binary Tree Preorder Traversal", () => {

diff --git a/solutions/binaryTreePreorderTraversal.ts b/solutions/binaryTreePreorderTraversal.ts
@@ -1,11 +1,13 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 144. Binary Tree Preorder Traversal
 // https://leetcode.com/problems/binary-tree-preorder-traversal/
-export default function preorderTraversal<T>(root: TreeNode<T> | null): T[] {
+export default function preorderTraversal<T>(
+  root: BinaryTreeNode<T> | null
+): T[] {
   const history: T[] = [];
 
-  function traverse(node: TreeNode<T> | null): void {
+  function traverse(node: BinaryTreeNode<T> | null): void {
     if (node === null) return;
 
     history.push(node.val);

diff --git a/solutions/countCompleteTreeNodes.test.ts b/solutions/countCompleteTreeNodes.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import countNodes from "./countCompleteTreeNodes";
 
 describe("222. Count Complete Tree Nodes", () => {

diff --git a/solutions/countCompleteTreeNodes.ts b/solutions/countCompleteTreeNodes.ts
@@ -1,8 +1,8 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 222. Count Complete Tree Nodes
 // https://leetcode.com/problems/count-complete-tree-nodes/
-function countNodes(root: TreeNode<number> | null): number {
+function countNodes(root: BinaryTreeNode<number> | null): number {
   if (!root) return 0;
 
   const leftHeight = calculateHeight(root.left);
@@ -17,7 +17,7 @@ function countNodes(root: TreeNode<number> | null): number {
       2 ** rightHeight + countNodes(root.left);
 }
 
-function calculateHeight(root: TreeNode<number> | null): number {
+function calculateHeight(root: BinaryTreeNode<number> | null): number {
   return root ? 1 + calculateHeight(root.left) : 0;
 }
 

diff --git a/solutions/countUnivalueSubtrees.test.ts b/solutions/countUnivalueSubtrees.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import countUnivalSubtrees from "./countUnivalueSubtrees";
 
 describe("250. Count Univalue Subtrees", () => {

diff --git a/solutions/countUnivalueSubtrees.ts b/solutions/countUnivalueSubtrees.ts
@@ -1,11 +1,13 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 250. Count Univalue Subtrees
 // https://leetcode.com/problems/count-univalue-subtrees/
 export default function countUnivalSubtrees(
-  root: TreeNode<number> | null
+  root: BinaryTreeNode<number> | null
 ): number {
-  function traverse(node: TreeNode<number> | null): [number, number | null] {
+  function traverse(
+    node: BinaryTreeNode<number> | null
+  ): [number, number | null] {
     if (node === null) return [0, null];
 
     let [leftCount, leftValue] = traverse(node.left);

diff --git a/solutions/diameterOfBinaryTree.test.ts b/solutions/diameterOfBinaryTree.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import diameterOfBinaryTree from "./diameterOfBinaryTree";
 
 describe("543. Diameter of Binary Tree", () => {

diff --git a/solutions/diameterOfBinaryTree.ts b/solutions/diameterOfBinaryTree.ts
@@ -1,11 +1,13 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 543. Diameter of Binary Tree
 // https://leetcode.com/problems/diameter-of-binary-tree/
 export default function diameterOfBinaryTree<T>(
-  node: TreeNode<T> | null
+  node: BinaryTreeNode<T> | null
 ): number {
-  function getHeightAndDiameter(node: TreeNode<T> | null): [number, number] {
+  function getHeightAndDiameter(
+    node: BinaryTreeNode<T> | null
+  ): [number, number] {
     if (node === null) return [-1, -1];
 
     const [leftHeight, leftDiameter] = getHeightAndDiameter(node.left);

diff --git a/solutions/linkedListCycle.test.ts b/solutions/linkedListCycle.test.ts
@@ -1,4 +1,5 @@
-import { createListNode, ListNode } from "../utilities/ListNode";
+import { createSinglyLinkedListNode } from "../testUtilities/LinkedList";
+import { SinglyLinkedListNode } from "../types/LinkedList";
 import hasCycle from "./linkedListCycle";
 
 describe("141. Linked List Cycle", () => {
@@ -10,10 +11,10 @@ describe("141. Linked List Cycle", () => {
 
   for (const [[values, cycleStart], expected] of TEST_CASES) {
     it(`returns ${expected} when called with [${values}] (cycle starts from ${cycleStart})`, () => {
-      const head = createListNode(values);
+      const head = createSinglyLinkedListNode(values);
 
       let node = head;
-      let cycleStartNode: ListNode<number> | null = null;
+      let cycleStartNode: SinglyLinkedListNode<number> | null = null;
 
       for (const i of values.keys()) {
         if (i === cycleStart) {

diff --git a/solutions/linkedListCycle.ts b/solutions/linkedListCycle.ts
@@ -1,11 +1,13 @@
-import { ListNode } from "../utilities/ListNode";
+import { SinglyLinkedListNode } from "../types/LinkedList";
 
 // 141. Linked List Cycle
 // https://leetcode.com/problems/linked-list-cycle/
-export default function hasCycle<T>(head: ListNode<T> | null): boolean {
+export default function hasCycle<T>(
+  head: SinglyLinkedListNode<T> | null
+): boolean {
   function traverse(
-    previous: ListNode<T> | null,
-    node: ListNode<T> | null
+    previous: SinglyLinkedListNode<T> | null,
+    node: SinglyLinkedListNode<T> | null
   ): boolean {
     if (node === null) return false;
     if (node === head && previous !== null) return true;

diff --git a/solutions/maximumDepthOfBinaryTree.test.ts b/solutions/maximumDepthOfBinaryTree.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import maxDepth from "./maximumDepthOfBinaryTree";
 
 describe("104. Maximum Depth of Binary Tree", () => {

diff --git a/solutions/maximumDepthOfBinaryTree.ts b/solutions/maximumDepthOfBinaryTree.ts
@@ -1,8 +1,8 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 104. Maximum Depth of Binary Tree
 // https://leetcode.com/problems/maximum-depth-of-binary-tree/
-export default function maxDepth<T>(node: TreeNode<T> | null): number {
+export default function maxDepth<T>(node: BinaryTreeNode<T> | null): number {
   return node === null
     ? 0
     : Math.max(maxDepth(node.left), maxDepth(node.right)) + 1;

diff --git a/solutions/mergeTwoLists.test.ts b/solutions/mergeTwoLists.test.ts
@@ -1,4 +1,4 @@
-import { createListNode } from "../utilities/ListNode";
+import { createSinglyLinkedListNode } from "../testUtilities/LinkedList";
 import mergeTwoLists from "./mergeTwoLists";
 
 describe("21. Merge Two Sorted Lists", () => {
@@ -10,8 +10,11 @@ describe("21. Merge Two Sorted Lists", () => {
   for (const [[list1, list2], expected] of TEST_CASES) {
     it(`returns [${expected}] when called with [${list1}] and [${list2}]`, () => {
       expect(
-        mergeTwoLists(createListNode(list1), createListNode(list2))
-      ).toEqual(createListNode(expected));
+        mergeTwoLists(
+          createSinglyLinkedListNode(list1),
+          createSinglyLinkedListNode(list2)
+        )
+      ).toEqual(createSinglyLinkedListNode(expected));
     });
   }
 });
diff --git a/solutions/mergeTwoLists.ts b/solutions/mergeTwoLists.ts
@@ -1,11 +1,11 @@
-import { ListNode } from "../utilities/ListNode";
+import { SinglyLinkedListNode } from "../types/LinkedList";
 
 // 21. Merge Two Sorted Lists
 // https://leetcode.com/problems/merge-two-sorted-lists/
 function mergeTwoLists<T>(
-  list1: ListNode<T> | null,
-  list2: ListNode<T> | null
-): ListNode<T> | null {
+  list1: SinglyLinkedListNode<T> | null,
+  list2: SinglyLinkedListNode<T> | null
+): SinglyLinkedListNode<T> | null {
   if (!list1) {
     return list2;
   }

diff --git a/solutions/minimumDepthOfBinaryTree.test.ts b/solutions/minimumDepthOfBinaryTree.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import minDepth from "./minimumDepthOfBinaryTree";
 
 describe("111. Minimum Depth of Binary Tree", () => {

diff --git a/solutions/minimumDepthOfBinaryTree.ts b/solutions/minimumDepthOfBinaryTree.ts
@@ -1,9 +1,9 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 111. Minimum Depth of Binary Tree
 // https://leetcode.com/problems/minimum-depth-of-binary-tree/
-export default function minDepth<T>(node: TreeNode<T> | null) {
-  const queue: [TreeNode<T> | null, number][] = [[node, 1]];
+export default function minDepth<T>(node: BinaryTreeNode<T> | null) {
+  const queue: [BinaryTreeNode<T> | null, number][] = [[node, 1]];
 
   while (queue.length > 0) {
     const [node, depth] = queue.shift()!;

diff --git a/solutions/palindromeLinkedList.test.ts b/solutions/palindromeLinkedList.test.ts
@@ -1,4 +1,4 @@
-import { createListNode } from "../utilities/ListNode";
+import { createSinglyLinkedListNode } from "../testUtilities/LinkedList";
 import isPalindrome from "./palindromeLinkedList";
 
 describe("234. Palindrome Linked List", () => {
@@ -11,7 +11,7 @@ describe("234. Palindrome Linked List", () => {
 
   for (const [values, expected] of TEST_CASES) {
     it(`returns ${expected} when called with [${values}]`, () => {
-      expect(isPalindrome(createListNode(values))).toBe(expected);
+      expect(isPalindrome(createSinglyLinkedListNode(values))).toBe(expected);
     });
   }
 });
diff --git a/solutions/palindromeLinkedList.ts b/solutions/palindromeLinkedList.ts
@@ -1,11 +1,13 @@
-import { ListNode } from "../utilities/ListNode";
+import { SinglyLinkedListNode } from "../types/LinkedList";
 
 // 234. Palindrome Linked List
 // https://leetcode.com/problems/palindrome-linked-list/
-export default function isPalindrome<T>(node: ListNode<T> | null): boolean {
+export default function isPalindrome<T>(
+  node: SinglyLinkedListNode<T> | null
+): boolean {
   let left = node;
 
-  function traverse(right: ListNode<T> | null): boolean {
+  function traverse(right: SinglyLinkedListNode<T> | null): boolean {
     if (right === null) return true;
 
     const isNextMightBePalindrome = traverse(right.next);

diff --git a/solutions/pathSum.test.ts b/solutions/pathSum.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import pathSum from "./pathSum";
 
 describe("112. Path Sum", () => {

diff --git a/solutions/pathSum.ts b/solutions/pathSum.ts
@@ -1,9 +1,9 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 112. Path Sum
 // https://leetcode.com/problems/path-sum/
 export default function hasPathSum(
-  root: TreeNode<number> | null,
+  root: BinaryTreeNode<number> | null,
   sum: number
 ): boolean {
   // ⚠️ as following the test cases, we need to return false for hasPathSum(null, 0)

diff --git a/solutions/reverseLinkedList.test.ts b/solutions/reverseLinkedList.test.ts
@@ -1,4 +1,4 @@
-import { createListNode } from "../utilities/ListNode";
+import { createSinglyLinkedListNode } from "../testUtilities/LinkedList";
 import reverseList from "./reverseLinkedList";
 
 describe("206. Reverse Linked List", () => {
@@ -11,8 +11,8 @@ describe("206. Reverse Linked List", () => {
 
   for (const [values, expected] of TEST_CASES) {
     it(`returns [${expected}] when called with [${values}]`, () => {
-      expect(reverseList(createListNode(values))).toEqual(
-        createListNode(expected)
+      expect(reverseList(createSinglyLinkedListNode(values))).toEqual(
+        createSinglyLinkedListNode(expected)
       );
     });
   }

diff --git a/solutions/reverseLinkedList.ts b/solutions/reverseLinkedList.ts
@@ -1,8 +1,10 @@
-import { ListNode } from "../utilities/ListNode";
+import { SinglyLinkedListNode } from "../types/LinkedList";
 
 // 206. Reverse Linked List
 // https://leetcode.com/problems/reverse-linked-list/
-function reverseList<T>(head: ListNode<T> | null): ListNode<T> | null {
+function reverseList<T>(
+  head: SinglyLinkedListNode<T> | null
+): SinglyLinkedListNode<T> | null {
   if (head === null || head.next === null) return head;
 
   // call itself recursively with next node as the new head:  [1, 2, 3] -> [2, 3] -> [3]

diff --git a/solutions/subtreeOfAnotherTree.test.ts b/solutions/subtreeOfAnotherTree.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import isSubtree from "./subtreeOfAnotherTree";
 
 describe("572. Subtree of Another Tree", () => {

diff --git a/solutions/subtreeOfAnotherTree.ts b/solutions/subtreeOfAnotherTree.ts
@@ -1,17 +1,20 @@
-import { TreeNode } from "../utilities/TreeNode";
+import { BinaryTreeNode } from "../types/BinaryTree";
 
 // 572. Subtree of Another Tree
 // https://leetcode.com/problems/subtree-of-another-tree/
 export default function isSubtree<T = number>(
-  s: TreeNode<T> | null,
-  t: TreeNode<T> | null
+  s: BinaryTreeNode<T> | null,
+  t: BinaryTreeNode<T> | null
 ): boolean {
   return s === null
     ? s === t
     : isSameTree(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
 }
 
-function isSameTree<T>(s: TreeNode<T> | null, t: TreeNode<T> | null): boolean {
+function isSameTree<T>(
+  s: BinaryTreeNode<T> | null,
+  t: BinaryTreeNode<T> | null
+): boolean {
   if (s === null && t === null) return true;
 
   if (s !== null && t !== null)

diff --git a/solutions/symmetricTree.test.ts b/solutions/symmetricTree.test.ts
@@ -1,4 +1,4 @@
-import { createBinaryTreeNode } from "../utilities/TreeNode";
+import { createBinaryTreeNode } from "../testUtilities/BinaryTree";
 import isSymmetric from "./symmetricTree";
 
 describe("101. Symmetric Tree", () => {