Post on 19-Jan-2016
description
Arrays, part 2
Array applications
• Arrays are useful whenever a relatively large amount of data must be kept available in memory for processing
• We will look at several examples of array applications, and see how arrays can be used as arguments to methods and as method return values
Application 1: frequency counter
• A common programming problem involves counting the number of times particular values are found in a data set, or particular events occur while a program is running
• An array can be used as a frequency counter, keeping track of the frequency of occurrence of several events at a time
Example: are the dice fair?
• For our first example, consider the dice game craps:– The game involves rolling two six-sided dice– Both dice have a pattern of dots on each of
their sides; each has a side with 1, 2, 3, 4, 5 and 6 dots
– When the dice are rolled, whichever sides land up determine the score for the roll; for example, if the dice read 3 and 4, the player rolled a 7
Are the dice fair?
• The possible dice combinations are these (repeat combinations are not shown):
Determining fairness
• With fair dice, the most common roll should be 7, since there are more combinations (two each of 1-6, 2-5, and 3-4) that add up to 7 than any other combination
• We should see a 7 come up one-sixth of the time
• A Java program that plays craps would use a random number generator to simulate the roll of the dice
• We can use an array as a frequency counter to determine if the simulated dice are fair
Testing dice fairness
• First, we’ll write a method that produces a random number between 1 and 6
• To test the fairness of our method, we will call it from within a loop that runs several thousand times; each time we roll (by calling the method twice, once for each die), we will record the score by incrementing an index in a frequency-counting array
• When the loop is finished, we’ll examine the array to see how often we rolled a 7
Code for example 1import java.util.*;
public class DiceGame { private Random rg; // generates random # to represent roll
public DiceGame () { // initialize random number generator rg = new Random(); }
public int rollDice () { // return a number between 1 and 6 int cube = rg.nextInt(); cube = Math.abs(cube); cube = cube % 6 + 1; return cube; }
Code for example 1 public boolean testDice () { boolean fair = false; int [] diceCounter = new int [13]; for (int x=0; x<13; x++) diceCounter[x] = 0; int die1, die2; for (int y=0; y<100000; y++) { die1=rollDice(); die2=rollDice(); diceCounter[die1+die2]++; } System.out.println ("After rolling dice 100,000 times, we have:"); for (int z=2; z<13; z++) System.out.println (z + ":\t" + diceCounter[z]); if (diceCounter[7] >= (1.0/6.0)) fair = true; return fair; }
Code for example 1
public static void main (String [] args) { DiceGame dg = new DiceGame(); System.out.println ("Testing dice ..."); boolean areFair = dg.testDice(); if (areFair) System.out.println ("Dice are fair - we can play"); else System.out.println ("These dice are loaded!"); }}
Sample output from example 1Testing dice ...After rolling dice 100,000 times, we have:2: 28063: 55114: 83775: 110946: 139587: 165938: 138039: 1123010: 823011: 560312: 2795Dice are fair - we can play
Application 2: sorting algorithms
• Sorting is one of the most basic operations of computers; the need to sort data was one of the motivating factors for the invention of automatic computing machines
• We will take a brief look at a few of the many sorting algorithms that have been developed over the years, using an array of random integers as our data set
A testbed for sorting algorithms
• The next slide presents some of the methods of a class that is designed to test various sorting algorithms
• The class contains an array of random integers and the means to copy and print this array, as well as implementations of a few well-known sorting algorithms
Sorter class – private members, default constructor, utility methods
import java.util.*;
public class Sorter { private int [] numbers; private Random rg;
public Sorter () { numbers = new int [100]; rg = new Random(); for (int x = 0; x<100; x++) { int tmp = rg.nextInt(); tmp = Math.abs(tmp); tmp = tmp % 100 + 1; numbers[x] = tmp; } }
public int [] copyArray () { int [] sorted = new int [numbers.length]; for (int x=0; x < numbers.length; x++) sorted[x] = numbers[x]; return sorted; } public static void printArray (int [] array) { for (int x=0; x<array.length; x++) { if (x % 10 == 0) System.out.print("\n"); System.out.print (array[x] + "\t"); } }
Selectionsort• Goal of the algorithm is to sort a list of values (for
example, integers in an array) from smallest to largest
• The method employed comes directly from this statement of the problem– find smallest value and place at front of array– find next-smallest value and place in second position– find next-next-smallest and place in third position– and so on ...
Selectionsort
• The mechanics of the algorithm are simple: swap the smallest element with whatever is in the first position, then move to the second position and perform a similar swap, etc.
• In the process, a sorted subarray grows from the front, while the remaining unsorted subarray shrinks toward the back
Sorting an Array of IntegersSorting an Array of Integers
• The picture shows an array of six integers that we want to sort from smallest to largest
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6][0] [1] [2] [3] [4] [5]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• Start by finding the smallest entry.
• Swap the smallest entry with the first entry.
[0] [1] [2] [3] [4] [5]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• Part of the array is now sorted.
Sorted side Unsorted side
[0] [1] [2] [3] [4] [5]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• Find the smallest element in the unsorted side.
Sorted side Unsorted side
[0] [1] [2] [3] [4] [5]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• Swap with the front of the unsorted side.
Sorted side Unsorted side
[0] [1] [2] [3] [4] [5]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• We have increased the size of the sorted side by one element.
Sorted side Unsorted side
[0] [1] [2] [3] [4] [5]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• The process continues...
Sorted side Unsorted side
Smallestfrom
unsorted
Smallestfrom
unsorted
[0] [1] [2] [3] [4] [5]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• The process continues...
Sorted side Unsorted side
[0] [1] [2] [3] [4] [5]
Swap
with
front
Swap
with
front
The Selectionsort AlgorithmThe Selectionsort Algorithm
• The process continues...
Sorted side Unsorted sideSorted side
is bigger
Sorted sideis bigger
[0] [1] [2] [3] [4] [5]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• The process keeps adding one more number to the sorted side.
• The sorted side has the smallest numbers, arranged from small to large.
Sorted side Unsorted side
[0] [1] [2] [3] [4] [5]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• We can stop when the unsorted side has just one number, since that number must be the largest number.
[0] [1] [2] [3] [4] [5]
The Selectionsort AlgorithmThe Selectionsort Algorithm
• The array is now sorted.
• We repeatedly selected the smallest element, and moved this element to the front of the unsorted side. [0] [1] [2] [3] [4] [5]
Implementation of Selectionsortpublic void selectionSort () { int mindex, len, tmp; len = numbers.length; for (int x = 0; x <= len-2; x++) { mindex = x; for (int y = x+1; y <= len-1; y++) if (numbers[y] < numbers[mindex]) mindex = y; tmp = numbers[x]; numbers[x] = numbers[mindex]; numbers[mindex] = tmp; } }
Sample outputBefore sort:
59 20 51 38 65 75 36 91 4 6535 21 89 64 34 76 12 93 48 8232 71 99 90 13 26 76 47 44 8378 77 29 81 51 21 55 79 83 217 99 63 3 92 99 48 91 40 8714 77 53 4 62 19 15 20 55 466 71 86 37 86 56 76 54 19 3688 51 38 64 16 28 50 23 22 810 51 34 80 33 16 34 17 79 1666 64 60 66 9 7 19 61 62 28
After sort:
3 4 4 4 7 7 8 9 10 1213 14 15 16 16 16 17 19 19 1920 20 21 21 21 22 23 26 28 2829 32 33 34 34 34 35 36 36 3738 38 40 44 47 48 48 50 51 5151 51 53 54 55 55 56 59 60 6162 62 63 64 64 64 65 65 66 6666 71 71 75 76 76 76 77 77 7879 79 80 81 82 83 83 86 86 8788 89 90 91 91 92 93 99 99 99
Insertionsort• Although based on the same principle as
Selectionsort (sorting a portion of the array, adding one element at a time to the sorted portion), Insertionsort takes a slightly different approach
• Instead of selecting the smallest element from the unsorted side, Insertionsort simply takes the first element and inserts it in place on the sorted side so that the sorted side is always in order
Insertionsort algorithm
• Designate first element as sorted
• Take first element from unsorted side and insert in correct location on sorted side:– copy new element– shift elements from end of sorted side to the
right (as necessary) to make space for new element
Insertionsort algorithm
• Correct location for new element found when:– front of array is reached or– next element to shift is <= new element
• Continue process until last element has been put into place
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertionsort AlgorithmThe Insertionsort Algorithm
• The Insertionsort algorithm also views the array as having a sorted side and an unsorted side. [0] [1] [2] [3] [4] [5]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertionsort AlgorithmThe Insertionsort Algorithm
• The sorted side starts with just the first element, which is not necessarily the smallest element.
[0] [1] [2] [3] [4] [5]
Sorted side Unsorted side
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertionsort AlgorithmThe Insertionsort Algorithm
• The sorted side grows by taking the front element from the unsorted side...
[0] [1] [2] [3] [4] [5]
Sorted side Unsorted side
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertionsort AlgorithmThe Insertionsort Algorithm
• ...and inserting it in the place that keeps the sorted side arranged from small to large. [0] [1] [2] [3] [4] [5]
Sorted side Unsorted side
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertionsort AlgorithmThe Insertionsort Algorithm
• In this example, the new element goes in front of the element that was already in the sorted side. [0] [1] [2] [3] [4] [5]
Sorted side Unsorted side
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertionsort AlgorithmThe Insertionsort Algorithm
• Sometimes we are lucky and the new inserted item doesn't need to move at all. [0] [1] [2] [3] [4] [5]
Sorted side Unsorted side
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertionsort AlgorithmThe Insertionsort Algorithm
• Sometimes we are lucky twice in a row.
[0] [1] [2] [3] [4] [5]
Sorted side Unsorted side
Implementation of Insertionsort
public void insertionSort () { int x, y, tmp; for (x=1; x<numbers.length; x++) { tmp = numbers[x]; for (y=x; y>0 && numbers[y-1] > tmp; y--) numbers[y] = numbers[y-1]; numbers[y] = tmp; } }
Passing Arrays to Methods
• Arrays and objects are reference data types, so the rules for passing an object to a method and returning an object from a method apply to arrays.
• Consider an example method that returns the index of the smallest element in an array of real numbers
Passing Arrays to Methods
public int searchMinimum(double[] number) {
int indexOfMinimum = 0;
for (int i = 1; i < number.length; i++){ if (number[i] < number[indexOfMinimum]) { //found a smaller element
indexOfMinimum = i; }
}return indexOfMinimum;}
Passing Arrays to Methods
double[] arrayOne;//create and assign values to arrayOne...//get the index of the smallest element of arrayOneint minOne = searchMinimum(arrayOne);
//output the resultSystem.out.print(“Minimum value in Array One is ”);System.out.print(arrayOne[minOne] + “at position ” +
minOne);...
Passing Arrays to Methods
• Remember that when an array is passed to a method, only its reference is passed.
• A copy of the array is not created in the method.
Passing Arrays to Methods
• Next we will consider an example in which we return an array from a method.
• This method inputs double values and returns the values as an array of double.
Passing Arrays to Methodspublic double[] readDoubles() {
double[] number;int N = Integer.ParseInt(
JOptionPane.showInputDialog(null, “How many input values?”));
number = new double[N];
for (int i = 0; i<N; i++){number[i] = Double.parseDouble( JOptionPane.showInputDialog(null, “Number ” + i));
} return number;}
Passing Arrays to Methods
• The readDoubles method is called:double[] arrayOne;
//assign values to arrayOne
arrayOne = readDoubles();
• Because a new array is created by the method, we do not have to create an array from the calling side. Doing so will not cause an error, but it is a wasteful operation.
The effect of creating a local array and not returning it
The effect of creating a local array and not returning it
The effect of creating a local array and not returning it
The effect of creating a local array and not returning it
Two-Dimensional Arrays
• In Java, data may be organized in a two-dimensional array.
• A table is an example of a two-dimensional array.
• In a two-dimensional array, two indices (in a table, one for the row and one for the column) are used to refer to the array element.
Two-Dimensional Arrays
• To declare our example array, we state:double[][] payScaleTable;
or double payScaleTable[][];
and create the array aspayScaleTable = new double[4][5];
Examples of information represented as tables.
Two-Dimensional Arrays
• To refer to an element at the second column (column 1) of the third row (row 2), we say
payScaleTable[2][1]
• Nested-for loops are useful for manipulating two-dimensional arrays.
Accessing an element of a two-dimensional array
Two-Dimensional Arrays
• The concept of the two-dimensional array in Java is just that: a concept. There is no explicit structure called the “two-dimensional array” in Java.
• The two-dimensional array concept is implemented by using an array of arrays.
Two-Dimensional Arrays
• The sample array creationpayScaleTable = new double[4][5];
is a shorthand forpayScaleTable = new double [4][ ];
payScaleTable[0] = new double [5];
payScaleTable[1] = new double [5];
payScaleTable[2] = new double [5];
and so on.
Statements on the left in sequence create array of arrays on the right
Continued from previous slide
Two-Dimensional Arrays
• The expressionpayScaleTable.length
refers to the length of the array itself.
Two-Dimensional Arrays
• The expressionpayScaleTable[1].length
refers to the length of the array stored at row 1 of payScaleTable.
Two-Dimensional Arrays
• An array that is part of another array is called a subarray.
• An array of arrays may be initialized when it is created.
Two-Dimensional Arrays• Subarrays may be different lengths.
• Executing this code:triangularArray = new double[4][ ];
for (int i = 0; i < 4; i++)
triangularArray[i] = new double [i + 1];
results in an array that looks like: