- Trending Categories
Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Python Program To Get The Middle Element Of A Linked List In A Single Iteration
Linked list is used for storing the data in non-contiguous memory locations. The nodes containing the data items are linked using pointers. Each node consists of two fields. The first field is used for storing the data and the second field contains the link to the next node.
Brute Force Technique
To find the middle element of a linked list, the brute force technique is to find out the length of the linked list by iterating the entire linked list till NULL is encountered and then the length is divided by 2 to get the index of the middle element. After getting the index of the middle element, iterate the linked list again from the head and stop when the required index is reached. The data item at that index gives the middle element.
Take a variable called “temp” pointing to the HEAD and initialize “len” to 0
Iterate the linked list using temp until NULL is reached and increment “len” by 1 at every node.
After getting the length of the linked list, initialize the temp to HEAD again. Iterate the linked list until len//2.
Using Slow And Fast Pointers (Single Iteration)
We will use two pointers to traverse the linked list. One is called the “slow pointer” and the other is called the “fast pointer”.
Fast pointer will be moving with double the speed of the slow pointer.
When the fast pointer reaches the end of the linked list, The slow pointer will be at the middle node.
Hence, we can directly print the contents of the middle node.
Example
Consider the below linked list. The middle element is 3.
The fast pointer has reached the last node in the linked list and now the slow pointer is pointing to the node 3. Hence, 3 is the middle element of the given linked list. Now, consider 6 nodes.
Example
The fast pointer has reached NULL and the slow pointer is pointing towards the 4th node. Hence, the middle element is 4.
Algorithm
Make the “slow” and “fast” point to the HEAD of the linked list.
Increment fast pointer by two and the slow pointer by one until that fast pointer and fast.next are not equal to NULL
Print the value at the slow pointer.
The time complexity will be O(n).
class Node:
def __init__(self, val):
self.val = val
self.next = None
class LinkedList:
def __init__(self):
self.head = None
def insert_at_the_beginning(self, newVal):
newNode = Node(newVal)
newNode.next = self.head
self.head = newNode
def print_middle_element(self):
slow=self.head
fast=self.head
while fast is not None and fast.next is not None:
slow=slow.next #slow pointer moves one node
fast=fast.next.next #fast pointer moves two nodes
print("\n\nthe middle element is ",slow.val)
def Print_the_LL(self):
temp = self.head
if(temp != None):
print("The linked list elements are:", end=" ")
while (temp != None):
print(temp.val, end=" ")
temp = temp.next
else:
print("The list is empty.")
newList = LinkedList()
newList.insert_at_the_beginning(5)
newList.insert_at_the_beginning(4)
newList.insert_at_the_beginning(3)
newList.insert_at_the_beginning(2)
newList.insert_at_the_beginning(1)
newList.Print_the_LL()
newList.print_middle_element()
Output
The linked list elements are: 1 2 3 4 5 the middle element is 3
688 Views
