*Sorting algorithms* take a sequence of values and arrange them in
*sorted order*: usually lowest to highest (*ascending* order),
although highest to lowest order (*descending* order) is
sometimes used.

In Java, the simplest way to represent a sequence of values is to use an array. Therefore, sorting in Java is generally accomplished by re-arranging the elements of an array so they are in sorted order.

*Selection sort* is a simple sorting algorithm. Here is
the pseudo-code for selection sort:

for each index (curIndex) in the array from 0 to end of the array { find the index (minIndex) of the minimum value between curIndex and end of array swap elements at curIndex and minIndex }

The outer loop proceeds through each position in the array from beginning to end. Each iteration of the outer loop find the next-smallest element and moves it into the correct location in the array. Thus, when the outer loop terminates each element of the array will contain the correct element in order for the entire array to be in ascending order.

The steps listed in green are subproblems that we can solve in separate methods, as discussed in Lecture 14. The method to find the minimum element between curIndex and the end of the array will need to take both curIndex and a reference to the array as input parameters, and will return the index of the minimum value as a return value. The method to swap two elements in the array will need to take a reference to the array, curIndex, and minIndex as input parameters. This method does not need to return a value because it works by modifying the input array.

Within the selection sort method, we note that we need variables for curIndex and minIndex. The method can take the array to be sorted as an input parameter. Because the method works by modifying the input array, it doesn't need to explicitly return an input value.

Here is the Java code for the selection sort, which is defined to sort an array of double values:

public static void selectionSort(double[] array) { int minIndex; int curIndex; // for each index (curIndex) in the array from 0 to end of the array for (curIndex = 0; curIndex < array.length; curIndex++) { // find the index (minIndex) of the minimum value between curIndex and end of array minIndex = findMinIndex(array, curIndex); // swap elements at curIndex and minIndex swapValues(array, curIndex, minIndex); } }

The findMinIndex method is an example of a *search* algorithm: it
needs to find a value with a particular property (being the minimum) among
a collection of values. In this case, we know that we can't prove that
any particular element is the minimum unless we examine each element in
the collection. A common pattern for this kind of problem is to
start out by *assuming* that the first value in the collection is the
one we are looking for, and then considering each remaining element in the
collection. If we encounter a value that is a better candidate
than our current candidate, then we change our assumption to reflect the
new information.

Here is the pseudo-code for findMinIndex:

begin by assuming the start element is the minimum value for each remaining index (curIndex) in range start+1 to end of array { see if the element at curIndex is less than current minimum value if so, current value is the new minimum value }

The algorithm uses two items of data:

- The index of the minimum element (minIndex)
- The index of the current element (curIndex)

These become local variables in the method.

Translation into Java:

private static int findMinIndex(double[] array, int startIndex) { int curIndex; int minIndex; // begin by assuming the start element is the minimum value minIndex = startIndex; // for each remaining index (curIndex) in range start+1 to end of array for (curIndex = startIndex + 1; curIndex < array.length; curIndex++) { // see if the element at curIndex is less than current minimum value if (array[curIndex] < array[minIndex]) { // if so, current value is the new minimum value minIndex = curIndex; } } return minIndex; }

The swapValues method exchanges the values of two array elements
whose indices are given as input parameters. A *temporary variable*
is required to perform the exchange:

private static void swapValues(double[] array, int firstIndex, int secondIndex) { double temp; temp = array[firstIndex]; array[firstIndex] = array[secondIndex]; array[secondIndex] = temp; }

You should convince yourself that this method does indeed perform the task of swapping two array elements, and that it would not have the indended effect without the use of the temporary variable.

Now that we've completed the selectionSort method and the other implementation methods it relies on, we can test it to make sure it performs correctly on some test data. Since we are working with arrays of double values, we will need a method to print the contents of an array of double:

public static void printVals(double[] array) { for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); } System.out.println(); }

With the printVals method in place, we can write a test method:

public static void testSelectionSort() { double[] testArray = new double[5]; testArray[0] = 4.0; testArray[1] = 7.0; testArray[2] = 1.0; testArray[3] = 3.0; testArray[4] = 6.0; System.out.println("Before sorting"); printVals(testArray); selectionSort(testArray); System.out.println("After sorting"); printVals(testArray); }

Here is the output of running the test method in the DrJava interactions window:

Welcome to DrJava. >Sort.testSelectionSort()Before sorting 4.0 7.0 1.0 3.0 6.0 After sorting 1.0 3.0 4.0 6.0 7.0

So far we have seen arrays that are *sequences* of elements, where each
element is identified by a single index value. A *multidimensional*
array is an array where each element is identified by *mutliple*
index values. For example, in a two-dimensional array, each element
is identified by 2 index values, and you can think of it as being like
a grid. A three-dimensional array would be like a cube, and so on.

In the following example, let's say that we're writing a TicTacToe game and we will use a two-dimensional array of integers to represent the game board.

Declaring an array variable:

int[][] gameBoard;

Remember that because arrays are reference types, declaring an array variable
does not actually create an array object. Creating the object must
be done using a **new** expression:

gameBoard = new int[3][3];

Accessing an element---to retrieve the current value of the element, or to assign a new value to the element---is done by providing each index value of the desired element.

gameBoard[0][0] = 1; System.out.println("value at row 1, column 2: " + gameBoard[1][2]);

In a two-dimensional array, one index corresponds to rows of the grid
and one index corresponds to columns of the grid. If the
first dimension of the array is rows, then we are using a
*row-major* interpretation. If the first dimension is
columns, then we are using a *column-major* interpretation.
Neither interpretation is correct or incorrect: instead, it is up
to you to decide which you prefer. The most common interpretation
is the row-major interpretation.

As an example, say that we declare and create a two-dimensional array as follows:

int[][] a = new int[2][5];

The following diagram illustrates the difference between the row-major and column-major interpretations: