+ All Categories
Home > Documents > Arrays of Arrays

Arrays of Arrays

Date post: 03-Jan-2016
Category:
Upload: jorden-kent
View: 64 times
Download: 4 times
Share this document with a friend
Description:
Arrays of Arrays. An array can represent a collection of any type of object - including other arrays! The world is filled with examples Monthly magazine: we number the monthly editions pages with in each Calendars: we number the months days in each month. General Two-Dimensional Arrays. - PowerPoint PPT Presentation
Popular Tags:
54
1 Arrays of Arrays An array can represent a collection of any type of object - including other arrays! The world is filled with examples Monthly magazine: we number the monthly editions pages with in each Calendars: we number the months days in each month
Transcript
Page 1: Arrays of Arrays

1

Arrays of Arrays

An array can represent a collection of any type of object - including other arrays!

The world is filled with examples• Monthly magazine: we number

– the monthly editions

– pages with in each

• Calendars: we number– the months

– days in each month

Page 2: Arrays of Arrays

2

General Two-Dimensional Arrays

Say we want to develop an annual calendar manager

Representing the Data

• A month is an array of strings that represent daily events

• A year is a 12- element array of months.

Page 3: Arrays of Arrays

3

Declaring an Array of Arrays

• A month is an array of daily event Strings• A year is an array of months

So a year is an array of String arrays

private String[ ] [ ] dailyEvent;

Page 4: Arrays of Arrays

4

Creating an Array of Arrays

Array declaration introduces a name, but does not create an array

Proceed in two steps

1. Construct 12- element year

2. Construct each individual month array

Page 5: Arrays of Arrays

5

1. Construct 12- element year

dailyEvent = new String[12] [ ]

Page 6: Arrays of Arrays

6

1. m

2. Construct months

for (int month = 0; month < 12; month++) {int numDays = getDays( month+1 );dailyEvent[month] = new String[numDays];

}

Assume getDays is a private method that returns the number of days in a month

Page 7: Arrays of Arrays

7

Page 8: Arrays of Arrays

8

Indexing an Array of Arrays

Say a user enters the information

1/28- Spring semester starts

The month is 1

The day is 28

The event is “Spring semester starts”Since array indexing begins at 0,

dailyEvent[0][27] = “Spring semester starts”;

Page 9: Arrays of Arrays

9

Page 10: Arrays of Arrays

10

Setting and Getting Array Values

// Set the event description for a given month and daypublic void setEvent( int month, int day, String description ) {

dailyEvent[month-1][day-1] = description;}

// Returns the event associated with a given datepublic String getEvent( int month, int day ) {

return dailyEvent[month-1][day-1];}

Page 11: Arrays of Arrays

11

Arrays of Arrays are two dimensional

When you think of an array of arrays in this way, it is natural to think of indices as specifying row and column

someArray[rowNum][colNum]

QuickTime™ and aNone decompressor

are needed to see this picture.

Page 12: Arrays of Arrays

12

Traversing a 2-D ArrayOften want to do something with every element in an array- Use for loops!

• Ex. Initialize all calendar entries to “No event today”– to initialize all calendar entries for a single month:

for ( int day = 0; day < dailyEvent[month].length; day++) {dailyEvent[month][day] = “No event today”;

}

– to initialize all 12 months

// Fill all entries in each month with “No event today”for (int month = 0; month < 12; month++) {

// Fill all entries for one month with “No event today”...

}

Page 13: Arrays of Arrays

13

Putting it all Together

// Fill all entries in each month with “No event today”for (int month = 0; month < 12; month++) {

// Fill all entries for one month with “No event today”for (int day = 0; day < dailyEvent[month].length; day++) {

dailyEvent[month][day] = “No event today”;}

}

Page 14: Arrays of Arrays

14

General Structure of Nested for Loops for 2- D Arrays

for (row = 0; row < myArray.length; row++) {for (col = 0; col < myArray[row].length; col++) {

// Do something with array element myArray[row][col]...

}}

Page 15: Arrays of Arrays

15

Beyond Two Dimensions

• so far our yearly calendar is quite limited• might want a day’s entries to include

– daily events– hourly events

Page 16: Arrays of Arrays

16

A CalendarDay Class

Two arrays• full- day events• hourly events

private String[ ] fullDayEvent;private String[ ] hourlyEvent;

A year is then just an array of months, each of which is an array of CalendarDay, each of which is two arrays

Page 17: Arrays of Arrays

17

• YearlyCalendar.rtf• CalendarDay.rtf

Page 18: Arrays of Arrays

18

Exercises: Add the Following to CalendarDay

// Clear all event entries for this day// All event entries are set to “–––”public void clearDay()

// Return the event for a specific hour on this daypublic String getHourlyEvent( int time )// Print all hourly events;

// Each hourly event on a separate line in the form// hour: 00 eventpublic void printHourlyEvents()

