C Program for Selection Sort

Last Updated : 20 Aug, 2024

The selection sort is a simple comparison-based sorting algorithm that sorts a collection by repeatedly finding the minimum (or maximum) element and placing it in its correct position in the list. It is very simple to implement and is preferred when you have to manually implement the sorting algorithm for a small amount of dataset.

In this article, we will learn about the selection sort, its working and its implement in C language.

How Selection Sort Works in C?

Selection sort work by virtually dividing the array into two parts: sorted and unsorted. Initially, whole list is considered unsorted. Starting from the first element in the unsorted part, a minimum element is identified from the unsorted part of the array and placed at the current position. The same is done for the rest of the elements in the unsorted part one by one gradually growing the sorted part till the whole array is sorted.

Let’s take the example of the array {64, 25, 12, 22, 11} which we want to sort in ascending order and see what happens in each pass:

The resultant array is the sorted array.

Selection Sort Algorithm in C

Start with the entire list as unsorted.
Start traversing the list from the first element.
For each element:
- Find the smallest element from the current position to the end of the list.
- Swap it with the current element to place it in its correct position.
Move to the next element and repeat until all elements are sorted.

C Program to Implement Selection Sort Algorithm

// C program for implementation of selection sort
#include <stdio.h>

void selectionSort(int arr[], int N) {

    // Start with the whole array as unsored and one by
  	// one move boundary of unsorted subarray towards right
    for (int i = 0; i < N - 1; i++) {

        // Find the minimum element in unsorted array
        int min_idx = i;
        for (int j = i + 1; j < N; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }

        // Swap the found minimum element with the first
        // element in the unsorted part
        int temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int N = sizeof(arr) / sizeof(arr[0]);
    printf("Unsorted array: \n");
    for (int i = 0; i < N; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
  
  	// Calling selection sort
    selectionSort(arr, N);

    printf("Sorted array: \n");
    for (int i = 0; i < N; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

Output

Unsorted array: 
64 25 12 22 11 
Sorted array: 
11 12 22 25 64

Time Complexity: O(N²), as there are two nested loops.
Auxiliary Space: O(1), as the only extra memory used is for temporary variable while swapping two values in Array.

Advantages of Selection Sort in C

Selection Sort is easy to understand and implement.
It requires no additional memory beyond a few variables, making it space efficient.
The number of comparisons and swaps is fixed, providing consistent performance regardless of the input order.
Selection Sort minimizes the number of swaps, which can be useful in scenarios where writing to memory is costly.

Disadvantages of Selection Sort in C

The O(N²) time complexity makes Selection Sort inefficient for sorting large datasets, as it can be significantly slower than more advanced algorithms like QuickSort or MergeSort.
Without modifications, Selection Sort may change the relative order of equal elements, which can be problematic in some applications.
Selection Sort always makes the same number of comparisons, even if the array is already sorted, leading to unnecessary computations.