Chapter 7 Arrays. © 2004 Pearson Addison-Wesley. All rights reserved11-2 Arrays Arrays are objects that help us organize large amounts of information

Chapter 7

Arrays

© 2004 Pearson Addison-Wesley. All rights reserved 11-2

Arrays

• Arrays are objects that help us organize large amounts of information

• Chapter 7 focuses on:

array declaration and use bounds checking and capacity arrays that store object references multidimensional arrays variable length parameter lists


Outline

Declaring and Using Arrays

Arrays of Objects

Two-Dimensional Arrays

Variable Length Parameter Lists



• A one-dimensional array stores a list of elements

• A two-dimensional array can be thought of as a table of elements, with rows and columns

onedimension

twodimensions



• To be precise, in Java a two-dimensional array is an array of arrays

• A two-dimensional array is declared by specifying the size of each dimension separately:

int[][] scores = new int[12][50];

• A array element is referenced using two index values:

value = scores[3][6]

• The array stored in one row can be specified using one index


2D Array in Memory

…

[0]

[1]

[pop.length-1]

692134 655615 621077 492428

[0] [1] [2] [3]

187328 118572 61911 36152

[0] [1] [2] [3]


Two-Dimensional ArraysExpression Type Description

table int[][] 2D array of integers, or

array of integer arrays

table[5] int[] array of integers

table[5][12] int integer

• From TwoDArray.java (page 399)

int[][] table = new int[5][10];

// Load the table with values for (int row=0; row < table.length; row++) for (int col=0; col < table[row].length; col++) table[row][col] = row * 10 + col;

// Print the table for (int row=0; row < table.length; row++) { for (int col=0; col < table[row].length; col++) System.out.print (table[row][col] + "\t"); System.out.println(); }


SodaSurvey.java //---------------------------------------------------------- // Determines and prints the average of each row (soda) and // each column (respondent) of the survey scores. //---------------------------------------------------------- public static void main (String[] args) { int[][] scores = { {3, 4, 5, 2, 1, 4, 3, 2, 4, 4}, {2, 4, 3, 4, 3, 3, 2, 1, 2, 2}, {3, 5, 4, 5, 5, 3, 2, 5, 5, 5}, {1, 1, 1, 3, 1, 2, 1, 3, 2, 4} };

final int SODAS = scores.length; final int PEOPLE = scores[0].length;

int[] sodaSum = new int[SODAS]; int[] personSum = new int[PEOPLE];

for (int soda=0; soda < SODAS; soda++) for (int person=0; person < PEOPLE; person++) { sodaSum[soda] += scores[soda][person]; personSum[person] += scores[soda][person]; }


SodaSurvey.java DecimalFormat fmt = new DecimalFormat ("0.#"); System.out.println ("Averages:\n");

for (int soda=0; soda < SODAS; soda++) System.out.println ("Soda #" + (soda+1) + ": " + fmt.format ((float)sodaSum[soda]/PEOPLE));

System.out.println (); for (int person =0; person < PEOPLE; person++) System.out.println ("Person #" + (person+1) + ": " + fmt.format ((float)personSum[person]/SODAS)); }}


Multidimensional Arrays

• An array can have many dimensions – if it has more than one dimension, it is called a multidimensional array

• Each dimension subdivides the previous one into the specified number of elements

• Each dimension has its own length constant

• Because each dimension is an array of array references, the arrays within one dimension can be of different lengths

these are sometimes called ragged arrays


Exercise 1

• Write a code fragment that calculates the product of all the entries on the main diagonal of a square array of doubles called numbers.


Exercise 2

• Write a code fragment that calculates the product of all the entries on the skew diagonal of a square array of doubles called numbers (the skew diagonal is the one from the lower left corner to the upper right corner).

(0,3)(1,2)(2,1)(3,0)


Exercise 3

• Write a code fragment that copies the lower right quarter of a 20 by 10 int array called arr into an array called copy. You may assume that arr has already been declared and initialized, but write the statements that declare and initialize copy. copy should be a 10 by 5 array.

arrcopy


Exercise 3

arrcopy


Outline

Declaring and Using Arrays

Arrays of Objects





• Suppose we wanted to create a method that processed a different amount of data from one invocation to the next

• For example, let's define a method called average that returns the average of a set of integer parameters

// one call to average three valuesmean1 = average (42, 69, 37);

// another call to average seven valuesmean2 = average (35, 43, 93, 23, 40, 21, 75);



• We could define overloaded versions of the average method

Downside: we'd need a separate version of the method for each parameter count

• We could define the method to accept an array of integers

Downside: we'd have to create the array and store the integers prior to calling the method each time

• Instead, Java provides a convenient way to create variable length parameter lists



• Using special syntax in the formal parameter list, we can define a method to accept any number of parameters of the same type

• For each call, the parameters are automatically put into an array for easy processing in the method

