Open In App

# Python program to Sort a List of Tuples in Increasing Order by the Last Element in Each Tuple

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

 `# Python program to sort``# a list of tuples by the second Item``  ` `# Function to sort the list``# of tuples by its second item``def` `Sort_Tuple(tup): ``      ` `    ``# getting length of list of tuples``    ``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 ``  ` `# Driver Code ``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

 `# Python program to sort a list of``# tuples by the second Item using sort() ``  ` `# Function to sort the list by second item of tuple``def` `Sort_Tuple(tup): ``  ` `    ``# reverse = None (Sorts in Ascending order) ``    ``# key is set to sort using second element of ``    ``# sublist lambda has been used ``    ``tup.sort(key ``=` `lambda` `x: x[``-``1``]) ``    ``return` `tup ``  ` `# Driver Code ``tup ``=` `[(``1``, ``3``), (``3``, ``2``), (``2``, ``1``)]``  ` `# printing the sorted list of tuples``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.

1. Define a function called Sort_Tuple(tup) that takes a list of tuples as input.
2. Define a variable called n and set it equal to the length of the input list.
3. Use a for loop to iterate from the second element to the end of the list.
4. For each element in the loop, store the tuple in a temporary variable called key.
5. Define a variable called j and set it equal to the index of the element before the current element.
6. 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.
7. 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.
8. 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.
9. Insert the temporary variable into the correct position in the list.
10. 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` `# Driver Code``tup ``=` `[(``1``, ``3``), (``3``, ``2``), (``2``, ``1``)]``  ` `# printing the sorted list of tuples``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

1. Define a function called merge_sort which will take a list as an input.
2. Check the length of the list. If the length is less than or equal to 1, return the list.
3. Define a variable mid which will be equal to the length of the list divided by 2.
4. Define two variables left and right which will be equal to the left and right halves of the list respectively.
5. Recursively call merge_sort on left and right until the length of the list is less than or equal to 1.
6. Define a function called merge which will take two lists as inputs.
7. Define an empty list called result.
8. Define two variables i and j which will be equal to 0.
9. Use a while loop to iterate through both lists until either i or j is equal to the length of the list.
10. 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.
11. Use a while loop to append the remaining elements of left to the result list.
12. Use a while loop to append the remaining elements of right to the result list.
13. Return the result list.
14. Modify the Sort_Tuple function to call merge_sort instead of insertion sort.
15. 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)` `# Driver Code``tup ``=` `[(``1``, ``3``), (``3``, ``2``), (``2``, ``1``)]``  ` `# printing the sorted list of tuples``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

1. Initialize the starting index of the unsorted sublist as 0.
2. Repeat the following until the entire list is sorted:
3. Return the sorted list of tuples.

## Python3

 `# Python program to sort a list of tuples``# by the second Item using Selection Sort` `# Function to sort the list by second``# item of tuple``def` `Sort_Tuple(tup):``    ``n ``=` `len``(tup)``    ``for` `i ``in` `range``(n``-``1``):``        ``min_index ``=` `i``        ` `        ``# Find the minimum index``        ``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 the tuple``    ``return` `tup` `# Driver Code``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.