// Print all full day eventspublic void printFullDayEvents()

// Print all events for this daypublic void printDay()

Page 19: Arrays of Arrays

19

Matrices

• two dimensional arrays with rows of same length

Ex. magnified region of pixels from an image

Each pixel can be described by row and column position, as well as color value

Page 20: Arrays of Arrays

20

More examples• chessboards• sliding block puzzles

Page 21: Arrays of Arrays

21

Magic Square

• a matrix in which the sums of rows, columns, and diagonals are all equal

Page 22: Arrays of Arrays

22

Declaring and Constructing a Matrix

• Matrices are simply 2-D arrays, so a matrix is declared in the same way

private int[ ][ ] magicSquare;

• Matrix must be constucted before it is filled

magicSquare = new int[SIZE][SIZE];• n- row, m- column matrix constructed as follows

rectangularArray = new type[n][m];

Page 23: Arrays of Arrays

23

Traversing a MatrixEx. Determine whether a square matrix is a magic

square• Row, column, and diagonal sums must be equal.• Start by finding target sum

// Compute sum of elements in row 0int targetSum = 0;for (int col = 0; col < SIZE; col++) {

targetSum = targetSum + magicSquare[0][col];}

Page 24: Arrays of Arrays

24

Row by Row Traversal• check sum of each row

• use nested for loops!

// Assume we have a magic square unless a sum is incorrectboolean isMagicSquare = true;for (int row = 1; row < SIZE; row++) {

// Check sum of each rowint sum = 0;for (col = 0; col < SIZE; col++) {

sum = sum + magicSquare[row][col];}if (sum !=targetSum) {

isMagicSquare = false;}

}

Page 25: Arrays of Arrays

25

A More Efficient Version

• If any row’s sum does not match target, can stop right away

// Assume we have a magic square unless a sum is incorectboolean isMagicSquare = true;for (int row = 1; row < SIZE && isMagicSquare; row++) {

// Check sum of each rowint sum = 0;for (col = 0; col < SIZE; col++) {

sum = sum + magicSquare[row][col];}if (sum !=targetSum) [

isMagicSquare = false;}

}

Page 26: Arrays of Arrays

26

Column by Column• nested loops again• reverse order of nesting

– outer loop through columns

– inner loop through rows

// Assume we have a magic square unless a sum is incorrectboolean isMagicSquare = true;for (int col =0; col < SIZE && isMagicSquare; col++) {

// Check sum of each columnint sum = 0;for (row = 0; row < SIZE; row++) {

sum = sum + magicSquare[row][col];}isMagicSquare = (sum == targetSum);}

Page 27: Arrays of Arrays

27

Diagonal Traversal

• two diagonals- two loops• no nested loops this time

//Check sum of major diagonalint sum = 0;for (int element = 0; element < SIZE; element++) {

sum = sum + magicSquare[element][element];}isMagicSquare = (sum == targetSum);

Page 28: Arrays of Arrays

28

Minor Diagonal

• a bit more tricky to get indices right• for a 4x4 matrix:

– [0][3], [1][2], [2][1], [3][0]– if loop var is row (over 0,1,2,3), associated column is (SIZE-1)-row

// Check sum of minor diagonalint sum = 0;for (int row = 0; row < SIZE; row++) {

sum = sum + magicSquare[row][SIZE-1-row];}isMagicSquare = (sum == targetSum);

Page 29: Arrays of Arrays

29

Array Indexing

• Now let’s fill a magic square

• Through this we’ll explore more complex ways to “walk through” matrices

Page 30: Arrays of Arrays

30

Filling a Magic Square

For an n-by-n matrix, if n is odd, a simple algorithm will fill it appropriately

• place a 1 in the center of the bottom row. Then fill in the remainder of the square by following these rules:

• Try to place the next integer (one greater than the last one you placed) in the cell one slot below and to the right of the last one placed. If you fall off the bottom of the array, go to the top row of the same column. If you fall off the right edge of the array, go to the leftmost column. If that cell is empty, write the next integer there and continue. If the cell is full, go back to where you wrote the last integer and write the next one in the cell directly above it.

Page 31: Arrays of Arrays

31

1

Page 32: Arrays of Arrays

32

2

1

Page 33: Arrays of Arrays

33

2

3

1

Page 34: Arrays of Arrays

34

4 2

3

1

Page 35: Arrays of Arrays

35

4 2

3 5

1

Page 36: Arrays of Arrays

36

4 2

3 5

1

6

Page 37: Arrays of Arrays

37

4 2

3 5 7

1 6

Page 38: Arrays of Arrays

38

4 2

3 5 7

8 1 6

Page 39: Arrays of Arrays

39

4 9 2

3 5 7

8 1 6

Page 40: Arrays of Arrays

40

Initializing Matrix Entries to a Value

Begin by initializing each cell in a matrix to 0

