Selection Sort

The algorithm (i.e., the approach) used by selection sort corresponds closely to the technique you might use if you were asked to sort a deck of cards, a pile of folders, a list of names:

• Find the smallest value, set it aside, and make it the first
• Find the smallest value of the remaining items and make it the second
• Repeat until you've gone through the whole set of items

Selection sort basically does the same thing, but we take into consideration that we're working with an array:

• We don't set the smallest value to the side, we rather move it to the beginning of the array
  • We have to do something with the element that's already there-- we'll swap them
• Each successive 'smallest' element will go into the second, third, etc elements of the array

We can thus think of the array as being divided into two parts:

• The left side which is sorted and growing
• The right side which is unsorted and shrinking

What we will do is ave a pair of nested loops:

• The outer loop will determine which 'smallest' element we're selecting
  • The first time through it will be the actual smallest element, the second time through the next-to-smallest, etc.
  • Each time through this outer loop, the sorted portion gets one bigger and the unsorted portion one element smaller.
• The inner loop will find the smallest element remaining in the unsorted portion
  • Start at the left end of the sorted portion and move through the array
  • Whenever we find an element smaller than the leftmost element, swap them
  • When we have reached the end of the array, the leftmost element contains the smallest (remaining) value

Initially:

+----------------------------------------------------------------------------+
|                                                                            |
|                          unsorted                                          |
|                                                                            |
+----------------------------------------------------------------------------+

After one iteration through the outer loop:

+----------------------------------------------------------------------------+
|        |                                                                   |
|smallest|                 unsorted                                          |
|        |                                                                   |
+----------------------------------------------------------------------------+

Halfway through the outer loop:

+----------------------------------------------------------------------------+
|                               |                                            |
|         sorted                |          unsorted                          |
|                               |                                            |
+----------------------------------------------------------------------------+

At end:

+----------------------------------------------------------------------------+
|                                                                            |
|                            sorted                                          |
|                                                                            |
+----------------------------------------------------------------------------+

The Selection Sort Algorithm (SwappySelectionSort)

A very high-level statement of the approach:

Go through the array from beginning to end
   Find the smallest element in the array from the current position to the end,
	   and place it in that position

In a bit more detail:

Go through the array from beginning to end
   Go through the array from the current position to the end
      If an element is less than the value in the current position swap them

Let's start getting down to code-level

for (currentPosition = 0; currentPosition < size; currentPosition++)
   for (j = currentPosition+1; j < size; j++)
      if (arr[j] < arr[currentPosition] 
         swap(arr[j], arr[currentPosition])

Here it is turned into a method:

void selectionSort(int [] arr, int size) {
	for (currentPosition = 0; currentPosition < size; currentPosition++)
	   for (j = currentPosition+1; j < size; j++)
		 if (arr[j] < arr[currentPosition] 
		    swap(arr, j, currentPosition)
}

An Optimization of Selection Sort (SelectionSort)

Rather than constantly swapping each time we find a new minimum value, we remember the position of the smallest value encountered and it's only once we've gone completely through the array in the inner loop that we swap the smallest value into the current position.

void selectionSort(int [] arr, int size) {
	for (currentPosition = 0; currentPosition < size; currentPosition++)
		int pos = currentPosition;
		for (j = currentPosition+1; j < size; j++)
			if (arr[j] < arr[currentPosition] 
				pos = j;
		swap(arr, pos, currentPosition)
}

One More Optimization (LazySelectionSort)

Each time we've gone completely through the inner loop, before we swap the smallest element to the current position, we make sure the smallest value is not already at the current position.

void selectionSort(int [] arr, int size) {
	for (currentPosition = 0; currentPosition < size; currentPosition++)
		int smallestPosition = currentPosition;
		for (j = currentPosition+1; j < size; j++)
			if (arr[j] < arr[currentPosition] 
				smallestPosition = j;
		if (smallestPosition != currentPosition) swap(arr, pos, currentPosition)
}

and here it is with the inner loop (a single pass through the array) turned into a method:

void selectionSort(int [] arr, int size) {
	for (currentPosition = 0; currentPosition < size; currentPosition++)
		int smallestPosition = findSmallestPosition(arr, size);
		if (smallestPosition != currentPosition) swap(arr, pos, currentPosition)
}

int findSmallestPosition(int [] arr, int size) {
	int smallestPosition = currentPosition;
	for (j = currentPosition+1; j < size; j++)
		if (arr[j] < arr[currentPosition] 
			smallestPosition = j;
	return smallestPosition;
}

Pass through the array until a pass is completed with no swaps performed
		 Compare adjacent elements and swap if they're out of order

   Go through the array from the beginning to end
      If an element at position i is less than the element at position i+1 swap them
If a swap was performed repeat

do {
   bool swapped = false;
   for (i = 0; i < n-1; i++)
      if (arr[i] > arr[i+1] { 
         swap(arr, i, i+1)
         swapped = true;
      }
} while (swapped)

for (int i = 0; i < n; i++)
	for (int j = 0; j < n-1; j++)
		if (arr[j] > arr[j+1])
			swap(arr, j, j+1);

for (int last = n-1; last > 0; last--)
	for (int i = 0; i < last; i++)
		if (arr[i] > arr[i+1])
			swap(arr, i, i+1);

boolean swapped = true;
for (int last = n-1; last > 0 && swapped; last--) {
	swapped = false;
	for (int i = 0; i < last; i++)
		if (arr[i] > arr[i+1]) {
			swap(arr, i, i+1);
			swapped = true;
		}
}

Why do we have to bother with two sorts

• Examine bubble sort-- what if the array came in sorted to begin with? What about selection sort?
• Our selection sort is actually a bit simple-minded in constantly swapping-- there's a more 'swap-efficient' version that does significantly less movement than the version we presented-- and bubble sort for that matter.

public static int find(int [] arr, int val) {
	int lo = 0, hi = arr.length-1;
	while (lo <= hi) {
		int mid = (hi+lo)/2;
		if (val == arr[mid]) 
			return mid;
		else if (val < arr[mid]) 
			hi = mid - 1;
		else
			lo = mid + 1;
	}
	return -1;
}