Python Program For Rearranging A Linked List In Zig-Zag Fashion
Last Updated :
22 Aug, 2024
Given a linked list, rearrange it such that the converted list should be of the form a < b > c < d > e < f … where a, b, c… are consecutive data nodes of the linked list.
Examples:
Input: 1->2->3->4
Output: 1->3->2->4
Explanation: 1 and 3 should come first before 2 and 4 in
zig-zag fashion, So resultant linked-list
will be 1->3->2->4.
Input: 11->15->20->5->10
Output: 11->20->5->15->10
A simple approach to do this is to sort the linked list using merge sort and then swap alternate, but that requires O(n Log n) time complexity. Here n is a number of elements in the linked list.
An efficient approach that requires O(n) time is, using a single scan similar to bubble sort and then maintain a flag for representing which order () currently we are. If the current two elements are not in that order then swap those elements otherwise not. Please refer to this for a detailed explanation of the swapping order.
follow” href=”https://www.geeksforgeeks.org/converting-an-array-of-integers-into-zig-zag-fashion/”>this for a detailed explanation of the swapping order.
Python
class Node:
def __init__(self, data):
self.data = data
self.next = None
def zigZagList(head):
flag = True
current = head
while (current.next != None):
if (flag):
if (current.data >
current.next.data):
t = current.data
current.data = current.next.data
current.next.data = t
else :
if (current.data <
current.next.data):
t = current.data
current.data = current.next.data
current.next.data = t
current = current.next
if(flag):
flag = False
else:
flag = True
return head
def push(head, k):
tem = Node(0)
tem.data = k
tem.next = head
head = tem
return head
def display(head):
curr = head
while (curr != None):
print(curr.data,
"->", end =" ")
curr = curr.next
print("None")
head = None
head = push(head, 1)
head = push(head, 2)
head = push(head, 6)
head = push(head, 8)
head = push(head, 7)
head = push(head, 3)
head = push(head, 4)
print("Given linked list ")
display(head)
head = zigZagList(head)
print("Zig Zag Linked list ")
display(head)
|
Output:
Given linked list
4->3->7->8->6->2->1->NULL
Zig Zag Linked list
3->7->4->8->2->6->1->NULL
Time Complexity: O(N), as we are using a loop for traversing the linked list.
Auxiliary Space: O(1), as we are not using extra space.
Another Approach:
In the above code, the push function pushes the node at the front of the linked list, the code can be easily modified for pushing the node at the end of the list. Another thing to note is, swapping of data between two nodes is done by swap by value not swap by links for simplicity, for the swap by links technique please see this.
This can be also be done recursively. The idea remains the same, let us suppose the value of the flag determines the condition we need to check for comparing the current element. So, if the flag is 0 (or false) the current element should be smaller than the next and if the flag is 1 ( or true ) then the current element should be greater than the next. If not, swap the values of nodes.
Python3
class Node:
def __init__(self, data):
self.data = data
self.next = None
head = None
def printLL():
t = head
while (t != None):
print(t.data, end = " ->")
t = t.next
print()
def swap(a,b):
if(a == None or
b == None):
return
temp = a.data
a.data = b.data
b.data = temp
def zigZag(node, flag):
if(node == None or
node.next == None):
return node
if (flag == 0):
if (node.data >
node.next.data):
swap(node, node.next)
return zigZag(node.next, 1)
else:
if (node.data <
node.next.data):
swap(node, node.next)
return zigZag(node.next, 0)
head = Node(11)
head.next = Node(15)
head.next.next = Node(20)
head.next.next.next = Node(5)
head.next.next.next.next = Node(10)
printLL();
flag = 0
zigZag(head, flag)
print("LL in zig zag fashion : ")
printLL()
|
Output:
11 ->15 ->20 ->5 ->10 ->
LL in zig zag fashion :
11 ->20 ->5 ->15 ->10 ->
Complexity Analysis:
- Time Complexity: O(n).
Traversal of the list is done only once, and it has ‘n’ elements.
- Auxiliary Space: O(n).
O(n) extra space dure to recursive stack.
Please refer complete article on Rearrange a Linked List in Zig-Zag fashion for more details!
Similar Reads
Python Program For Rearranging A Given Linked List In-Place
Given a singly linked list L0 -> L1 -> … -> Ln-1 -> Ln. Rearrange the nodes in the list so that the new formed list is: L0 -> Ln -> L1 -> Ln-1 -> L2 -> Ln-2 ...You are required to do this in place without altering the nodes' values. Examples: Input: 1 -> 2 -> 3 ->
7 min read
Python Program For Reversing A Doubly Linked List
Given a Doubly Linked List, the task is to reverse the given Doubly Linked List. See below diagrams for example. (a) Original Doubly Linked List (b) Reversed Doubly Linked List Here is a simple method for reversing a Doubly Linked List. All we need to do is swap prev and next pointers for all nodes
4 min read
Python Program For Rotating A Linked List
Given a singly linked list, rotate the linked list counter-clockwise by k nodes. Where k is a given positive integer. For example, if the given linked list is 10->20->30->40->50->60 and k is 4, the list should be modified to 50->60->10->20->30->40. Assume that k is smaller than the count of nodes in
5 min read
Python Program For Reversing Alternate K Nodes In A Singly Linked List
Given a linked list, write a function to reverse every alternate k nodes (where k is an input to the function) in an efficient way. Give the complexity of your algorithm. Example: Inputs: 1->2->3->4->5->6->7->8->9->NULL and k = 3 Output: 3->2->1->4->5->6-
6 min read
Python Program For Swapping Nodes In A Linked List Without Swapping Data
Given a linked list and two keys in it, swap nodes for two given keys. Nodes should be swapped by changing links. Swapping data of nodes may be expensive in many situations when data contains many fields. It may be assumed that all keys in the linked list are distinct. Examples: Input : 10->15-
5 min read
Python Program For Reversing A Linked List In Groups Of Given Size- Set 2
Given a linked list, write a function to reverse every k nodes (where k is an input to the function). Examples: Input: 1->2->3->4->5->6->7->8->NULL and k = 3 Output: 3->2->1->6->5->4->8->7->NULL. Input: 1->2->3->4->5->6->7->8->NULL and k = 5 Output: 5->4->3->2->1->8->7->6->NULL. Recommended: Please
3 min read
Python Program For Flattening A Linked List
Given a linked list where every node represents a linked list and contains two pointers of its type: Pointer to next node in the main list (we call it 'right' pointer in the code below).Pointer to a linked list where this node is headed (we call it the 'down' pointer in the code below). All linked l
4 min read
Python Program For Reversing A Linked List In Groups Of Given Size - Set 1
Given a linked list, write a function to reverse every k nodes (where k is an input to the function). Example: Input: 1->2->3->4->5->6->7->8->NULL, K = 3 Output: 3->2->1->6->5->4->8->7->NULL Input: 1->2->3->4->5->6->7->8->NULL, K = 5 Output: 5->4->3->2->1->8->7->6->NULL Recommended: Please solve
3 min read
Python Program For Insertion Sort In A Singly Linked List
We have discussed Insertion Sort for arrays. In this article we are going to discuss Insertion Sort for linked list. Below is a simple insertion sort algorithm for a linked list. 1) Create an empty sorted (or result) list. 2) Traverse the given list, do following for every node. ......a) Insert curr
5 min read
Python Program For Alternating Split Of A Given Singly Linked List- Set 1
Write a function AlternatingSplit() that takes one list and divides up its nodes to make two smaller lists 'a' and 'b'. The sublists should be made from alternating elements in the original list. So if the original list is 0->1->0->1->0->1 then one sublist should be 0->0->0 and
3 min read