Selection Sort Algorithm in DSA Python - Build from Scratch

Selection Sort Algorithm

📖 Scenario: You have a list of numbers that you want to arrange from smallest to largest. This is like sorting your books by height on a shelf so they look neat.

🎯 Goal: You will build a program that uses the Selection Sort method to sort a list of numbers in ascending order.

📋 What You'll Learn

Create a list called numbers with the exact values: [29, 10, 14, 37, 13]

Create a variable called n that stores the length of the numbers list

Use a for loop with variable i to iterate from 0 to n - 1

Inside the loop, create a variable called min_index and set it to i

Use a nested for loop with variable j to iterate from i + 1 to n

Inside the nested loop, compare numbers[j] with numbers[min_index] and update min_index if a smaller number is found

After the nested loop, swap the values at numbers[i] and numbers[min_index]

Print the sorted numbers list

💡 Why This Matters

🌍 Real World

Sorting is used everywhere, like arranging books, organizing contacts, or displaying search results in order.

💼 Career

Understanding sorting algorithms helps in software development, data analysis, and optimizing performance in many applications.

1

Create the list of numbers

Create a list called numbers with these exact values: [29, 10, 14, 37, 13]

DSA Python

# Create the list called numbers with the values [29, 10, 14, 37, 13]
# Your code here

Hint

Use square brackets [] to create a list and separate numbers with commas.

2

Set the length of the list

Create a variable called n that stores the length of the numbers list using the len() function

DSA Python

numbers = [29, 10, 14, 37, 13]
# Create a variable n that stores the length of numbers
# Your code here

Hint

Use len(numbers) to find how many items are in the list.

3

Implement the selection sort loops

Use a for loop with variable i to iterate from 0 to n - 1. Inside it, create a variable min_index set to i. Then use a nested for loop with variable j to iterate from i + 1 to n. Inside the nested loop, if numbers[j] is less than numbers[min_index], update min_index to j. After the nested loop, swap numbers[i] and numbers[min_index]

DSA Python

numbers = [29, 10, 14, 37, 13]
n = len(numbers)
# Write the selection sort loops and swapping logic below
# Your code here

Hint

Remember to use two loops: the outer loop picks the position, the inner loop finds the smallest number to swap.

4

Print the sorted list

Print the numbers list after sorting using print(numbers)

DSA Python

numbers = [29, 10, 14, 37, 13]
n = len(numbers)
for i in range(n - 1):
    min_index = i
    for j in range(i + 1, n):
        if numbers[j] < numbers[min_index]:
            min_index = j
    numbers[i], numbers[min_index] = numbers[min_index], numbers[i]
# Print the sorted numbers list
# Your code here

Hint

Use print(numbers) to show the sorted list.

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