Python Program To Merge Two Sorted Lists (In-Place)
Last Updated :
11 Jan, 2022
Given two sorted lists, merge them so as to produce a combined sorted list (without using extra space).
Examples:
Input: head1: 5->7->9
head2: 4->6->8
Output: 4->5->6->7->8->9
Explanation: The output list is in sorted order.
Input: head1: 1->3->5->7
head2: 2->4
Output: 1->2->3->4->5->7
Explanation: The output list is in sorted order.
There are different discussed different solutions in post below.
Merge two sorted linked lists
Method 1 (Recursive):
Approach: The recursive solution can be formed, given the linked lists are sorted.
- Compare the head of both linked lists.
- Find the smaller node among the two head nodes. The current element will be the smaller node among two head nodes.
- The rest elements of both lists will appear after that.
- Now run a recursive function with parameters, the next node of the smaller element, and the other head.
- The recursive function will return the next smaller element linked with rest of the sorted element. Now point the next of current element to that, i.e curr_ele->next=recursivefunction()
- Handle some corner cases.
- If both the heads are NULL return null.
- If one head is null return the other.
Python3
# Python3 program to merge two
# sorted linked lists in-place.
import math
class Node:
def __init__(self, data):
self.data = data
self.next = None
# Function to create newNode in
# a linkedlist
def newNode(key):
temp = Node(key)
temp.data = key
temp.next = None
return temp
# A utility function to print
# linked list
def printList(node):
while (node != None):
print(node.data,
end = " ")
node = node.next
# Merges two given lists in-place.
# This function mainly compares
# head nodes and calls mergeUtil()
def merge(h1, h2):
if (h1 == None):
return h2
if (h2 == None):
return h1
# start with the linked list
# whose head data is the least
if (h1.data < h2.data):
h1.next = merge(h1.next, h2)
return h1
else:
h2.next = merge(h1, h2.next)
return h2
# Driver Code
if __name__=='__main__':
head1 = newNode(1)
head1.next = newNode(3)
head1.next.next = newNode(5)
# 1.3.5 LinkedList created
head2 = newNode(0)
head2.next = newNode(2)
head2.next.next = newNode(4)
# 0.2.4 LinkedList created
mergedhead = merge(head1, head2)
printList(mergedhead)
# This code is contributed by Srathore
Output:
0 1 2 3 4 5
Complexity Analysis:
- Time complexity:O(n).
Only one traversal of the linked lists are needed. - Auxiliary Space:O(n).
If the recursive stack space is taken into consideration.
Method 2 (Iterative):
Approach: This approach is very similar to the above recursive approach.
- Traverse the list from start to end.
- If the head node of second list lies in between two nodes of the first list, insert it there and make the next node of second list the head. Continue this until there is no node left in both lists, i.e. both the lists are traversed.
- If the first list has reached end while traversing, point the next node to the head of second list.
Note: Compare both the lists where the list with a smaller head value is the first list.
Python
# Python program to merge two
# sorted linked lists in-place.
# Linked List node
class Node:
def __init__(self, data):
self.data = data
self.next = None
# Function to create newNode in
# a linkedlist
def newNode(key):
temp = Node(0)
temp.data = key
temp.next = None
return temp
# A utility function to print
# linked list
def printList(node):
while (node != None) :
print( node.data, end =" ")
node = node.next
# Merges two lists with headers as h1 and h2.
# It assumes that h1's data is smaller than
# or equal to h2's data.
def mergeUtil(h1, h2):
# if only one node in first list
# simply point its head to second
# list
if (h1.next == None) :
h1.next = h2
return h1
# Initialize current and next
# pointers of both lists
curr1 = h1
next1 = h1.next
curr2 = h2
next2 = h2.next
while (next1 != None and
curr2 != None):
# if curr2 lies in between curr1
# and next1 then do curr1.curr2.next1
if ((curr2.data) >= (curr1.data) and
(curr2.data) <= (next1.data)):
next2 = curr2.next
curr1.next = curr2
curr2.next = next1
# now let curr1 and curr2 to point
# to their immediate next pointers
curr1 = curr2
curr2 = next2
else:
# if more nodes in first list
if (next1.next) :
next1 = next1.next
curr1 = curr1.next
# else point the last node of first list
# to the remaining nodes of second list
else:
next1.next = curr2
return h1
return h1
# Merges two given lists in-place.
# This function mainly compares head
# nodes and calls mergeUtil()
def merge(h1, h2):
if (h1 == None):
return h2
if (h2 == None):
return h1
# Start with the linked list
# whose head data is the least
if (h1.data < h2.data):
return mergeUtil(h1, h2)
else:
return mergeUtil(h2, h1)
# Driver code
head1 = newNode(1)
head1.next = newNode(3)
head1.next.next = newNode(5)
# 1.3.5 LinkedList created
head2 = newNode(0)
head2.next = newNode(2)
head2.next.next = newNode(4)
# 0.2.4 LinkedList created
mergedhead = merge(head1, head2)
printList(mergedhead)
# This code is contributed by Arnab Kundu
Output:
0 1 2 3 4 5
Complexity Analysis:
- Time complexity:O(n).
As only one traversal of the linked lists is needed. - Auxiliary Space:O(1).
As there is no space required.
Please refer complete article on
Merge two sorted lists (in-place) for more details!
Similar Reads
Python Program To Merge K Sorted Linked Lists - Set 1 Given K sorted linked lists of size N each, merge them and print the sorted output. Examples: Input: k = 3, n = 4 list1 = 1->3->5->7->NULL list2 = 2->4->6->8->NULL list3 = 0->9->10->11->NULL Output: 0->1->2->3->4->5->6->7->8->9->10-
6 min read
Python Program For Merge Sort Of Linked Lists Merge sort is often preferred for sorting a linked list. The slow random-access performance of a linked list makes some other algorithms (such as quicksort) perform poorly, and others (such as heapsort) completely impossible. Let the head be the first node of the linked list to be sorted and headRe
6 min read
Python program to insert an element into sorted list Inserting an element into a sorted list while maintaining the order is a common task in Python. It can be efficiently performed using built-in methods or custom logic. In this article, we will explore different approaches to achieve this.Using bisect.insort bisect module provides the insort function
2 min read
Python3 Program for Merge 3 Sorted Arrays Given 3 arrays (A, B, C) which are sorted in ascending order, we are required to merge them together in ascending order and output the array D. Examples: Input : A = [1, 2, 3, 4, 5] B = [2, 3, 4] C = [4, 5, 6, 7]Output : D = [1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 6, 7]Input : A = [1, 2, 3, 5] B = [6, 7, 8,
8 min read
Merge Two Lists into List of Tuples - Python The task of merging two lists into a list of tuples involves combining corresponding elements from both lists into paired tuples. For example, given two lists like a = [1, 2, 3] and b = ['a', 'b', 'c'], the goal is to merge them into a list of tuples, resulting in [(1, 'a'), (2, 'b'), (3, 'c')]. Usi
3 min read