Python Selection Sort Tutorial
last modified March 8, 2025
In this article, we explain the selection sort algorithm in Python. We cover basic definitions, provide examples for sorting numeric and textual data, and compare selection sort with quick sort.
An algorithm is a step-by-step procedure for solving a problem or performing a computation. Algorithms are the backbone of computer programs.
Sorting is the process of arranging data in a specific order, such as ascending or descending. Sorting is a fundamental operation in computer science.
Common Sorting Algorithms
Some common sorting algorithms include:
- Selection Sort
- Bubble Sort
- Insertion Sort
- Merge Sort
- Quick Sort
- Heap Sort
Selection Sort Algorithm
The selection sort algorithm works by repeatedly finding the minimum (or maximum) element from the unsorted portion of the list and swapping it with the first unsorted element. This process continues until the entire list is sorted.
Selection Sort Example
The following is a Python implementation of the selection sort algorithm.
def selection_sort(arr, ascending=True):
n = len(arr)
for i in range(n):
idx = i
for j in range(i + 1, n):
if (ascending and arr[j] < arr[idx]) or (not ascending and arr[j] > arr[idx]):
idx = j
arr[i], arr[idx] = arr[idx], arr[i]
return arr
# Sorting numeric data
numbers = [64, 25, 12, 22, 11]
print("Sorted in ascending order:", selection_sort(numbers))
print("Sorted in descending order:", selection_sort(numbers, ascending=False))
# Sorting textual data
words = ["apple", "banana", "kiwi", "cherry"]
print("Sorted in ascending order:", selection_sort(words))
print("Sorted in descending order:", selection_sort(words, ascending=False))
The selection_sort function sorts a list in either ascending or
descending order. It works for both numeric and textual data.
$ ./selection_sort.py Sorted in ascending order: [11, 12, 22, 25, 64] Sorted in descending order: [64, 25, 22, 12, 11] Sorted in ascending order: ['apple', 'banana', 'cherry', 'kiwi'] Sorted in descending order: ['kiwi', 'cherry', 'banana', 'apple']
Comparing Selection Sort with Quick Sort
Selection sort is simple but inefficient for large datasets. Quick sort, on the other hand, is much faster for large datasets due to its divide-and-conquer approach. Let's compare their performance.
import time
import random
def selection_sort(arr):
n = len(arr)
for i in range(n):
idx = i
for j in range(i + 1, n):
if arr[j] < arr[idx]:
idx = j
arr[i], arr[idx] = arr[idx], arr[i]
return arr
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)
# Generate a large dataset
data = [random.randint(1, 1000) for _ in range(1000)]
# Benchmark selection sort
start = time.time()
selection_sort(data.copy())
end = time.time()
print(f"Selection Sort Time: {end - start:.6f} seconds")
# Benchmark quick sort
start = time.time()
quick_sort(data.copy())
end = time.time()
print(f"Quick Sort Time: {end - start:.6f} seconds")
The example benchmarks the performance of selection sort and quick sort on a dataset of 1000 random integers.
Source
In this article, we explained the selection sort algorithm in Python and compared it with quick sort.
Author
List all Python tutorials.