// Initialize all entries in the square to 0for (int row = 0; row < SIZE; row++) {

for (int col = 0; col < SIZE; col++) {magicSquare[row][col] = 0;

}}

Page 41: Arrays of Arrays

41

Filling the Magic Square

• Declare and initialize variables to keep track of current row and column

int currRow = SIZE-1;int currCol = SIZE/2;

• Assuming SIZE is odd!

Page 42: Arrays of Arrays

42

Follow the Rules

• will follow the rules for filling a magic square• apply to the rules until the square is filled

(SIZExSIZE times)

for (int nextInt = 1; nextInt <= SIZE*SIZE; nextInt++) {// fill a cell

}

Page 43: Arrays of Arrays

43

In the Loop

• Fill the current cell

magicSquare[currRow][currCol] = nextInt;

• Find the next cell to fill

Page 44: Arrays of Arrays

44

Finding the Next Cell

Move down and to the right

int nextCol = currCol + 1;int nextRow = currRow + 1;

Might “fall off” the matrix!

Need to wrap around

int nextCol = (currCol + 1) % SIZE;int nextRow = (currRow + 1) % SIZE;

Page 45: Arrays of Arrays

45

Adjusting if a Cell is Full

If a cell is already filled, go back to previous cell and move up

if (magicSquare[nextRow][nextCol] == 0) {

// Use the cell if it is available

currRow = nextRow;

currCol = nextCol;

} else { // Move up one cell otherwise

currRow = (currRow - 1 + SIZE) % SIZE;

}

Page 46: Arrays of Arrays

46

Putting it all Together

• Figure 15.5 (A method to fill a magic square)

Page 47: Arrays of Arrays

47

More Practice with Matrices:Digital Image Smoothing

• A digital photo is a matrix of pixel values• Noise and other artifacts sometimes appear• can smooth an image to eliminate (or

decrease) some of these artifacts

Page 48: Arrays of Arrays

48

A Simple Smoothing Algorithm

• Assume image is black and white– pixel values are ints giving brightness levels

private int[ ][ ] brightness;

• Implement smoothing by averaging– replace each pixel value with the average of its

neighbors

Page 49: Arrays of Arrays

49

Design of Smoothing Algorithm

• Assume constants WIDTH and HEIGHT give image width and height in pixels

• Declare a matrix for the averaged (smoothed) image

private int[ ][ ] avgBrightness;

• Traverse row by rowfor (int row = 1; row < HEIGHT-1; row++) {

for (int col = 1; col < WIDTH-1; col++)// replace brightness value by average value...

}}

Page 50: Arrays of Arrays

50

Calculating Average Brightness

Consider a 3-by-3 square centered at the pixel to be replaced by an average

// Calculate average brightness at position specified by row and col;// position is not on an edge of the image.int totalBrightness = 0;for (int r = -1; r <= 1; r++) {

for (int c = -1; c <= 1; c++) {totalBrightness = totalBrightness + brightness[row+r][col+c];

}avgBrightness[row][col] = totalBrightness/9;

}

Page 51: Arrays of Arrays

51

Pixels on the Edge

What about pixels on the edges of an image?– pixels on top edge have no neighbors above them;

only to the sides and below.– pixels on bottom have no neighbors below them;

only to the sides and above.– pixels in the corners have even fewer neighbors.

Page 52: Arrays of Arrays

52

// Calculate average brightness at position specified by row and col;// position is top edge of the image, not in a cornerint totalBrightness = 0;for (int r = 0; r <=1; r++) {

for (int c = -1; c <= 1; c++) {totalBrightness = totalBrightness + brightness[row+r][col+c];

}avgBrightness[row][col] = totalBrightness/6;

}

Handling the Top Edge

Page 53: Arrays of Arrays

53

Handling the Bottom Edge

// Calculate average brightness at position specified by row and col;// position is bottom edge of the image, not in a cornerint totalBrightness = 0for (int r = -1; r <= 0; r++) {

for (int c = -1; c <= 1; c++) {totalBrightness = totalBrightness + brightness[row+r][col+c];

}avgBrightness[row][col] = totalBrightness/6;

}

Page 54: Arrays of Arrays

54

Generalizing• Similar loops to handle

– left border– right border– corners

• Difference is how many neighbors are found above, below, to the right, and to the left

// calculate average brightness at position specified by// row and col; distLeft, distRight, distUp, and DistDown// specify the neighborhood to be averaged.private int adjustPixel( int row, int col, int distLeft,

int distRight, int distUp, int distDown ) {int totalBrightness = 0;int neighbors = 0;for (int r = distUp; r <= distDown; r++) {

for (int c = distLeft; c <= distRight; c++) {totalBrightnesss = totalBrightness + brightness[row+r][col+c]; neighbors++;

}}return totalBrightness/neighbors;

}


Recommended