public double average (int ... list){ // whatever} element

typearrayname

Indicates a variable length parameter list


Summary

• Chapter 7 has focused on:

array declaration and use bounds checking and capacity arrays that store object references variable length parameter lists multidimensional arrays

Chapter 11

Recursion


Recursion

• Recursion is a fundamental programming technique that can provide an elegant solution certain kinds of problems

• Chapter 11 focuses on:

thinking in a recursive manner programming in a recursive manner the correct use of recursion recursion examples


Outline

Recursive Thinking

Recursive Programming

Using Recursion


Recursive Thinking

• A recursive definition is one which uses the word or concept being defined in the definition itself

• When defining an English word, a recursive definition is often not helpful

• But in other situations, a recursive definition can be an appropriate way to express a concept

• Before applying recursion to programming, it is best to practice thinking recursively


Recursive Definitions

• Consider the following list of numbers:

24, 88, 40, 37

• Such a list can be defined as follows:

A LIST is a: number or a: number comma LIST

• That is, a LIST is defined to be a single number, or a number followed by a comma followed by a LIST

• The concept of a LIST is used to define itself



• The recursive part of the LIST definition is used several times, terminating with the non-recursive part:

number comma LIST 24 , 88, 40, 37

number comma LIST 88 , 40, 37

number comma LIST 40 , 37

number 37


Infinite Recursion

• All recursive definitions have to have a non-recursive part

• If they didn't, there would be no way to terminate the recursive path

• Such a definition would cause infinite recursion

• This problem is similar to an infinite loop, but the non-terminating "loop" is part of the definition itself

• The non-recursive part is often called the base case



• N!, for any positive integer N, is defined to be the product of all integers between 1 and N inclusive

• This definition can be expressed recursively as:

1! = 1

N! = N * (N-1)!

• A factorial is defined in terms of another factorial

• Eventually, the base case of 1! is reached



5!

5 * 4!

4 * 3!

3 * 2!

2 * 1!

1

2

6

24

120


Outline

Recursive Thinking


Using Recursion



• A method in Java can invoke itself; if set up that way, it is called a recursive method

• The code of a recursive method must be structured to handle both the base case and the recursive case

• Each call to the method sets up a new execution environment, with new parameters and local variables

• As with any method call, when the method completes, control returns to the method that invoked it (which may be an earlier invocation of itself)



• Consider the problem of computing the sum of all the numbers between 1 and any positive integer N

• This problem can be recursively defined as:

3

1

2

1

1

11

21

1

N

i

N

i

N

i

N

i

iNNN

iNNiNi



// This method returns the sum of 1 to num

public int sum (int num)

{

int result;

if (num == 1)

result = 1;

else

result = num + sum (n-1);

return result;

}



main

sum

sum

sum

sum(3)

sum(1)

sum(2)

result = 1

result = 3

result = 6

public int sum (int num){ int result;

if (num == 1) result = 1; else result = num + sum (n-1);

return result;}



• Note that just because we can use recursion to solve a problem, doesn't mean we should

• For instance, we usually would not use recursion to solve the sum of 1 to N problem, because the iterative version is easier to understand

• However, for some problems, recursion provides an elegant solution, often cleaner than an iterative version

• You must carefully decide whether recursion is the correct technique for any problem


Indirect Recursion

• A method invoking itself is considered to be direct recursion

• A method could invoke another method, which invokes another, etc., until eventually the original method is invoked again

• For example, method m1 could invoke m2, which invokes m3, which in turn invokes m1 again

• This is called indirect recursion, and requires all the same care as direct recursion

• It is often more difficult to trace and debug


Indirect Recursion

m1 m2 m3

m1 m2 m3

m1 m2 m3


Outline

Recursive Thinking


Using Recursion


Maze Traversal

• We can use recursion to find a path through a maze

• From each location, we can search in each direction

• Recursion keeps track of the path through the maze

• The base case is an invalid move or reaching the final destination

• See MazeSearch.java (page 583)• See Maze.java (page 584)

C:\Documents and Settings\dlawrie\Local Settings\Temp\Temporary Directory 1 for 17308-0321278631_ppt.zip\L\examples\chap11\MazeSearch.java

C:\Documents and Settings\dlawrie\Local Settings\Temp\Temporary Directory 1 for 17308-0321278631_ppt.zip\L\examples\chap11\Maze.java


Maze.java//*************************************************************// Maze.java Author: Lewis/Loftus//// Represents a maze of characters. The goal is to get from// the top left corner to the bottom right, following a path// of 1s.//*************************************************************

public class Maze{ private final int TRIED = 3; private final int PATH = 7;

private int[][] grid = { {1,1,1,0,1,1,0,0,0,1,1,1,1}, {1,0,1,1,1,0,1,1,1,1,0,0,1}, {0,0,0,0,1,0,1,0,1,0,1,0,0}, {1,1,1,0,1,1,1,0,1,0,1,1,1}, {1,0,1,0,0,0,0,1,1,1,0,0,1}, {1,0,1,1,1,1,1,1,0,1,1,1,1}, {1,0,0,0,0,0,0,0,0,0,0,0,0}, {1,1,1,1,1,1,1,1,1,1,1,1,1} };


Maze.java //---------------------------------------------------------- // Attempts to recursively traverse the maze. Inserts // special characters indicating locations that have been // tried and that eventually become part of the solution. //---------------------------------------------------------- public boolean traverse (int row, int column) { boolean done = false; if (valid (row, column)) { grid[row][column] = TRIED; // this cell has been tried

if (row == grid.length-1 && column == grid[0].length-1) done = true; // the maze is solved else {


Maze.java done = traverse (row+1, column); // down if (!done) done = traverse (row, column+1); // right if (!done) done = traverse (row-1, column); // up if (!done) done = traverse (row, column-1); // left }

if (done) // this location is part of the final path grid[row][column] = PATH; } return done; }


Maze.java //------------------------------------------------------------ // Determines if a specific location is valid. //------------------------------------------------------------ private boolean valid (int row, int column) { boolean result = false; // check if cell is in the bounds of the matrix if (row >= 0 && row < grid.length && column >= 0 && column < grid[row].length)

// check if cell is not blocked and not previously // tried if (grid[row][column] == 1) result = true;

return result; }


Maze.java //------------------------------------------------------------ // Returns the maze as a string. //------------------------------------------------------------ public String toString () { String result = "\n";

for (int row=0; row < grid.length; row++) { for (int column=0; column < grid[row].length; column++) result += grid[row][column] + ""; result += "\n"; }

return result; }}


