### The Algorithm :

Selection sort is an in-place comparison sorting algorithm. It has an O(n2) time complexity, which makes it inefficient on large lists, and generally performs worse than the similar insertion sort. Selection sort is noted for its simplicity and has performance advantages over more complicated algorithms in certain situations, particularly where auxiliary memory is limited.

The algorithm divides the input list into two parts: a sorted sublist of items which is built up from left to right at the front (left) of the list and a sublist of the remaining unsorted items that occupy the rest of the list. Initially, the sorted sublist is empty and the unsorted sublist is the entire input list. The algorithm proceeds by finding the smallest (or largest, depending on sorting order) element in the unsorted sublist, exchanging (swapping) it with the leftmost unsorted element (putting it in sorted order), and moving the sublist boundaries one element to the right.

The time efficiency of selection sort is quadratic, so there are a number of sorting techniques which have better time complexity than selection sort. One thing which distinguishes selection sort from other sorting algorithms is that it makes the minimum possible number of swaps, n − 1 in the worst case.

Let us take the array {22,8,4,11,5,78,2,7,15,44} as an example to demonstrate how selection sort works in arranging the elements in ascending order.

### The Code :

import java.util.*;
class selection
{
public static void main()
{

int ar[] = {22,8,4,11,5,78,2,7,15,44};
int i,j,temp,small,ind;
System.out.println("Unsorted array : ");
for(i = 0; i < 10; i++)
{
System.out.print(ar[i] + "\t");
}
for(i = 0; i < 10; i++)
{
small = ar[i];
ind = i;
for(j = i+1; j < 10; j++)
{
if(ar[j] < small)
{
small = ar[j];
ind = j;
}
}
temp = ar[i];
ar[i] = ar[ind];
ar[ind] = temp;
}
System.out.println("\nSorted array : ");
for(i = 0; i < 10; i++)
{
System.out.print(ar[i] + "\t");
}
}
}

The Selection Sort algorithm has :

A Worst – Case performance of O(n2) comparisons and O(n) swaps

A Best Case performance of O(n2) comparisons and O(n) swaps

An Average performance of O(n2) comparisons and O(n) swaps

A Worst – Case space complexity of O(1) auxiliary

The github link for the program is :