SOLN: Remove nth node (#195)

Author: retiman

src/linked-list/remove-nth-node-from-end-of-list.ts

@@ -11,16 +11,13 @@ export { removeNthFromEnd };
 // To do this in one iteration, throw all the nodes onto a list.  Then we can easily find the nth node from the end of
 // the list.  After that, we just have to point the (k - 1)th node to the (k + 1)th node.  Assuming both exist.
 //
+// You can also do this using two pointers, but this solution is a more straightforward.
+//
 // COMPLEXITY:
 //
 // Runs in O(n) time because we are iterating through the list once.  Runs in O(n) space because we are storing the list
 // in an array.
 function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
-  // Assume this means we aren't going to remove anything.
-  if (n === 0 || head === null) {
-    return head;
-  }
-
   // Just convert the linked list to an array so we can easily find the nth node from the end.
   const list: ListNode[] = [];
   let node: ListNode | null = head;
@@ -29,37 +26,33 @@ function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
     node = node.next;
   }
 
-  // Okay, now we try to find the nth node from the end of the list.  First make sure we can actually do this.  That is,
-  // n must be between 1 and the length of the list inclusive.
-  if (n > list.length) {
+  // Now make sure this operation can even be done.  If n is 0 or greater than the length of the list, then we can't
+  // then we can't remove anything!
+  if (head === null || n <= 0 || n > list.length) {
     return head;
   }
 
-  // Special case the single element list to make things easier (here, n === 1).
-  if (list.length === 1) {
-    return null;
-  }
+  // Create sentinel nodes to make the logic easier, and so we can return the head of the list later.
+  const sentinel = new ListNode();
+  sentinel.next = head;
 
   // Now that we know n is within bounds, let's find the node we want to remove.  For example, if we want to remove the
   // 2nd node from the end of the list with 3 elements, then the index is 1 (3 - 2 = 1).
   //
   // After this we just have point the (k - 1)th node to the (k + 1)th node.  Assuming both exist.
   const k = list.length - n;
 
-  // If the (k + 1)th node doesn't exist, then we are unlinking the tail of the list.  AKA n === 1.
-  if (k + 1 === list.length) {
-    list[k - 1].next = null;
-    return head;
-  }
+  // The previous node to remove is the a = (k - 1)th node.  If it turns out the (k - 1)th node doesn't exist, then node
+  // a is the sentinel node we created.
+  const a = list[k - 1] ?? sentinel;
 
-  // If the (k - 1)th node doesn't exist, then we are unlinking the head of the list.  AKA n === stack.length.
-  //
-  // We can just return head.next as that's the new head.
-  if (k - 1 < 0) {
-    return head.next;
-  }
+  // The next node to link it to is the c = (k + 1)th node.  If it turns out that the (k + 1)th node doesn't exist, then
+  // node c is null.
+  const c = list[k + 1] ?? null;
+
+  // Unlink the node b in position list[k] by setting the a node's next pointer to c.
+  a.next = c;
 
-  // Otherwise just make the (k - 1)th node point to the (k + 1)th node.
-  list[k - 1].next = list[k + 1];
-  return head;
+  // Return the list minus the sentinel.
+  return sentinel.next;
 }