8/11 to 8/13 (Driving with JJ to MiW in Huntsville and flight back)

- sorted_lists_merge.cc
- delete_node_from_list.cc
- is_list_cyclic.cc
- reverse_sublist.cc

Author: jsgoller1

elements-of-programming-interviews/cpp/delete_node_from_list.cc

@@ -3,8 +3,26 @@
 #include "test_framework/timed_executor.h"
 
 // Assumes node_to_delete is not tail.
+/*
+ Linear time: shift node->next's data to node. Then remove the final node
+ from the list.
+
+ while (node && node->next && node->next->next){
+    node->data = node->next->data
+    node = node->next;
+ }
+ node->data = node->next->data
+ node->next = nullptr;
+*/
+
 void DeletionFromList(const shared_ptr<ListNode<int>>& node_to_delete) {
-  // TODO - you fill in here.
+  shared_ptr<ListNode<int>> node = node_to_delete;
+  while (node && node->next && node->next->next) {
+    node->data = node->next->data;
+    node = node->next;
+  }
+  node->data = node->next->data;
+  node->next = nullptr;
   return;
 }
 shared_ptr<ListNode<int>> DeletionFromListWrapper(

elements-of-programming-interviews/cpp/is_list_cyclic.cc

@@ -1,15 +1,94 @@
 #include <memory>
+#include <set>
 
 #include "list_node.h"
 #include "test_framework/generic_test.h"
 #include "test_framework/test_failure.h"
 #include "test_framework/timed_executor.h"
+using std::set;
 using std::shared_ptr;
 
+// Normal way: tortise and hare method; list must be finite. But this doesn't
+// return the first node of the cycle.
+
+// O(n) space - just use a set.
+
+// O(c) space, O(n^2) time; use Floyd's method (tortise/hare) to find cycle.
+// Then, start another pointer (turtle; moves one at a time) off from the start
+// of the list. Each time turtle moves, have the tortise pointer do a full lap
+// until it reaches either the hare or the turtle. If tortise reaches hare,
+// turtle is not on cycle yet. If tortise reaches turtle, turtle has reached
+// first node of cycle.
+
+shared_ptr<ListNode<int>> HasCycleLinearSpace(
+    const shared_ptr<ListNode<int>>& head) {
+  shared_ptr<ListNode<int>> curr = head;
+  set<shared_ptr<ListNode<int>>> visited;
+  while (curr && visited.find(curr) == visited.end()) {
+    visited.insert(curr);
+    curr = curr->next;
+  }
+  return curr;
+}
+
+/*
+  - Suppose we use the Tortise/Hare strategy to force the two pointers ("slow"
+  and "fast") to meet.
+  - Assume this list:
+              _______________
+              V              |
+    0 -> 1 -> 2 -> 3 -> 4 -> 5
+
+  - The linked list can be described using the following:
+    - A: Nodes not in cycles (2: 0, and 1)
+    - B: Distance from start of cycle meeting point (2)
+        - (0,0), (1,2), (2,4), (3, 2), (4,4)
+    - C: cycle length (4: 2,3,4,5)
+  - When slow meets fast, slow traveled through all of the non-cycle nodes (A)
+  and the distance from the first cycle node to the meeting point to B, so
+  A+B.
+  - Because fast moves 2 nodes for each of slow's 1, fast has moved 2(A+B)
+  when they meet; the extra A+B that fast has moved before meeting slow happens
+  inside the loop.
+  - Suppose we now reset slow; fast is still at the meeting point:
+    - Slow is now A away from the first node in the cycle
+    - Fast is C-B away from the first node in the cycle.
+    - If A = C-B, then they meet at the first node of the cycle.
+      - When hare traveled the first A+B, it arrived at the meeting point.
+        When it then traveled another A+B, it arrived at the meeting point
+        again. This does _not_ mean that C = A+B, but it does mean that C*N =
+  A+B.
+      - If N = 1 (so C = A+B), then when both nodes travel A forward, they will
+  meet at the first node of the cycle.
+      - If N > 1, then C < A+B, so hare completes several cycles as tortise
+  moves A. However, after some number of cycles, tortise will be C away from the
+  meeting point, and hare will be at the meeting point. Hare moves forward C-B
+  to get to the first cycle point. Turtle will also move forward C-B along the
+  non-cycle points, arriving simultaneously at the first cycle point.
+
+
+*/
+
 shared_ptr<ListNode<int>> HasCycle(const shared_ptr<ListNode<int>>& head) {
-  // TODO - you fill in here.
-  return nullptr;
+  shared_ptr<ListNode<int>> slow = head, fast = head;
+  do {
+    if (!slow || !fast || !fast->next) {
+      // no cycle
+      return nullptr;
+    }
+
+    slow = slow->next;
+    fast = fast->next->next;
+  } while (fast != slow);
+
+  slow = head;
+  while (fast != slow) {
+    fast = fast->next;
+    slow = slow->next;
+  }
+  return fast;
 }
+
 void HasCycleWrapper(TimedExecutor& executor,
                      const shared_ptr<ListNode<int>>& head, int cycle_idx) {
   int cycle_length = 0;

elements-of-programming-interviews/cpp/reverse_sublist.cc

@@ -1,10 +1,32 @@
 #include "list_node.h"
 #include "test_framework/generic_test.h"
 
+/*
+0    1    2    3    4    5    6
+A -> B -> C -> D -> E -> F -> G
+
+ReverseSublist(2, 5)
+
+0    1    2    3    4    5    6
+A -> B -> F -> E -> D -> C -> G
+
+
+
+- Have two pointers, to 5 (end, final) and 2 (start).
+while (start != final)
+- Set 2->next to 5->next
+  - (start->next = end->next; end = start, start = start->next)
+- Then set 3->next to 2
+- Then set 4->next to 3
+- Then set 5->next to 4
+
+
+*/
+
 shared_ptr<ListNode<int>> ReverseSublist(shared_ptr<ListNode<int>> L, int start,
                                          int finish) {
   // TODO - you fill in here.
-  return nullptr;
+  return L;
 }
 
 int main(int argc, char* argv[]) {

elements-of-programming-interviews/cpp/sorted_lists_merge.cc

@@ -1,9 +1,31 @@
 #include "list_node.h"
 #include "test_framework/generic_test.h"
+
+// One / both could be empty
+// Negatives?
+
 shared_ptr<ListNode<int>> MergeTwoSortedLists(shared_ptr<ListNode<int>> L1,
                                               shared_ptr<ListNode<int>> L2) {
-  // TODO - you fill in here.
-  return nullptr;
+  shared_ptr<ListNode<int>> head = make_shared<ListNode<int>>();
+  shared_ptr<ListNode<int>> curr = head;
+  while (L1 && L2) {
+    if (L1->data <= L2->data) {
+      curr->next = L1;
+      L1 = L1->next;
+    } else {
+      curr->next = L2;
+      L2 = L2->next;
+    }
+    curr = curr->next;
+  }
+  if (L1) {
+    curr->next = L1;
+  }
+  if (L2) {
+    curr->next = L2;
+  }
+
+  return head->next;
 }
 
 int main(int argc, char* argv[]) {

elements-of-programming-interviews/problem_mapping.js

@@ -690,7 +690,7 @@ problem_mapping = {
         },
         "7.01 Merge two sorted lists": {
             "C++: sorted_lists_merge.cc": {
-                "passed": 0,
+                "passed": 501,
                 "total": 501
             },
             "Java: SortedListsMerge.java": {
@@ -704,7 +704,7 @@ problem_mapping = {
         },
         "7.02 Reverse a single sublist": {
             "C++: reverse_sublist.cc": {
-                "passed": 0,
+                "passed": 2,
                 "total": 210
             },
             "Java: ReverseSublist.java": {
@@ -718,7 +718,7 @@ problem_mapping = {
         },
         "7.03 Test for cyclicity": {
             "C++: is_list_cyclic.cc": {
-                "passed": 0,
+                "passed": 102,
                 "total": 102
             },
             "Java: IsListCyclic.java": {
@@ -760,7 +760,7 @@ problem_mapping = {
         },
         "7.06 Delete a node from a singly linked list": {
             "C++: delete_node_from_list.cc": {
-                "passed": 0,
+                "passed": 512,
                 "total": 512
             },
             "Java: DeleteNodeFromList.java": {