# 5 Best Ways to Find the Shortest Sublist to Sort for a Fully Sorted List in Python

Rate this post

π‘ Problem Formulation: The task is to determine the minimum length contiguous sublist of a given list of numbers which, when sorted, results in the entire list being sorted. For example, given the input list `[3, 7, 5, 6, 9]`, the desired output would be to identify the sublist `[7, 5, 6]`, because sorting just this sublist would result in the entire list being sorted.

## Method 1: Using Two Pointers

The Two Pointers method involves iterating over the list from both ends to identify the boundaries of the unsorted sublist. Once the boundaries are identified, the sublist can then be sorted to ensure the entire list is sorted. This method is efficient and straightforward to implement in Python.

Here’s an example:

```def find_sublist_to_sort(lst):
left, right = 0, len(lst) - 1
# Find the left boundary of the unsorted sublist
while left < right and lst[left]  left and lst[right] >= lst[right - 1]:
right -= 1
return (left, right)

# Example usage
lst = [3, 7, 5, 6, 9]
result = find_sublist_to_sort(lst)
sublist = lst[result[0]: result[1]+1]
print("Sublist to sort:", sublist)```

Output:

`Sublist to sort: [7, 5, 6]`

This code snippet defines a function `find_sublist_to_sort()` that takes a list as input and returns a tuple with the starting and ending indices of the shortest sublist that needs to be sorted. The example uses this function to find and print the unsorted sublist in the given list.

## Method 2: Using Sorting and Comparison

This method sorts a copy of the original list and compares it with the original to find the first and last elements that differ. The indices of these elements define the boundaries of the shortest sublist that needs to be sorted. This method is simple but involves sorting the entire list, which may not be the most efficient approach.

Here’s an example:

```def min_sublist(lst):
sorted_lst = sorted(lst)
start = next((i for i in range(len(lst)) if lst[i] != sorted_lst[i]), None)
end = next((i for i in range(len(lst)-1, -1, -1) if lst[i] != sorted_lst[i]), None)
return lst[start:end+1] if start is not None else []

# Example usage
lst = [3, 7, 5, 6, 9]
print("Sublist to sort:", min_sublist(lst))```

Output:

`Sublist to sort: [7, 5, 6]`

In the `min_sublist()` function, a sorted copy of the list is created and compared with the original list to find the boundaries of the sublist that differ. The function then returns the sublist that, when sorted, will result in a fully sorted original list.

## Method 3: Extending Method 1 Using the Stack Data Structure

A stack can be used to enhance the two-pointers approach by pushing and popping indices based on the order of the elements, which allows tracking of the minimum and maximum indices that need to be sorted. This method improves the readability of the code and maintains an efficient time complexity.

Here’s an example:

```def find_sublist_using_stack(lst):
stack = []
l, r = 0, 0
# Find the left boundary using a stack
for i in range(len(lst)):
while stack and lst[stack[-1]] > lst[i]:
l = min(l, stack.pop())
stack.append(i)
# Reset and find the right boundary using a stack
stack = []
for i in range(len(lst)-1, -1, -1):
while stack and lst[stack[-1]] < lst[i]:
r = max(r, stack.pop())
stack.append(i)
return lst[l:r+1]

# Example usage
lst = [3, 7, 5, 6, 9]
print("Sublist to sort:", find_sublist_using_stack(lst))```

Output:

`Sublist to sort: [7, 5, 6]`

The `find_sublist_using_stack()` function uses a stack to keep track of the indices where the order of the elements is not followed. It finds the left and right boundaries of the sublist and returns the unsorted sublist.

## Method 4: Enhanced Simple Comparison

Enhanced simple comparison can be applied by iterating once through the list and tracking the local minima and maxima that are out of place. These markers are then used to determine the extent of the unsorted sublist without the need for a complete sort. This method can offer performance improvements while still being intuitive.

Here’s an example:

```def find_sublist_simple_comparison(lst):
min_out_of_order = max(lst)
max_out_of_order = min(lst)
for i in range(1, len(lst)):
if lst[i]  min_out_of_order)
sub_end = next(i for i, x in enumerate(reversed(lst)) if x < max_out_of_order)
return lst[sub_start:len(lst)-sub_end]

# Example usage
lst = [3, 7, 5, 6, 9]
print("Sublist to sort:", find_sublist_simple_comparison(lst))```

Output:

`Sublist to sort: [7, 5, 6]`

The function `find_sublist_simple_comparison()` iteratively finds the minimum and maximum values that are out of the desired order. It then identifies the extent of the sublist that, when sorted, would result in the entire list being sorted.

## Bonus One-Liner Method 5: Using Python’s List Comprehensions

Python’s list comprehensions can be used to create a concise one-liner that combines finding the sorted copy and the boundaries of the sublist. This method is not the most efficient but leverages Python’s powerful syntax to provide a quick solution.

Here’s an example:

```lst = [3, 7, 5, 6, 9]
sorted_lst = sorted(lst)
sublist = [x for i, x in enumerate(lst) if x != sorted_lst[i]]
print("Sublist to sort:", sublist)```

Output:

`Sublist to sort: [7, 5, 6]`

This one-liner leverages list comprehensions to iterate over the original and sorted lists concurrently, adding elements to the sublist that are not in the correct order, and then prints the sublist that needs to be sorted.

## Summary/Discussion

• Method 1: Two Pointers. Efficient for identifying boundaries. Can be complex to understand for beginners.
• Method 2: Sorting and Comparison. Simple to understand and implement. Less efficient due to sorting the full list.
• Method 3: Stack Data Structure. Improves readability over the two-pointers approach. The stack simplifies tracking the unsorted boundaries.
• Method 4: Simple Comparison. Intuitive and more performant than a full list sort. Relies on identifying out-of-place elements.
• Method 5: List Comprehensions. Very concise. Not as efficient due to the lack of optimization but demonstrates Python’s expressive power.