Python program to find middle of a linked list using one traversal

# Python program for the above approach
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None


class NodeOperation:
    # Function to add a new node
    def pushNode(self, head_ref, data_val):

        # Allocate node and put in the data
        new_node = Node(data_val)

        # Link the old list of the new node
        new_node.next = head_ref

        # move the head to point to the new node
        head_ref = new_node
        return head_ref

    # A utility function to print a given linked list
    def printNode(self, head):
        while (head != None):
            print('%d->' % head.data, end="")
            head = head.next
        print("NULL")

    ''' Utility Function to find length of linked list '''

    def getLen(self, head):
        temp = head
        len = 0

        while (temp != None):
            len += 1
            temp = temp.next

        return len

    def printMiddle(self, head):
        if head != None:
            # find length
            len = self.getLen(head)
            temp = head

            # traverse till we reached half of length
            midIdx = len // 2
            while midIdx != 0:
                temp = temp.next
                midIdx -= 1

            # temp will be storing middle element
            print('The middle element is: ', temp.data)


# Driver Code
head = None
temp = NodeOperation()
head = temp.pushNode(head, 5)
head = temp.pushNode(head, 4)
head = temp.pushNode(head, 3)
head = temp.pushNode(head, 2)
head = temp.pushNode(head, 1)
temp.printNode(head)
temp.printMiddle(head)

# This code is contributed by Yash Agarwal

# Python 3 program to find the middle of a  
# given linked list 

# Node class 
class Node: 

    # Function to initialise the node object 
    def __init__(self, data): 
        self.data = data 
        self.next = None 

class LinkedList:

    def __init__(self):
        self.head = None

    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node

    # Function to get the middle of 
    # the linked list
    def printMiddle(self):
        slow_ptr = self.head
        fast_ptr = self.head

        if self.head is not None:
            while (fast_ptr is not None and fast_ptr.next is not None):
                fast_ptr = fast_ptr.next.next
                slow_ptr = slow_ptr.next
            print("The middle element is: ", slow_ptr.data)

# Driver code
list1 = LinkedList()
list1.push(5)
list1.push(4)
list1.push(2)
list1.push(3)
list1.push(1)
list1.printMiddle()

# Python 3 program to find the middle of a
# given linked list

class Node:
    def __init__(self, value):
        self.data = value
        self.next = None
    
class LinkedList:

    def __init__(self):
        self.head = None

    # create Node and make linked list
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node
        
    def printMiddle(self):
        temp = self.head
        count = 0
        
        while self.head:

            # only update when count is odd
            if (count & 1):
                temp = temp.next
            self.head = self.head.next

            # increment count in each iteration
            count += 1
        
        print(temp.data)    
        
# Driver code
llist = LinkedList()
llist.push(1)
llist.push(20)
llist.push(100)
llist.push(15)
llist.push(35)
llist.printMiddle()
# code has been contributed by - Yogesh Joshi

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None
        
    def insert(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current_node = self.head
            while current_node.next is not None:
                current_node = current_node.next
            current_node.next = new_node
            
    def print_list(self):
        current_node = self.head
        while current_node is not None:
            print(current_node.data, end="->")
            current_node = current_node.next
        print("NULL")
    
    def find_middle(self):
        elements = []
        current_node = self.head
        while current_node is not None:
            elements.append(current_node.data)
            current_node = current_node.next
        middle_index = len(elements) // 2
        return elements[middle_index]
        
linked_list = LinkedList()
linked_list.insert(1)
linked_list.insert(2)
linked_list.insert(3)
linked_list.insert(4)
linked_list.insert(5)
linked_list.print_list()

middle = linked_list.find_middle()
print("The middle element is:", middle)