The task is to write a Python Program to sort a list of tuples in increasing order by the last element in each tuple.
Input: [(1, 3), (3, 2), (2, 1)]
Output: [(2, 1), (3, 2), (1, 3)]
Explanation: sort tuple based on the last digit of each tuple.
Methods #1: Using sorted().
Sorted() method sorts a list and always returns a list with the elements in a sorted manner, without modifying the original sequence.
Approach:
- Take a list of tuples from the user.
- Define a function that returns the last element of each tuple in the list of tuples.
- Define another function with the previous function as the key and sort the list.
- Print the sorted list.
Python3
def last(n):
return n[ - 1 ]
def sort(tuples):
return sorted (tuples, key = last)
a = [( 1 , 3 ), ( 3 , 2 ), ( 2 , 1 )]
print ( "Sorted:" )
print (sort(a))
|
Output:
Sorted:
[(2, 1), (3, 2), (1, 3)]
Time Complexity: O(nlogn)
Auxiliary Space: O(1)
Methods #2: Using Bubble Sort.
Access the last element of each tuple using the nested loops. This performs the in-place method of sorting. The time complexity is similar to the Bubble Sort i.e. O(n^2).
Python3
def Sort_Tuple(tup):
lst = len (tup)
for i in range ( 0 , lst):
for j in range ( 0 , lst - i - 1 ):
if (tup[j][ - 1 ] > tup[j + 1 ][ - 1 ]):
temp = tup[j]
tup[j] = tup[j + 1 ]
tup[j + 1 ] = temp
return tup
tup = [( 1 , 3 ), ( 3 , 2 ), ( 2 , 1 )]
print (Sort_Tuple(tup))
|
Output:
[(2, 1), (3, 2), (1, 3)]
Time complexity: O(n^2) – The program uses a nested loop to compare each element with the rest of the elements in the list.
Auxiliary space: O(1) – The program uses a constant amount of extra space to swap elements in the list.
Methods #3: Using sort().
The sort() method sorts the elements of a given list in a specific ascending or descending order.
Python3
def Sort_Tuple(tup):
tup.sort(key = lambda x: x[ - 1 ])
return tup
tup = [( 1 , 3 ), ( 3 , 2 ), ( 2 , 1 )]
print (Sort_Tuple(tup))
|
Output:
[(2, 1), (3, 2), (1, 3)]
Time complexity: O(n log n), where n is the number of tuples in the list.
Auxiliary space: O(1). This is because the sorting is done in place, without creating any additional data structures.
Method #4: Using Insertion Sort.
- Define a function called Sort_Tuple(tup) that takes a list of tuples as input.
- Define a variable called n and set it equal to the length of the input list.
- Use a for loop to iterate from the second element to the end of the list.
- For each element in the loop, store the tuple in a temporary variable called key.
- Define a variable called j and set it equal to the index of the element before the current element.
- Use a while loop to compare the second element of the tuple in the temporary variable with the second element of the tuple at index j.
- If the second element of the tuple at index j is greater than the second element of the tuple in the temporary variable, then swap the two tuples.
- Decrement j by 1 and continue the while loop until j is less than 0 or the second element of the tuple at index j is less than or equal to the second element of the tuple in the temporary variable.
- Insert the temporary variable into the correct position in the list.
- Return the sorted list of tuples.
Python3
def Sort_Tuple(tup):
n = len (tup)
for i in range ( 1 , n):
key = tup[i]
j = i - 1
while j > = 0 and key[ 1 ] < tup[j][ 1 ]:
tup[j + 1 ] = tup[j]
j - = 1
tup[j + 1 ] = key
return tup
tup = [( 1 , 3 ), ( 3 , 2 ), ( 2 , 1 )]
print (Sort_Tuple(tup))
|
Output[(2, 1), (3, 2), (1, 3)]
Time complexity: O(n^2) in the worst case scenario.
Auxiliary space: O(1) as the space used is only for temporary variables.
Method #5: Using Merge Sort
- Define a function called merge_sort which will take a list as an input.
- Check the length of the list. If the length is less than or equal to 1, return the list.
- Define a variable mid which will be equal to the length of the list divided by 2.
- Define two variables left and right which will be equal to the left and right halves of the list respectively.
- Recursively call merge_sort on left and right until the length of the list is less than or equal to 1.
- Define a function called merge which will take two lists as inputs.
- Define an empty list called result.
- Define two variables i and j which will be equal to 0.
- Use a while loop to iterate through both lists until either i or j is equal to the length of the list.
- Compare the elements at i index of left and j index of right. If the element at i index of left is smaller, append it to the result list and increment i by 1. If the element at j index of right is smaller, append it to the result list and increment j by 1.
- Use a while loop to append the remaining elements of left to the result list.
- Use a while loop to append the remaining elements of right to the result list.
- Return the result list.
- Modify the Sort_Tuple function to call merge_sort instead of insertion sort.
- Return the sorted tuple.
Python3
def merge_sort(lst):
if len (lst) < = 1 :
return lst
mid = len (lst) / / 2
left = lst[:mid]
right = lst[mid:]
left = merge_sort(left)
right = merge_sort(right)
return merge(left, right)
def merge(left, right):
result = []
i, j = 0 , 0
while i < len (left) and j < len (right):
if left[i][ 1 ] < = right[j][ 1 ]:
result.append(left[i])
i + = 1
else :
result.append(right[j])
j + = 1
while i < len (left):
result.append(left[i])
i + = 1
while j < len (right):
result.append(right[j])
j + = 1
return result
def Sort_Tuple(tup):
return merge_sort(tup)
tup = [( 1 , 3 ), ( 3 , 2 ), ( 2 , 1 )]
print (Sort_Tuple(tup))
|
Output[(2, 1), (3, 2), (1, 3)]
Time Complexity: O(n log n)
Auxiliary Space: O(n)
Method #6: Using Selection Sort
- Initialize the starting index of the unsorted sublist as 0.
- Repeat the following until the entire list is sorted:
- Return the sorted list of tuples.
Python3
def Sort_Tuple(tup):
n = len (tup)
for i in range (n - 1 ):
min_index = i
for j in range (i + 1 , n):
if tup[j][ 1 ] < tup[min_index][ 1 ]:
min_index = j
tup[i], tup[min_index] = tup[min_index], tup[i]
return tup
tup = [( 1 , 3 ), ( 3 , 2 ), ( 2 , 1 )]
print (Sort_Tuple(tup))
|
Output[(2, 1), (3, 2), (1, 3)]
Time Complexity: O(N2)
Auxiliary Space: O(1)
Note: In the original code provided, Method #3 is redundant as tup.sort() already sorts the list in place.