Sorting arrays is a fundamental operation in computer science that plays a crucial role in optimizing search and data manipulation operations. Selection sort is one of the simplest sorting algorithms that can be employed to arrange the elements of an array in ascending or descending order. In this article, we will dive into the selection sort algorithm and its working, implementation and time complexity. By the end of this article, you’ll have a solid understanding of how selection sort works and how to use it effectively.

Selection Sort Algorithm:

Selection sort is an in-place comparison sorting algorithm. The basic idea behind selection sort is to divide the input array into two subarrays: the sorted subarray and the unsorted subarray. The sorted subarray starts as an empty array, and the unsorted subarray contains all the elements yet to be sorted. In each iteration, the smallest (or largest, depending on the sorting order) element from the unsorted subarray is selected and swapped with the element at the beginning of the sorted subarray.

How Dose Selection Sort Algorithm Work?

The selection sort algorithm can be summarized in the following steps:

  1. Find the minimum (or maximum) element in the unsorted subarray.
  2. Swap the found element with the first element of the unsorted subarray.
  3. Expand the sorted subarray by moving the boundary one position to the right.

Implementing Selection Sort in C++:

Here’s a step-by-step implementation of the selection sort algorithm in C++:

#include <iostream>

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        int minIndex = i;
        for (int j = i + 1; j < n; ++j) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
        // Swap the minimum element with the first element of the unsorted subarray
        std::swap(arr[i], arr[minIndex]);

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    selectionSort(arr, n);
    std::cout << "Sorted array: ";
    for (int i = 0; i < n; ++i) {
        std::cout << arr[i] << " ";
    return 0;

Time Complexity of Selection Sort:

The time complexity of the selection sort algorithm is O(n^2), where n is the number of elements in the array. This is because, in the worst case, for each element in the array, the algorithm needs to iterate through the entire unsorted subarray to find the minimum (or maximum) element. As a result, the total number of comparisons and swaps becomes proportional to n^2.


Can selection sort be used for large datasets?

Selection sort’s time complexity of O(n^2) makes it inefficient for larger datasets. For large arrays, more advanced sorting algorithms like merge sort or quick sort are preferred.

Does selection sort maintain the relative order of equal elements?

Selection sort is not a stable sorting algorithm, meaning that it may change the relative order of equal elements during sorting.

How does selection sort compare to other sorting algorithms?

Selection sort is generally slower than more advanced sorting algorithms like merge sort or quick sort. However, it’s easy to implement and can be useful for small arrays or educational purposes.

What is the main advantage of selection sort?

The main advantage of selection sort is its simplicity. It’s easy to understand and implement, making it a good choice for learning about sorting algorithms.

Can selection sort be used for sorting linked lists?

Selection sort can be used to sort linked lists, but it’s generally not recommended due to its high time complexity and the need for swapping elements, which can be more complex with linked lists.

Is selection sort used in real-world applications?

Selection sort is not commonly used in real-world applications due to its inefficiency for larger datasets. However, it can still be useful for educational purposes and for scenarios where simplicity and ease of implementation are more important than performance.

And get notified everytime we publish a new blog post.