# 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;
      }
    }
  }
};
```