ts-3: addressed review comments (imports, naming, ditch extra types)

Author: aikhelis

typescript/Linked Lists/flatten_multi_level_list.ts

@@ -1,23 +1,26 @@
-/* Definition of MultiLevelListNode:
-class MultieLevelListNode {
-    val: number; next: MLLNode; child: MLLNode;
+import { MultiLevelListNode } from "./ds";
+
+/* Definition of MultiLevelListNode: 
+class MultiLevelListNode {
+    val: number; 
+    next: MultiLevelListNode | null; 
+    child: MultiLevelListNode | null;
     constructor(val: number){
         this.val = val;
         this.next = null;
         this.child = null;
     }
-}
-type MLLNode = MultieLevelListNode | null;
-*/
+}*/
+
 
-function flattenMultiLevelList(head: MLLNode): MLLNode {
+function flattenMultiLevelList(head: MultiLevelListNode | null): MultiLevelListNode | null {
     if (!head) 
         return head;
-    let tail: MLLNode = head;
+    let tail: MultiLevelListNode | null = head;
     // Find the tail of the linked list at the first level.
     while (tail.next !== null)
         tail = tail.next;
-    let curr: MLLNode = head;
+    let curr: MultiLevelListNode | null = head;
     // Process each node at the current level. If a node has a child linked list,
     // append it to the tail and then update the tail to the end of the extended 
     // linked list. Continue until all nodes at the current level are processed.

typescript/Linked Lists/linked_list_intersection.ts

@@ -1,29 +1,29 @@
+import { ListNode } from './ds';
+
 /* Definition of ListNode:
 class ListNode {
-    val: number; 
-    next: LLNode;
-    constructor(val: number, next: LLNode = null){
+    val: number; next: ListNode | null;
+    constructor(val: number){
         this.val = val;
-        this.next = next;
+        this.next = null;
     }
-}
-type LLNode = ListNode | null;
-*/
+}*/
+
 
-function linkedListIntersection(head_A: LLNode, head_B: LLNode): LLNode {
-    let ptr_A = head_A, ptr_B = head_B;
-    // Traverse through list A with 'ptr_A' and list B with 'ptr_B' 
+function linkedListIntersection(headA: ListNode | null, headB: ListNode | null): ListNode | null {
+    let ptrA = headA, ptrB = headB;
+    // Traverse through list A with 'ptrA' and list B with 'ptrB' 
     // until they meet.
-    while (ptr_A !== ptr_B) {
-        // Traverse list A -> list B by first traversing 'ptr_A' and 
+    while (ptrA !== ptrB) {
+        // Traverse list A -> list B by first traversing 'ptrA' and 
         // then, upon reaching the end of list A, continue the 
         // traversal from the head of list B.
-        ptr_A = ptr_A !== null ? ptr_A.next : head_B;
+        ptrA = ptrA !== null ? ptrA.next : headB;
         // Simultaneously, traverse list B -> list A.
-        ptr_B = ptr_B !== null ? ptr_B.next : head_A;
+        ptrB = ptrB !== null ? ptrB.next : headA;
     }
-    // At this point, 'ptr_A' and 'ptr_B' either point to the 
+    // At this point, 'ptrA' and 'ptrB' either point to the 
     // intersection node or both are null if the lists do not 
     // intersect. Return either pointer.
-    return ptr_A;
+    return ptrA;
 }

typescript/Linked Lists/linked_list_reversal.ts

@@ -1,22 +1,21 @@
+import { ListNode } from './ds';
+
 /* Definition of ListNode:
 class ListNode {
-    val: number; 
-    next: LLNode;
-    constructor(val: number, next: LLNode = null){
+    val: number; next: ListNode | null;
+    constructor(val: number){
         this.val = val;
-        this.next = next;
+        this.next = null;
     }
-}
-type LLNode = ListNode | null;
-*/
+}*/
 
-function linkedListReversal(head: LLNode): LLNode {
-    let currNode: LLNode = head;
-    let prevNode: LLNode = null;
+function linkedListReversal(head: ListNode | null): ListNode | null {
+    let currNode: ListNode | null = head;
+    let prevNode: ListNode | null = null;
     // Reverse the direction of each node's pointer until 'currNode' 
     // is null.
     while (currNode !== null){
-        const nextNode: LLNode = currNode.next;
+        const nextNode: ListNode | null = currNode.next;
         currNode.next = prevNode;
         prevNode = currNode;
         currNode = nextNode;

typescript/Linked Lists/linked_list_reversal_recursive.ts

@@ -1,21 +1,20 @@
+import { ListNode } from './ds';
+
 /* Definition of ListNode:
 class ListNode {
-    val: number; 
-    next: LLNode;
-    constructor(val: number, next: LLNode = null){
+    val: number; next: ListNode | null;
+    constructor(val: number){
         this.val = val;
-        this.next = next;
+        this.next = null;
     }
-}
-type LLNode = ListNode | null;
-*/
+}*/
 
-function linkedListReversalRecursive(head: LLNode): LLNode {
+function linkedListReversalRecursive(head: ListNode | null): ListNode | null {
     // Base cases.
     if (!head || !head.next)
         return head;
     // Recursively reverse the sublist starting from the next node.
-    const newHead: LLNode = linkedListReversalRecursive(head.next);
+    const newHead: ListNode | null = linkedListReversalRecursive(head.next);
     // Connect the reversed linked list to the head node to fully
     // reverse the entire linked list.
     head.next.next = head;

typescript/Linked Lists/lru_cache.ts

@@ -1,3 +1,6 @@
+import { DoublyLinkedListNode } from './ds';
+
+/* Definition of DoublyLinkedListNode:
 class DoublyLinkedListNode {
     key: number; val: number; 
     prev: DoublyLinkedListNode | null; 
@@ -9,7 +12,7 @@ class DoublyLinkedListNode {
         this.prev = null;
         this.next = null;
     }
-}
+}*/
 
 class LRUCache {
     capacity: number;

typescript/Linked Lists/palindromic_linked_list.ts

@@ -1,16 +1,15 @@
-/* Definition of ListNode: 
+import { ListNode } from './ds';
+
+/* Definition of ListNode:
 class ListNode {
-    val: number; 
-    next: LLNode;
+    val: number; next: ListNode | null;
     constructor(val: number){
         this.val = val;
         this.next = null;
     }
-}
-type LLNode = ListNode | null;
-*/
+}*/
 
-function palindromicLinkedList(head: LLNode): boolean {
+function palindromicLinkedList(head: ListNode | null): boolean {
     // Find the middle of the linked list and then reverse the second half of the
     // linked list starting at this midpoint.
     const mid = findMiddle(head);
@@ -28,9 +27,9 @@ function palindromicLinkedList(head: LLNode): boolean {
 }
 
 // From the 'Reverse Linked List' problem.
-function reverseList(head: LLNode): LLNode {
-    let prevNode: LLNode = null;
-    let currNode: LLNode = head;
+function reverseList(head: ListNode | null): ListNode | null {
+    let prevNode: ListNode | null = null;
+    let currNode: ListNode | null = head;
     while (currNode) {
         const nextNode = currNode.next;
         currNode.next = prevNode;
@@ -41,9 +40,9 @@ function reverseList(head: LLNode): LLNode {
 }
 
 // From the 'Linked List Midpoint' problem.
-function findMiddle(head: LLNode): LLNode {
-    let slow: LLNode = head;
-    let fast: LLNode = head;
+function findMiddle(head: ListNode | null): ListNode | null {
+    let slow: ListNode | null = head;
+    let fast: ListNode | null = head;
     while (fast && fast.next) {
         slow = slow!.next;
         fast = fast.next!.next;

typescript/Linked Lists/remove_kth_last_node.ts

@@ -1,21 +1,21 @@
-/* Definition of ListNode: 
+import { ListNode } from './ds';
+
+/* Definition of ListNode:
 class ListNode {
-    val: number; 
-    next: LLNode;
+    val: number; next: ListNode | null;
     constructor(val: number){
         this.val = val;
         this.next = null;
     }
-}
-type LLNode = ListNode | null;
-*/
+}*/
 
-function removeKthLastNode(head: LLNode, k: number): LLNode {
+function removeKthLastNode(head: ListNode | null, k: number): ListNode | null {
     // A dummy node to ensure there's a node before 'head' in case we 
     // need to remove the head node.
-    let dummy: LLNode = new ListNode(-1);
+    let dummy: ListNode | null = new ListNode(-1);
     dummy.next = head;
-    let trailer: LLNode = dummy, leader: LLNode = dummy;
+    let trailer: ListNode | null = dummy;
+    let leader: ListNode | null = dummy;
     // Advance 'leader' k steps ahead.  
     for (let i = 0; i < k; i++){
         leader = leader.next;