Selection Sort Algorithm in DSA Python

Mental Model

Selection sort finds the smallest item and puts it at the start, then repeats for the rest.

Analogy: Imagine picking the smallest apple from a basket and placing it in a new row, then picking the next smallest from the remaining apples, and so on.

Unsorted array:
[7, 3, 5, 2, 4]
Indexes:
 0  1  2  3  4

Dry Run Walkthrough

Input: array: [7, 3, 5, 2, 4]

Goal: Sort the array in ascending order using selection sort

Step 1: Find smallest from index 0 to end and swap with index 0

[2, 3, 5, 7, 4]

Why: We put the smallest number 2 at the start

Step 2: Find smallest from index 1 to end and swap with index 1

[2, 3, 5, 7, 4]

Why: 3 is already the smallest in the remaining part, so no change

Step 3: Find smallest from index 2 to end and swap with index 2

[2, 3, 4, 7, 5]

Why: 4 is the smallest from index 2 onwards, swap with 5

Step 4: Find smallest from index 3 to end and swap with index 3

[2, 3, 4, 5, 7]

Why: 5 is the smallest from index 3 onwards, swap with 7

Step 5: Last element is in place, sorting done

[2, 3, 4, 5, 7]

Why: Only one element left, so array is sorted

Result:

Final sorted array:
[2, 3, 4, 5, 7]

Annotated Code

DSA Python

def selection_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        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]

# Driver code
array = [7, 3, 5, 2, 4]
selection_sort(array)
print(array)

for i in range(n - 1):

iterate over each position to place the smallest element

min_index = i

assume current position holds the smallest value

for j in range(i + 1, n):

search for smaller element in the unsorted part

if arr[j] < arr[min_index]:

update min_index if a smaller element is found

arr[i], arr[min_index] = arr[min_index], arr[i]

swap smallest found with current position

Output

[2, 3, 4, 5, 7]

Complexity Analysis

Time: O(n^2) because for each element we scan the rest to find the smallest

Space: O(1) because sorting is done in place without extra storage

vs Alternative: Compared to bubble sort, selection sort does fewer swaps but still does O(n^2) comparisons

Edge Cases

empty array

function returns immediately with no error

DSA Python

for i in range(n - 1):

array with one element

no swaps needed, array stays the same

DSA Python

for i in range(n - 1):

array with all elements equal

no swaps happen, array remains unchanged

DSA Python

if arr[j] < arr[min_index]:

When to Use This Pattern

When you need a simple sorting method that selects the smallest item step-by-step, use selection sort because it clearly separates sorted and unsorted parts.

Common Mistakes

Mistake: Swapping inside the inner loop instead of after finding the minimum
Fix: Only swap once after the inner loop finishes to place the smallest element

Mistake: Not updating min_index when a smaller element is found
Fix: Update min_index inside the inner loop whenever a smaller element is found

Summary

Selection sort repeatedly finds the smallest element and moves it to the front.

Use it for small arrays or when simplicity is more important than speed.

The key insight is to separate the array into sorted and unsorted parts and pick the smallest from unsorted each time.

Practice

1. What is the main idea behind the Selection Sort algorithm?

easy

A. Repeatedly find the smallest element and move it to the front

B. Divide the list into halves and merge sorted halves

C. Swap adjacent elements if they are in wrong order repeatedly

D. Use a pivot to partition the list into smaller parts

Solution

1. Step 1: Understand Selection Sort process

   Selection Sort works by finding the smallest element in the unsorted part and swapping it with the first unsorted element.

2. Step 2: Compare with other sorting methods

   Other options describe different algorithms: merge sort, bubble sort, and quicksort, not selection sort.

3. Final Answer:

   Repeatedly find the smallest element and move it to the front -> Option A

4. Quick Check:

   Selection Sort = Find smallest and swap [OK]

Hint: Selection sort always picks the smallest next element [OK]

Common Mistakes:

• Confusing selection sort with bubble sort
• Thinking it divides the list like merge sort
• Mixing it up with quicksort's pivot method

2. Which of the following is the correct syntax to swap two elements a[i] and a[j] in Python during selection sort?

