Array Sorting Algorithms in Python
Sorting algorithms are used to arrange elements in a list or array in a specific order, usually in
ascending or descending order. Below are some common sorting algorithms along with Python
implementations.
1. Bubble Sort
Bubble sort is a simple algorithm that repeatedly steps through the list, compares adjacent
elements, and swaps them if they are in the wrong order. The process repeats until the list is
sorted.
Time Complexity:
• Worst case: O(n²)
• Best case: O(n) (if already sorted)
• Average case: O(n²)
Python Code:
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] # Swap
# Example usage
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("Sorted array:", arr)
2. Selection Sort
Selection sort divides the list into two parts: the sorted part and the unsorted part. It repeatedly
selects the smallest element from the unsorted part and swaps it with the first unsorted
element.
Time Complexity:
• Worst case: O(n²)
• Best case: O(n²)
• Average case: O(n²)
Python Code:
def selection_sort(arr):
n = len(arr)
for i in range(n):
min_index = i
for j in range(i+1, n):
if arr[j] < arr[min_index]:
min_index = j
arr[i], arr[min_index] = arr[min_index], arr[i] # Swap
# Example usage
arr = [64, 34, 25, 12, 22, 11, 90]
selection_sort(arr)
print("Sorted array:", arr)
3. Insertion Sort
Insertion sort works by taking one element at a time and inserting it into its correct position in a
sorted portion of the list. It's similar to how you might sort playing cards in your hands.
Time Complexity:
• Worst case: O(n²)
• Best case: O(n) (if already sorted)
• Average case: O(n²)
Python Code:
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
# Example usage
arr = [64, 34, 25, 12, 22, 11, 90]
insertion_sort(arr)
print("Sorted array:", arr)
4. Merge Sort
Merge sort is a divide-and-conquer algorithm. It divides the array into two halves, sorts each
half recursively, and then merges the sorted halves. Merge sort has better performance
compared to the previous algorithms.
Time Complexity:
• Worst case: O(n log n)
• Best case: O(n log n)
• Average case: O(n log n)
Python Code:
def merge_sort(arr):
if len(arr) > 1:
mid = len(arr) // 2
left_half = arr[:mid]
right_half = arr[mid:]
merge_sort(left_half)
merge_sort(right_half)
i=j=k=0
while i < len(left_half) and j < len(right_half):
if left_half[i] < right_half[j]:
arr[k] = left_half[i]
i += 1
else:
arr[k] = right_half[j]
j += 1
k += 1
while i < len(left_half):
arr[k] = left_half[i]
i += 1
k += 1
while j < len(right_half):
arr[k] = right_half[j]
j += 1
k += 1
# Example usage
arr = [64, 34, 25, 12, 22, 11, 90]
merge_sort(arr)
print("Sorted array:", arr)
5. Quick Sort
Quick sort is another divide-and-conquer algorithm. It selects a pivot element from the array,
partitions the other elements into two sub-arrays (elements less than the pivot and elements
greater than the pivot), and recursively sorts the sub-arrays.
Time Complexity:
• Worst case: O(n²) (if pivot is poorly chosen)
• Best case: O(n log n)
• Average case: O(n log n)
Python Code:
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
# Example usage
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = quick_sort(arr)
print("Sorted array:", sorted_arr)
6. Heap Sort
Heap sort is based on the binary heap data structure. It converts the array into a binary heap (a
complete binary tree) and repeatedly extracts the maximum element from the heap and places
it at the end of the array.
Time Complexity:
• Worst case: O(n log n)
• Best case: O(n log n)
• Average case: O(n log n)
Python Code:
import heapq
def heap_sort(arr):
heapq.heapify(arr) # Convert array into a min-heap
return [heapq.heappop(arr) for _ in range(len(arr))]
# Example usage
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = heap_sort(arr)
print("Sorted array:", sorted_arr)
7. Python’s Built-in Sort
Python provides a built-in method called sort() (for sorting in place) and sorted() (returns a new
sorted list). Both use Timsort (a hybrid sorting algorithm derived from merge sort and insertion
sort), which is highly efficient.
Time Complexity:
• Worst case: O(n log n)
• Best case: O(n) (for nearly sorted data)
• Average case: O(n log n)
Python Code:
arr = [64, 34, 25, 12, 22, 11, 90]
arr.sort() # Sorts the array in place
print("Sorted array:", arr)
# Or using sorted() to return a new sorted array
arr2 = [64, 34, 25, 12, 22, 11, 90]
sorted_arr2 = sorted(arr2)
print("Sorted array:", sorted_arr2)
Summary of Sorting Algorithms
Time Complexity Time Complexity Time Complexity Space
Algorithm
(Best) (Average) (Worst) Complexity
Bubble Sort O(n) O(n²) O(n²) O(1)
Selection
O(n²) O(n²) O(n²) O(1)
Sort
Insertion
O(n) O(n²) O(n²) O(1)
Sort
Merge Sort O(n log n) O(n log n) O(n log n) O(n)
Time Complexity Time Complexity Time Complexity Space
Algorithm
(Best) (Average) (Worst) Complexity
Quick Sort O(n log n) O(n log n) O(n²) O(log n)
Heap Sort O(n log n) O(n log n) O(n log n) O(1)
Python Sort O(n) O(n log n) O(n log n) O(n)
Each algorithm has its strengths and weaknesses, and the choice of which one to use depends
on the problem and the dataset. For practical purposes, Timsort (used in Python's sort()
method) is the most commonly used due to its performance and efficiency in handling both
sorted and unsorted data.
