Arrays

An array is a data object that can hold multiple

objects, all of the same type. We can think of an

array as a storage box which has multiple

compartments. The compartments are numbered

(starting at 0) so that we can indicate which

compartment we are referring to.

Creating an Array

The notation for an an array of a given type is:

<type>[]

For example, an array of ints is denoted by:

int[]

Naming Arrays

Just like other types, we can associate a name with a

data object by assigning it a label – a variable:

int[] grades;

This declares grades to be of type array of int. But

it does not create the array.

Creating an array

To actually create the array, we must use the new

operator, and specify the size of the array:

int[] grades = new int[100];

This creates a new data object, which can hold 100

ints (numbered from 0 to 99) and sets the variable

grades to refer to that new data object.

Using Arrays

In mathematics, we have a notion of a vector, which

is variable that holds a number of elements, e.g.

x = {1, 7, 10, 20, 2, 9}

An element is referred to by a subscript, e.g., x1

would be 1, x2 would be 7, and so forth. The

variable is read “x sub 1” and “x sub 2.”

Java Arrays

In Java, we do the same thing, but the notation is

different:

x[i]

is still read “x sub i” and means the ith element of the

array x. Not that in Java, arrays begin at 0, not 1.

Using Subscripts

The value inside the square bracket can be a

constant, a variable, or an expression, but must be

an int. The point is that we can vary the

expression in the brackets, so that x[i] can refer

to different values, depending on the value of i.

for(int i=0; i<100; i++) // read in 100 ints into grades grades[i] = sc.nextInt();

Example

Arrays are useful for storing lists of data. For

example, suppose that we wanted to calculate the

standard deviation of a set of test grades. The

formula is:

standard deviation =

where x is the average of x.√∑ i=1

N(x i− x̄)2 / N√∑ i=1

N(x i− x̄)2 / N

Example (cont'd)

We would have to read in and store the grades, and

compute the average first:int[] grades = new int[100];int total = 0, num = 0;int grade = sc.nextInt();while(grade >= 0) { total += grade; grades[num++] = grade; grade = sc.nextInt();}double ave = (double)total/(double)num;

Example (cont'd)

We would then have a second loop to compute the

standard deviation. This loop can be a count-

controlled loop:

double total2 = 0;for(int i=0; i<num; i++) total2 = (grades[i] – average)* (grades[i] - average);double sd = Math.sqrt(total2/num);

Finding the Minimum

We could also write a loop to find the minimum

grade. (We've already done this once – this is to

practice using arrays and loops.)

int min = grades[0];for(int i=1; i<num; i++) if(grades[i] < min) min = grades[i];

Sorting Arrays

Note that we can use this to sort the array, i.e., put it

in order from smallest to largest grade. We could

find the smallest grade, and switch it with the first

grade, find the next smallest grade, and switch it

with the second grade, and so on.

Note that it's not enough to find the smallest grade.

We must find the position of the smallest grade in

the array.

Finding the Position of the Min

All we need to do is to remember the position of the

minimum – originally 0, and then i, if a smaller

grade is found. We must access the array to find

the minimum grade in the comparison:

int minpos = 0;for(int i=1; i<num; i++) if(grades[i] < grades[minpos]; minpos = i;

Swapping

Once we find the position of the minimum grade, we

can swap that grade with the grade at position 0.

The code to swap a and b is:

int t = a; a = b; b = t;

Swap Method

We can write a method that swaps two elements of

an array:

private void swap(int[] a, int i, int j) {

int t = a[i]; a[i] = a[j]; a[j] = t; }

Arrays are Data Objects

It is important to note that arrays are data objects,

and array variables are object variables. Hence,

array variables contain a reference to the data

object, and not the data object themselves. When

we use assignment on arrays, the reference is

copied, and the two variables will point to the same

data object. Similarly, when calling a method, the

parameter and object refer to the same data object.

Sort (cont'd)

After we find the position of the minimum grade, we

can use the method to swap it with the element at

position 0:

int minpos = 0;for(int i=1; i<num; i++) if(grades[i] < grades[minpos]; minpos = i;swap(grades, 0, minpos);

Sort (cont'd)

This only puts the smallest grade in place. For the

other grades, we will need another loop:for(int j=0; j<num; j++) { int minpos = j; for(int i=minpos+1; i<num; i++) if(grades[i] < grades[minpos]; minpos = i; swap(grades, j, minpos);}

Selection Sort

Note that minpos should start at j, and the inner

loop begins at minpos+1 to find the smallest

grade.

Also, we note that if all but the last grades are in

their right place, then the last grade must be also.

So, in the outer loop, the test could be j < num-1.

This sort is called Selection Sort, because we select

the smallest element and put it into the right place.

Bubble Sort

Another kind of sort “bubbles” the largest element up

to the right place, by comparing each element to

the one following it and swapping them if they are

in the wrong order. Each pass guarantees that the

largest will be forced to the end. After num passes

(actually num-1) all the elements will be in the

right places.

Bubble Sort (cont'd)

Here's the code to move the largest to the end:

for(j=0; j<num-1; j++) if(grades[j] > grades[j+1])

swap(grades, j, j+1)

Note that the index j only goes up to num-2, since

then j+1 will be num-1, the last element in the

array.

Bubble Sort (cont'd)

Again, we must do this num times (actually, num-1

times, since if all the elements but the last are in

the right place, the last one must be too). After

each pass, the next largest element is in the right

place at the end of the array, so we don't have to

go as far each time, i.e., the inner loop can end one

earlier.

Bubble Sort (cont'd)

for(int i=0; i<num-1; i++) for(j=0; j<num-1-i; j++) if(grades[j] > grades[j+1])

swap(grades, j, j+1)

Improved Bubblesort

We can improve upon the naive bubblesort by

checking if we do any swapping at all. If no swaps

are done, then the array is in order and we can stop

(after a pass that verifies that no swaps are done)

Advanced Bubblesort

for(int i = 0; i < num-1; i++) { boolean swapped = false; for(int j = 0; j < num-1-i; j++) { if(grades[j] > grades[j+1]) { swap(grades, j, j+1); swapped = true; } } if(!swapped) break;

}

Insertion Sort

Another sort that is commonly used to sort cards is as

follows: Suppose that we have a hand of cards that

is already in order. We can add a card by

comparing the card to the last card in our hand, and

if the last card is bigger, slide it to the right a bit,

and then look at the next-to-last card. Slide it over

if it's bigger. We stop when we come to a card

that's smaller, or we run out of cards. We insert the

new card in the empty slot.

Insertion Sort

To insert one card, t, into a hand that is already in

order, a[0..i-1], we do:while(i > 0 && a[i-1] > t) { a[i] = a[i-1];// slide one card over i--; // move to the next card }a[i] = t; // insert t

Note that we have to check we haven't run out of

cards (i > 0) before we compare the last card to t.

Insertion Sort (cont'd)

To sort the whole hand, we need another loop to

insert all the cards:for(int j=1; j<num-1; j++) { int t = a[j], i = j; while(i > 0 && a[i-i] > t) { a[i] = a[i-1]; i--; } a[i] = t; }