Can I simplify selection sort in C? - c

Question

Selection sort in C usually written in the form of the following code below, introducing a min_pos variable in which is stored the index of the minimum number of the array in a particular step of a for loop:
void selectionsort(int A[], int n)
{
for (int i = 0; i < n - 1; i++)
{
int min_pos = i;
for (int j = i + 1; j < n; j++)
{
if (A[j] < A[min_pos])
{
min_pos = j;
}
if (min_pos != i)
{
int temp;
temp = A[i];
A[i] = A[min_pos];
A[min_pos] = temp;
}
}
}
return;
}
But, Is it necessary to introduce this variable when we can get the same result using the following code?
void selectionsort(int A[], int n)
{
for (int i = 0; i < n - 1; i++)
{
for (int j = i + 1; j < n; j++)
{
if (A[j] < A[i])
{
int temp;
temp = A[i];
A[i] = A[j];
A[j] = temp;
}
}
}
return;
}

Answer 1

Both functions achieve the same result but neither one is a correct implementation of selection sort. They implement a less efficient algorithm called exchange sort.
For selection sort, a single swap should be performed for each element in the array. This was probably the purpose of the min_pos variable in the first function.
Here is a modified version:
void selectionsort(int A[], int n)
{
for (int i = 0; i < n - 1; i++)
{
int min_pos = i;
for (int j = i + 1; j < n; j++)
{
if (A[j] < A[min_pos])
{
min_pos = j;
}
}
if (min_pos != i)
{
int temp = A[i];
A[i] = A[min_pos];
A[min_pos] = temp;
}
}
}

Answer 2

Here's a wondeful explanation (unmodified) by owner of a youtube channel named : portfolio courses
Wow - this is an awesome question! :-) So the above algorithm will work too, but it just sorts the array in a different way. As to why we might not do it this way:
This is a video on selection sort, and the above algorithm is not selection sort (even though it's close to it). In selection sort we find the smallest/largest element in the unsorted portion and swap it with the leftmost unsorted algorithm. Other approaches may also work, but they will not be a selection sort anymore. The above approach will do many, many more swaps than required.
For comparison's sake, I modified this code here to test the two different algorithms: https://github.com/portfoliocourses/c-example-code/blob/main/selection_sort.c. I modified the code to count the number of swaps required (see the modifications below for Selection Sort and this New Algorithm you've made). Selection Sort required only 6 swaps, where as the code above required 31 swaps.
One of the reasons why Selection Sort is used is that it's helpful when the cost of performing a swap in terms of time is high: https://en.wikipedia.org/wiki/Sorting_algorithm#Selection_sort. I know it's Wikipedia, but see this quote: "It does no more than n swaps, and thus is useful where swapping is very expensive."
Selection Sort:
int num_swaps = 0;
for (int i = 0; i < length - 1; i++)
{
// find the position of the minimum element in the unsorted portion of
// the array
int min_pos = i;
for (int j = i + 1; j < length; j++)
if (a[j] > a[min_pos]) min_pos = j;
// if that element is NOT the element at index i, then swap that element
// with the element at index i
if (min_pos != i)
{
int temp = a[i];
a[i] = a[min_pos];
a[min_pos] = temp;
num_swaps++;
}
}
New Algorithm:
int num_swaps = 0;
for (int i=0; i<length-1; i++)
{
for (int j=i+1; j<length; j++)
{
if(a[i]>a[j])
{
int temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
num_swaps++;
}
}
}

Answer 3

I think both algorithms are not particularly efficient, a more efficient way to write them would be as below:
void selectionsort(int A[], int n)
{
for (int i = 0; i < n - 1; i++)
{
int min_pos = i;
for (int j = i + 1; j < n; j++)
{
if (A[j] < A[min_pos])
{
min_pos = j;
}
}
if (min_pos != i)
{
int temp;
temp = A[i];
A[i] = A[min_pos];
A[min_pos] = temp;
}
}
return;
}
Notice how the min_pos variable is used as a temporary storage for the swapping position. This is beneficial since the swapping requires three operations while using min_pos only requires one operation.