vault backup: 2022-07-13 09:15:30

OJ notes/pages/Leetcode Middle-of-the-Linked-List.md

@@ -0,0 +1,94 @@
+# Leetcode Middle-of-the-Linked-List
+
+#### 2022-07-13 09:08
+
+> ##### Algorithms:
+> #algorithm #two_pointers 
+> ##### Data structures:
+> #DS #linked_list 
+> ##### Difficulty:
+> #coding_problem #difficulty-easy
+> ##### Additional tags:
+> #leetcode 
+> ##### Revisions:
+> N/A
+
+##### Related topics:
+```expander
+tag:#two_pointers
+```
+ 
+ 
+
+##### Links:
+- [Link to problem](https://leetcode.com/problems/middle-of-the-linked-list/)
+___
+### Problem
+
+Given the head of a singly linked list, return the middle node of the linked list.
+
+If there are two middle nodes, return the second middle node.
+
+#### Examples
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/07/23/lc-midlist1.jpg)
+
+**Input:** head = [1,2,3,4,5]
+**Output:** [3,4,5]
+**Explanation:** The middle node of the list is node 3.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/07/23/lc-midlist2.jpg)
+
+**Input:** head = [1,2,3,4,5,6]
+**Output:** [4,5,6]
+**Explanation:** Since the list has two middle nodes with values 3 and 4, we return the second one.
+
+#### Constraints
+
+-   The number of nodes in the list is in the range `[1, 100]`.
+-   `1 <= Node.val <= 100`
+
+### Thoughts
+
+> [!summary]
+> This is a #two_pointers problem
+> To find the middle of linked list, use two pointers:
+> one fast pointer and one small pointer
+
+### Solution
+
+```cpp
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+  ListNode *middleNode(ListNode *head) {
+    // two pointers problem.
+    ListNode *fast, *slow;
+    fast = slow = head;
+
+    while (true) {
+      if (fast->next && fast->next->next) {
+        slow = slow->next;
+        fast = fast->next->next;
+      } else if (!fast->next) {
+        return slow;
+      } else if (!fast->next->next) {
+        return slow->next;
+      }
+    }
+  }
+};
+```