easy

A. temp = a[i]; a[i] = a[j]; a[j] = a[i]

B. a[i], a[j] = a[j], a[i]

C. swap(a[i], a[j])

D. a[i] = a[j]; a[j] = a[i]

Solution

1. Step 1: Identify Pythonic swap syntax

   Python allows swapping two variables in one line: a[i], a[j] = a[j], a[i].

2. Step 2: Check other options for correctness

   temp = a[i]; a[i] = a[j]; a[j] = a[i] causes data loss by overwriting without properly using temp; swap(a[i], a[j]) is invalid syntax; a[i] = a[j]; a[j] = a[i] causes both to have same value.

3. Final Answer:

   a[i], a[j] = a[j], a[i] -> Option B

4. Quick Check:

   Python swap = a[i], a[j] = a[j], a[i] [OK]

Hint: Use comma swap for clean Python element exchange [OK]

Common Mistakes:

• Using a function swap() which doesn't exist
• Assigning one element twice causing data loss
• Not using tuple unpacking for swap

3. What will be the output of the following code snippet?

def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

arr = [3, 1, 4]
selection_sort(arr)
print(arr)

medium

A. [4, 3, 1]

B. [3, 1, 4]

C. [1, 4, 3]

D. [1, 3, 4]

Solution

1. Step 1: Trace first iteration of outer loop

   i=0, min_idx=0; inner loop finds smallest element from index 1 and 2. arr[1]=1 < arr[0]=3, so min_idx=1. Swap arr[0] and arr[1]: arr becomes [1, 3, 4].

2. Step 2: Trace second iteration

   i=1, min_idx=1; inner loop checks arr[2]=4 which is not less than arr[1]=3, so no swap. Array stays [1, 3, 4].

3. Final Answer:

   [1, 3, 4] -> Option D

4. Quick Check:

   Sorted array = [1, 3, 4] [OK]

Hint: Selection sort places smallest element at front each pass [OK]

Common Mistakes:

• Not swapping when min_idx changes
• Confusing indices in inner loop
• Assuming array is unchanged

4. Identify the error in the following selection sort code and choose the correct fix:

def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] > arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

medium

A. Initialize min_idx to 0 instead of i

B. Swap should be done outside the outer loop

C. Change '>' to '<' in the if condition to find the smallest element

D. Use '==' instead of '>' in the if condition

Solution

1. Step 1: Analyze the if condition logic

   The code uses 'if arr[j] > arr[min_idx]' which finds the largest element, but selection sort needs the smallest.

2. Step 2: Correct the comparison operator

   Changing '>' to '<' will correctly find the smallest element to swap.

3. Final Answer:

   Change '>' to '<' in the if condition to find the smallest element -> Option C

4. Quick Check:

   Selection sort finds minimum, so use '<' [OK]

Hint: Selection sort finds minimum, so use '<' in comparison [OK]

Common Mistakes:

• Using '>' causes sorting in descending order
• Swapping outside loop breaks logic
• Wrong initialization of min_idx

5. Given a list arr = [5, 3, 8, 3, 9], how many swaps will the selection sort algorithm perform to sort this list in ascending order?

hard

A. 3

B. 4

C. 2

D. 5

Solution

1. Step 1: Trace selection sort swaps step-by-step

   Initial array: [5, 3, 8, 3, 9] - i=0: smallest is 3 at index 1, swap arr[0] and arr[1] -> [3, 5, 8, 3, 9] (1 swap) - i=1: smallest is 3 at index 3, swap arr[1] and arr[3] -> [3, 3, 8, 5, 9] (2 swaps) - i=2: smallest is 5 at index 3, swap arr[2] and arr[3] -> [3, 3, 5, 8, 9] (3 swaps) - i=3: smallest is 8 at index 3, no swap needed - i=4: last element, no swap needed

2. Step 2: Count total swaps

   Total swaps performed = 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Swaps counted = 3 [OK]

Hint: Count swaps only when min_idx changes and swap occurs [OK]

Common Mistakes:

• Counting swaps even when min_idx equals i
• Assuming one swap per iteration always
• Ignoring repeated elements affecting swaps