The original problem of “876. Middle of the Linked List” was published on LeetCode.com

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.

**Example 1:**

Input:head = [1,2,3,4,5]Output:[3,4,5]Explanation:The middle node of the list is node 3.

**Example 2:**

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`

## Understanding the challenge

This question is asking for the middle node of a singly linked list. The singly linked list is provided as the “head” of the list, which is the first node. The output is expected to be the middle node in the list; if the list has two middle nodes, the second one should be returned. The constraint is that the number of nodes in the list is 1 to 100, and each node value is between 1 and 100.

## How to solve this problem?

To solve this problem, you will need to understand the concept of singly linked lists, which is a data structure typically used to represent a sequence of items. You will need to know how a linked list is structured and how to traverse a linked list. Additionally, you will need to understand how to find the middle node of a linked list, which can be achieved by finding the number of nodes and traversing the list until the middle node is reached. You should also understand how to handle the case where there are two middle nodes (i.e. returning the second one).

## What is a singly linked list?

A singly linked list is a collection of data elements (nodes) which are connected sequentially, with each element (or node) containing a “link” to the next element. Unlike arrays, linked lists allow for the efficient insertion or removal of elements from any position in the list. They can represent many data structures, such as stacks, queues, and graphs.

## How is a linked list structured?

A linked list is a linear data structure consisting of nodes. Every node consists of two parts: a data element, and a link (or reference) to the next node in the list. The head of the list is the first node and is followed by any number of nodes (which can be zero or more). The last node in the list usually contains a link to null, which signals the end of the list.

## How to traverse a linked list?

Traversing through a linked list can be done by starting from the head node and iterating through each node one at a time until the last node is reached. This can be done by taking the link stored in each node and following the link to the next node.

## How to find the middle node of a linked list?

Finding the middle node of a linked list can be achieved by counting the number of nodes in the list. Once this is done, the middle node can be found by traversing the list until the middle node is reached. If the list has an even number of nodes, the second middle node should be returned.

## Let’s develop the solution

```
# Function to find the middle node of a linked list
def find_middle_node(head):
# Start at the head of the list
current = head
# Initialize a counter to keep track of number of nodes
count = 0
# Iterate through each node in the list
while current:
count += 1
current = current.next
# Find the middle node by dividing the total number of nodes by 2
middle_node = head
for i in range(count // 2):
middle_node = middle_node.next
# Return the middle node
return middle_node
```

This code finds the middle node of a singly linked list. It starts by setting a variable, called ‘current’, to be the head node of the linked list. It then initializes a ‘count’ variable to 0, which keeps track of the number of nodes in the linked list. Next, it iterates through each node in the linked list and increments the count variable, until the last node is reached. Then, it finds the middle node by taking the head node of the list and traversing ‘count // 2’ times until the middle node is reached. Finally, it returns the middle node.

## What is the time complexity of this code?

The time complexity for this code is O(n), which is linear time. This is because the code iterates through each node in the linked list once, so the time it takes to complete will increase linearly in relation to the number of nodes in the list.

## What is the space complexity of this code?

The space complexity for this code is O(1), which is constant time. This is because the code only requires a constant amount of space, regardless of the number of nodes in the list, as it only requires two variables (current and count) to keep track of the head of the list and the number of nodes.