Working with sorted list is essential because mostly the data we get is ordered. Any query can come to insert the new data into its appropriate position. Hence requires to know how to perform these dynamic queries. Lets discuss certain ways in which this can be performed.
Method #1 : Naive Method In this method, we just simply test for the value and check if next element is greater than the input element and store the index which is then used to slice in that element at that position.
Python3
# Python3 code to demonstrate # insertion in sorted list # using naive method # initializing list test_list = [1, 2, 3, 6, 7] # printing original list print ("The original list is : " + str(test_list)) # insert element k = 5# using naive method # insertion in sorted list # using naive method for i in range(len(test_list)): if test_list[i] > k: index = i breakres = test_list[: i] + [k] + test_list[i :] # printing result print ("The list after insertion is : " + str(res)) |
The original list is : [1, 2, 3, 6, 7] The list after insertion is : [1, 2, 3, 5, 6, 7]
Time complexity: O(n) where n is size of list
Auxiliary Space: O(n)
Method #2 : Using bisect.insort() This is more concise and recommended method to perform this particular task. This method is designed for this particular task and performs this task in most efficient manner.
Python3
# Python3 code to demonstrate # insertion in sorted list # using bisect.insort() import bisect # initializing list test_list = [1, 2, 3, 6, 7] # printing original list print ("The original list is : " + str(test_list)) # insert element k = 5# using bisect.insort() # insertion in sorted list # using naive method bisect.insort(test_list, k) # printing result print ("The list after insertion is : " + str(test_list)) |
The original list is : [1, 2, 3, 6, 7] The list after insertion is : [1, 2, 3, 5, 6, 7]
Time complexity: O(n) where n is size of given list
Auxiliary space: O(1)
Method #3 : Using heapq
To insert an element into a sorted list using a min heap , you can use the following code:
Python3
import heapqtest_list = [1, 2, 3, 6, 7]k = 5heap = test_list + [k]heapq.heapify(heap)sorted_list = [heapq.heappop(heap) for _ in range(len(heap))]print(sorted_list)#This code is contributed by Edula Vinay Kumar Reddy |
[1, 2, 3, 5, 6, 7]
This code first creates a min heap from the elements of test_list and the element k using the heapq.heapify() function. Then, it extracts the elements from the heap one by one using a list comprehension and the heapq.heappop() function, and stores them in a new list sorted_list, which is then printed.
This approach has a time complexity of O(n log n), since the heapq.heapify() and heapq.heappop() functions have a time complexity of O(n) and O(log n), respectively. It also has a space complexity of O(n), since it requires an additional heap data structure to store the elements.
Method #4 : Using append() and sort() methods
Python3
# Python3 code to demonstrate# insertion in sorted list# initializing listtest_list = [1, 2, 3, 6, 7]# printing original listprint ("The original list is : " + str(test_list))# insert elementk = 5test_list.append(k)test_list.sort()# printing resultprint ("The list after insertion is : " + str(test_list)) |
The original list is : [1, 2, 3, 6, 7] The list after insertion is : [1, 2, 3, 5, 6, 7]
Time Complexity : O(N log N)
Auxiliary Space : O(1)
Method #5 : .insert()
Python3
from bisect import bisect_lefttest_list = [1, 2, 3, 6, 7] k = 5index = bisect_left(test_list, k)test_list.insert(index, k)print(test_list) |
[1, 2, 3, 5, 6, 7]
Time Complexity : O(N)
Auxiliary Space : O(1)
Method #6: Using list comprehension
Python3
test_list = [1, 2, 3, 6, 7]# printing original listprint ("The original list is : " + str(test_list))k = 5res = [x for x in test_list if x < k] + [k] + [x for x in test_list if x >= k]print(res)#This code is contributed by Vinay pinjala. |
The original list is : [1, 2, 3, 6, 7] [1, 2, 3, 5, 6, 7]
Time Complexity : O(N)
Auxiliary Space : O(N)
Method 7: Using a while loop and comparisons
This method involves using a while loop to find the index at which the new element should be inserted, and then using list slicing and concatenation to insert the element at the correct position.
step by step approach:
- Initialize the list and the new element to be inserted.
- Set a flag variable ‘inserted’ to False.
- Initialize a counter variable ‘i’ to 0.
- While the counter variable ‘i’ is less than the length of the list, do the following:
- a. If the new element is less than or equal to the current element in the list, insert the new element at that position using list slicing and concatenation, set the flag variable ‘inserted’ to True, and break out of the loop.
- b. Otherwise, increment the counter variable ‘i’.
- If the flag variable ‘inserted’ is still False, append the new element to the end of the list.
- Print the original list and the list after insertion.
Python3
# Python3 code to demonstrate# insertion in sorted list# initializing listtest_list = [1, 2, 3, 6, 7]# printing original listprint("The original list is : " + str(test_list))# insert elementk = 5# Method #5: Using a while loop and comparisons# initialize flag variable and counter variableinserted = Falsei = 0# loop through the list and find the index at which the new element should be insertedwhile i < len(test_list): if k <= test_list[i]: # insert the new element at the correct position using list slicing and concatenation test_list = test_list[:i] + [k] + test_list[i:] inserted = True break i += 1# if the new element was not inserted, append it to the end of the listif not inserted: test_list.append(k)# print the list after insertionprint("The list after insertion is : " + str(test_list)) |
The original list is : [1, 2, 3, 6, 7] The list after insertion is : [1, 2, 3, 5, 6, 7]
Time complexity: O(n), where n is the length of the list. In the worst case, the new element has to be inserted at the end of the list, so we have to compare it with every element in the list.
Auxiliary space: O(n), where n is the length of the list. In the worst case, the new element has to be inserted at the beginning of the list, so we have to create a new list of length n+1.
