Types of sorting and searching in python
Python provides a variety of techniques for sorting and searching
data. These methods range from built-in functions designed for
everyday use to classic algorithms that you can implement
manually when you need fine-grained control. Let’s explore these
approaches in detail.
Sorting Algorithms in Python
Built-in Methods
Python’s built-in functions, sorted() and the list method .sort(),
use Timsort—a hybrid sorting algorithm derived from merge and
insertion sort. Timsort is highly optimized for real-world data,
ensuring both stability and efficiency. For most applications, these
built-ins are your go-to tools because of their simplicity and speed.
Comparison-Based Sorting Algorithms
These algorithms make decisions by comparing elements. Their
performance, especially on small datasets, is often intuitive and
easy to understand:
• Bubble Sort: Compares adjacent elements and swaps them if
they're in the wrong order. Although simple, its worst-case
time complexity is O(n²), making it impractical for larger
datasets.
python
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1],
arr[j]
return arr
data = [64, 34, 25, 12, 22, 11, 90]
print(bubble_sort(data))
• Insertion Sort: Builds the sorted list one element at a time by
finding the correct insertion point for each element. It works
well for nearly sorted or small datasets.
python
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
data = [19, 2, 31, 45, 30, 11, 121, 27]
print(insertion_sort(data))
• Selection Sort: Repeatedly selects the minimum element
from the unsorted portion and moves it to the beginning. Like
bubble sort, it has a time complexity of O(n²) but is
conceptually straightforward.
• Merge Sort: A divide-and-conquer algorithm that splits the list
into halves, recursively sorts each half, and then merges them.
This guarantees an O(n log n) performance, making it efficient
for larger lists.
python
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
merged = []
while left and right:
if left[0] < right[0]:
merged.append(left.pop(0))
else:
merged.append(right.pop(0))
merged.extend(left if left else right)
return merged
data = [64, 34, 25, 12, 22, 11, 90]
print(merge_sort(data))
• Quick Sort: Often faster in practice than other O(n(n) log n))
algorithms on average, quick sort uses a pivot to partition the
array into elements less than the pivot and greater than it, then
recursively sorts the sub-arrays. However, its worst-case
performance is O(n²).
• Heap Sort: Converts the list into a heap data structure, then
repeatedly extracts the maximum (or minimum) element to
build a sorted list in O(n log n) time.
• Shell Sort: An optimized version of insertion sort that allows
elements to move over larger gaps, thereby reducing the
number of swaps.
These methods—and several others like counting, radix, and bucket
sort (often seen in specialized or non-comparison sorting
contexts)—offer flexibility depending on the data characteristics
and performance requirements 2.
Searching Algorithms in Python
Searching is about locating a particular element within a data
structure. The choice of search algorithm often depends on whether
or not the data is sorted.
• Linear Search: The simplest form of searching, linear search
traverses each element one by one until the target is found. Its
time complexity is O(n), making it suitable for small or
unsorted datasets.
python
def linear_search(arr, target):
for index, value in enumerate(arr):
if value == target:
return index
return -1
data = [5, 3, 7, 1, 9]
print(linear_search(data, 7)) # Outputs 2
• Binary Search: When dealing with sorted data, binary search
can efficiently locate an item by repeatedly dividing the search
interval in half. This technique has a time complexity of O(log
n) and can be implemented either recursively or iteratively.
python
def binary_search(arr, target):
low, high = 0, len(arr) - 1
while low <= high:
mid = (low + high) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
low = mid + 1
else:
high = mid - 1
return -1
data = [1, 3, 5, 7, 9]
print(binary_search(data, 7)) # Outputs 3
• Other Searches: In addition to these, algorithms such as jump
search, interpolation search, or even leveraging Python
dictionaries for O(1) average-time lookups (when keys are
known) are effective for specific scenarios. These methods
allow you to optimize based on the structure and constraints
of your data .
In Summary
Python’s ecosystem supports both simple and complex schemes
for sorting and searching:
• Sorting: Whether you use Python's built-in Timsort methods
(sorted() and .sort()) or implement classic algorithms like
bubble, insertion, merge, or quick sort, each method provides
a trade-off between simplicity and performance. For
specialized needs, non-comparison-based methods such as
counting or radix sort may be preferred.
• Searching: Linear search is straightforward and versatile for
unsorted data, while binary search offers fast performance on
sorted datasets. Additionally, data structures like dictionaries
enable constant-time lookups under ideal conditions.
