Python Program For Rearranging A Linked List Such That All Even And Odd Positioned Nodes Are Together

# Python3 program to rearrange a 
# linked list in such a way that 
# all odd positioned node are stored 
# before all even positioned nodes 

# Linked List Node 
class Node: 
    def __init__(self, d):
        self.data = d
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None
        
    # A utility function to create
    # a new node 
    def newNode(self, key): 
        temp = Node(key) 
        self.next = None
        return temp 

    # Rearranges given linked list 
    # such that all even positioned 
    # nodes are before odd positioned. 
    # Returns new head of linked List. 
    def rearrangeEvenOdd(self, head): 
        
        # Corner case 
        if (self.head == None): 
            return None

        # Initialize first nodes of 
        # even and odd lists 
        odd = self.head 
        even = self.head.next

        # Remember the first node of 
        # even list so that we can 
        # connect the even list at the 
        # end of odd list. 
        evenFirst = even 

        while (1 == 1): 
            
            # If there are no more nodes, 
            # then connect first node of even 
            # list to the last node of odd list 
            if (odd == None or even == None or 
               (even.next) == None): 
                odd.next = evenFirst 
                break

            # Connecting odd nodes 
            odd.next = even.next
            odd = even.next

            # If there are NO more even nodes 
            # after current odd. 
            if (odd.next == None): 
                even.next = None
                odd.next = evenFirst 
                break

            # Connecting even nodes 
            even.next = odd.next
            even = odd.next
        return head

    # A utility function to print a 
    # linked list 
    def printlist(self, node): 
        while (node != None): 
            print(node.data, end = "")
            print("->", end = "")
            node = node.next
        print ("NULL")
        
    # Function to insert a new node 
    # at the beginning 
    def push(self, new_data): 
        new_node = Node(new_data) 
        new_node.next = self.head 
        self.head = new_node

# Driver code 
ll = LinkedList()
ll.push(5)
ll.push(4)
ll.push(3)
ll.push(2)
ll.push(1)
print ("Given Linked List")
ll.printlist(ll.head) 

start = ll.rearrangeEvenOdd(ll.head) 

print ("Modified Linked List")
ll.printlist(start)
# This code is contributed by Prerna Saini

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

def rearrangeLinkedList(head: Node) -> Node:
    if not head or not head.next:
        return head
    
    odd_ptr = odd_head = Node(0)
    even_ptr = even_head = Node(0)
    
    is_odd = True
    while head:
        if is_odd:
            odd_ptr.next = head
            odd_ptr = odd_ptr.next
        else:
            even_ptr.next = head
            even_ptr = even_ptr.next
        is_odd = not is_odd
        head = head.next
    
    odd_ptr.next = even_head.next
    even_ptr.next = None
    
    return odd_head.next

# Creating the input linked list
head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(4)

# Rearranging the linked list
new_head = rearrangeLinkedList(head)

# Printing the rearranged linked list
while new_head:
    print(new_head.val, end="->")
    new_head = new_head.next

class Node:
    def __init__(self, data=None):
        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

    def printList(self):
        temp = self.head
        while(temp):
            print(temp.data, end=" ")
            temp = temp.next

    def rearrange(self):
        if self.head is None:
            return

        # create two separate linked lists for odd and even positioned nodes
        odd = Node(self.head.data)
        even = Node(self.head.next.data)
        odd_tail = odd
        even_tail = even

        curr_node = self.head.next.next
        is_odd = True
        while curr_node is not None:
            if is_odd:
                odd_tail.next = Node(curr_node.data)
                odd_tail = odd_tail.next
            else:
                even_tail.next = Node(curr_node.data)
                even_tail = even_tail.next

            curr_node = curr_node.next
            is_odd = not is_odd

        # combine the odd and even lists
        odd_tail.next = even
        self.head = odd

# Example 1
llist = LinkedList()
llist.push(4)
llist.push(3)
llist.push(2)
llist.push(1)
print("Original linked list: ")
llist.printList()
llist.rearrange()
print("\nRearranged linked list: ")
llist.printList()

# Example 2
llist = LinkedList()
llist.push(70)
llist.push(56)
llist.push(43)
llist.push(30)
llist.push(22)
llist.push(10)
print("\nOriginal linked list: ")
llist.printList()
llist.rearrange()
print("\nRearranged linked list: ")
llist.printList()