## Introduction to Selection Sort in Data Structure

Selection sort is one of the sorting algorithms which arrange the data in ascending order. What selection sort does is that first, it searches for the lowest value element in the array and then brings it to the first position. Later, from the remaining array, it finds the lowest value element and after searching such an element it brings it to the second position. Likewise, the algorithm goes on sorting the array finally ending up with the sorted array. Here we will discuss the algorithm and implementation of selection sort in data structure with steps.

### Algorithm for Selection Sort

We shall now go through the algorithm for selection sort. Just observe how the operations take place as using this algorithm we will implement a program for selection sort.

**Algorithm:**

`function selection sort (array [], integer variable n)`

declare integer variable position

declare index variables i, j

begin:

loop (i = 0, i < n-1, i = i +1)

begin:

position = i

loop(j = i + 1, j < n, j = j ++)

begin:

if(array[j] < array[position]) then

position = j

end if

end

swap(array[position], a[i])

end

end

### Program for Implementing Selection Sort

The program code to implement selection sort is as given below. This program can be implemented in any programming language of our choice. We implemented the program in C programming. Go through the program and each of the coding elements including variables, statements, and loops to understand how these elements function.

**Code:**

`#include <stdio.h>`

#include <conio.h>

void main()

{

int arr[50], num, i, j, pos, temp;

printf("Enter the number of elements in the array: ");

scanf("%d", &num);

printf("\nEnter the numbers: ");

for(i = 0; i < num; i++)

{

scanf("%d", &arr[i]);

}

for(i = 0;i < (num - 1); i++)

{

pos = i;

for(j = i + 1; j < num; j++)

{

if (arr[pos] > arr[j])

pos = j;

}

if(pos != i)

{

temp = arr[i];

arr[i] = arr[pos];

arr[pos] = temp;

}

}

printf("\nThe array sorted in ascending order is as follows.\n");

for(i = 0; i < num; i++)

printf("%d ", arr[i]);

getch();

}

We tested the above program with multiple inputs and the program worked correctly. Click on Run option and pass the required input so as to validate the program. Let’s go through the various inputs that we passed into and the results that we got.

4.7 (3,220 ratings)

View Course

**Input 1**

In this case, we passed five different two digits numbers. While passing the elements ensure that they are separated by space or enter. E.g. if we intend to pass three numbers 23, 45, and 87 then pass them as 23 45 87 and not as 234587 or else the compiler will consider it as a single element. The following screenshot shows this.

**Input 2**

In this case, we tested the program by passing an array containing eight elements. The array has elements present in the descending order. When executed, the program worked correctly giving the array sorted in ascending order of the numeric elements it has. Let’s go through the following programming output.

**Input 3**

In this case, we passed nine different numbers. As mentioned earlier, while passing numbers separate them with space. We must pass a specified number of elements only. As can be seen in the below screenshot, we got the input array sorted in the ascending order. So, this shows that our algorithm has worked correctly.

### How the Selection Sort Algorithm Works?

In the above section, we saw how the selection sort algorithm gave us correct results after we tested the program implementing the algorithm through various inputs. Now, we will go through the steps that are followed by a selection sort algorithm by following which we get the array sorted in ascending order.

For the understanding of how the algorithm works, we are considering an array that we passed in the second input example described above. The array consists of eight elements present in descending order. These eight numeric elements are 98, 93, 87, 64, 57, 48, 32, and 12. The steps followed by the selection sort algorithm to sort these elements in ascending order are as described below.

**Step 1: **Initially, the input array looks like as shown:

**Step 2: **The lowest element from the entire array is brought to the first place. So, 12 will come to the first place and 98 will go to the last place as shown below.

**Step 3: **Now, the first element remains intact and all the operations happen with the rest of the array elements. The process works the same as in the above step. From the remaining array, the lowest element is brought to the second position. So, here 32 will come to the second position and 93 will go to the position of 32. The array after swapping looks like as shown below.

**Step 4:** The next smallest element in the remaining array is 48. Now, 48 gets swapped with 87, and after the positions of these two elements are changed, 48 comes to the third position and the array looks like as shown in the below screenshot.

**Step 5:** If we see the array now, we find that it almost looks as if it has got sorted. In the remaining array now we have only two elements left which are 64 and 57. Had 57 been at 64’s position then in the above step itself the selection sort would have given us the ascendingly sorted array. However, now, the position of these two elements must be changed. So, selection sort brings 57 at the position of 64, the former numeric element being lower than the latter. After the swapping takes place, the array looks like as shown below.

### Conclusion – Selection Sort in Data Structure

The selection sort is a very easy algorithm to implement. Irrespective of the programming tool used for implementing the algorithm, the concept remains the same. Prior to implementing the program, the algorithm must be studied so as to understand the functioning of the algorithm.

### Recommended Articles

This is a guide to Selection Sort in Data Structure. Here we discuss the introduction, how it works, program and algorithm for selection sort in data structure. You can also go through our other suggested articles to learn more –