Python | Sort lists in tuple

Sometimes, while working with Python tuples, we can have a problem in which we need to sort the tuples which constitutes of lists and we need to sort each of them. Let's discuss certain ways in which this task can be performed. 

Method #1 : Using tuple() + sorted() + generator expression This task can be performed using the combination of above functions. In this, we iterate through each list using generator expression and perform the sort operation using sorted(). 

# Python3 code to demonstrate working of
# Sort lists in tuple
# Using tuple() + sorted() + generator expression

# Initializing tuple
test_tup = ([7, 5, 4], [8, 2, 4], [0, 7, 5])

# printing original tuple
print("The original tuple is : " + str(test_tup))

# Sort lists in tuple
# Using tuple() + sorted() + generator expression
res = tuple((sorted(sub) for sub in test_tup))

# printing result
print("The tuple after sorting lists : " + str(res))

The original tuple is : ([7, 5, 4], [8, 2, 4], [0, 7, 5])
The tuple after sorting lists : ([4, 5, 7], [2, 4, 8], [0, 5, 7])

  Method #2 : Using map() + sorted() This method performs the similar task as the above method, but it uses map() to extend the logic to each element of tuple, the task performed by list comprehension in above method. 

# Python3 code to demonstrate working of
# Sort lists in tuple
# Using map() + sorted()

# Initializing tuple
test_tup = ([7, 5, 4], [8, 2, 4], [0, 7, 5])

# printing original tuple
print("The original tuple is : " + str(test_tup))

# Sort lists in tuple
# Using map() + sorted()
res = tuple(map(sorted, test_tup))

# printing result
print("The tuple after sorting lists : " + str(res))

The original tuple is : ([7, 5, 4], [8, 2, 4], [0, 7, 5])
The tuple after sorting lists : ([4, 5, 7], [2, 4, 8], [0, 5, 7])

method#3: for+sorted

Approach

this approach is, sorts the lists in the given tuple using a for loop and the sorted() function. 

Algorithm

1. Create an empty tuple sorted_lists to store the sorted lists
2. Loop through each list in the original tuple using a for loop
3. Use the sorted() function to sort each list and store it in a new variable sorted_list
4. Add the sorted list to the sorted_lists tuple using the += operator
5. Print the sorted tuple

original_tuple = ([7, 5, 4], [8, 2, 4], [0, 7, 5])

sorted_lists = ()
for lst in original_tuple:
    sorted_list = sorted(lst)
    sorted_lists += (sorted_list,)

print(sorted_lists)

([4, 5, 7], [2, 4, 8], [0, 5, 7])

Time Complexity: The time complexity of the above program is O(NMlogM), where N is the number of lists in the tuple and M is the length of each list. This is because we loop through each list once and sorting each list takes O(M*logM) time.

Space Complexity: The space complexity of the above program is O(N*M), where N is the number of lists in the tuple and M is the length of each list. This is because we create a new tuple to store the sorted lists and each list has M elements.

Approach#4: Using lambda

In this approach, we are using map() function with an anonymous lambda function to apply the sorted() function to each list in the input tuple. The sorted() function sorts the elements of each list in ascending order, and the map() function applies this operation to all the lists in the input tuple. Finally, we convert the resulting iterable to a tuple.

Algorithm

1. Define the input tuple containing multiple lists.
2. Use the map() function with an anonymous lambda function to apply the sorted() function to each list in the input tuple.
3. Convert the resulting iterable to a tuple.
4. Print the resulting tuple.

tup = ([7, 5, 4], [8, 2, 4], [0, 7, 5])

result_tup = tuple(map(lambda lst: sorted(lst), tup))

print(result_tup)

([4, 5, 7], [2, 4, 8], [0, 5, 7])

Time Complexity: O(mn*log(n)). The time complexity of the sorted() function is O(nlog(n)), where n is the length of the input list. In this code, we are using the sorted() function inside a lambda function that is passed to the map() function. The map() function applies this operation to all the lists in the input tuple, so the time complexity of this operation becomes O(mnlog(n)), where m is the number of lists in the input tuple. 

Auxiliary Space: O(m*n), where m is the number of lists in the input tuple, and n is the length of each list. We are creating a new list for each input list, so the size of the resulting tuple is the same as the size of the input tuple. Therefore, the space complexity is linear with respect to the input size.