MazeSearch.javapublic class MazeSearch{ //---------------------------------------------------------- // Creates a new maze, prints its original form, attempts // to solve it, and prints out its final form. //---------------------------------------------------------- public static void main (String[] args) { Maze labyrinth = new Maze(); System.out.println (labyrinth);

if (labyrinth.traverse (0, 0)) System.out.println ("The maze was successfully traversed!"); else System.out.println ("There is no possible path.");

System.out.println (labyrinth); }}


Output

11101100011111011101111001000010101010011101110101111010000111001101111110111110000000000001111111111111

The maze was successfully traversed!

77701100011113077707771001000070707030077707770703337070000773003707777770333370000000000007777777777777

7 7 7

3 7 7 7 7 7 7

7 7 7 3

7 7 7 7 7 7 7 3 3 3

7 7 7 7 3 3

7 7 7 7 7 7 7 3 3 3 3

7

7 7 7 7 7 7 7 7 7 7 7 7 7


Towers of Hanoi

• The Towers of Hanoi is a puzzle made up of three vertical pegs and several disks that slide on the pegs

• The disks are of varying size, initially placed on one peg with the largest disk on the bottom with increasingly smaller ones on top

• The goal is to move all of the disks from one peg to another under the following rules:

We can move only one disk at a time

We cannot move a larger disk on top of a smaller one


Towers of Hanoi

Original Configuration Move 1

Move 3Move 2


Towers of Hanoi

Move 4 Move 5

Move 6 Move 7 (done)


Towers of Hanoi

• An iterative solution to the Towers of Hanoi is quite complex

• A recursive solution is much shorter and more elegant

• See SolveTowers.java (page 590) • See TowersOfHanoi.java (page 591)

C:\Documents and Settings\dlawrie\Local Settings\Temp\Temporary Directory 1 for 17308-0321278631_ppt.zip\L\examples\chap11\SolveTowers.java

C:\Documents and Settings\dlawrie\Local Settings\Temp\Temporary Directory 1 for 17308-0321278631_ppt.zip\L\examples\chap11\TowersOfHanoi.java


TowersOfHanoi.javapublic class TowersOfHanoi{ private int totalDisks;

//---------------------------------------------------------- // Sets up the puzzle with the specified number of disks. //---------------------------------------------------------- public TowersOfHanoi (int disks) { totalDisks = disks; }

//---------------------------------------------------------- // Performs the initial call to moveTower to solve the // puzzle. Moves the disks from tower 1 to tower 3 using // tower 2. //---------------------------------------------------------- public void solve () { moveTower (totalDisks, 1, 3, 2); }


TowersOfHanoi.java //---------------------------------------------------------- // Moves the specified number of disks from one tower to // another by moving a subtower of n-1 disks out of the // way, moving one disk, then moving the subtower back. // Base case of 1 disk. //---------------------------------------------------------- private void moveTower (int numDisks, int start, int end, int temp) { if (numDisks == 1) moveOneDisk (start, end); else { moveTower (numDisks-1, start, temp, end); moveOneDisk (start, end); moveTower (numDisks-1, temp, end, start); } }


TowersOfHanoi.java //---------------------------------------------------------- // Prints instructions to move one disk from the specified // start tower to the specified end tower. //---------------------------------------------------------- private void moveOneDisk (int start, int end) { System.out.println ("Move one disk from " + start + " to " + end); }}

public class SolveTowers{ //---------------------------------------------------------- // Creates a TowersOfHanoi puzzle and solves it. //---------------------------------------------------------- public static void main (String[] args) { TowersOfHanoi towers = new TowersOfHanoi (4);

towers.solve(); }}


Summary

• Chapter 11 has focused on:

thinking in a recursive manner programming in a recursive manner the correct use of recursion recursion examples