Moving though multi-dimensioned arrays

If you remember, or look back to searching and sorting single-dimensioned arrays you will know that to drive the inspection or sorting algorithm some kind of loop is required; this may be either a for, while or repeat - until loop. For single-dimension arrays a single loop is required, for a two dimensional array two loops are required. Using multiple loops together to drive through a multi-dimension array is called nesting loops. You probably could write an algorithm yourself now to run through a single-dimensional integer array and add up the values contained within it. Your algorithm might look something like this:

I hope you would admit that this was a fairly straightforward piece of coding to come up with. Well it is, and all that is needed to do the same job on a two-dimension array is to put this algorithm inside another FOR loop. It is very much like working with an array, which is contained within another array. For this algorithm, let us assume that there is an array of size MAX contained within an array of size 5, MAX of course would be a declared constant and could be any size.

Now, how does this work? Well when the loop controlled by I is reached, I becomes equal to one, then the program moves on to the loop controlled by J, which also becomes equal to one. So with both I and J equal to one the program reaches the third line, where quite simply the variable total takes the value of itself plus the value contained in the array at location [1,1]. Now the program is still within the loop controlled by J, and will be until J reaches the value MAX, at which point I will still be equal to one and J will be equal to MAX. So the sum of all the values contained in the array from [1,1] to [1,MAX] will have been added to total. Now the program will return to the loop controlled by I. I will be incremented to two, and the program will move on to the loop controlled by J, at which point J will be restarted at 1, and the first value added to total will be the value contained in the array location [2,1]. Get it? The program is still within the loop controlled by J, and will be there until J again equals MAX at which point I will still be equal to two, and J will be equal to MAX, and all the values contained in the from [2,1] to [2,MAX] will have been added to total. This repetition will continue until I equals five and J equals max then both loops will be exited from and the program will print out the value of total.

The next little program demonstrates the coordinates of two-dimensional arrays by writing out coordinates.

Program 3

The output from this program is shown in figure

Figure 3 - Two-dimensional arrays : Writing out the coordinates

A similar procedure occurs with arrays of more dimensions. A three dimensional array would be defined by:

To run through this particular data structure will require three coordinates, and triple nested FOR loop.

Let's return to two-dimensional arrays. If you look at the array as having rows and columns, you might at some point wish to total up the rows and the columns individually. This next program does that. Consider a two-dimensional array of five by five. The fifth element in each row is to contain the total for that row, and the fifth element in each column is to contain the total for that column. You will notice that I have used and reused the loop counters I and J. This may cause you a little problem, but I will explain what makes this ok later on. In this next program, because we will be reading values into the 4 by 4 part of the array, it is only necessary to zero the elements of the 5th row and the 5th column.

Program 4

array}

The next piece of code worth looking a bit more closely at is

It has the pair of FOR loops, that you know about. The line

is not as strange as it might seem. At each iteration of the loop the pair [row,column] will identify a different element in the array so that in each iteration the_array[row,column] is in fact a different element of the array. The line in effect is saying put the entered number into the variable the_array at the coordinates indicated by the pair [row,column].

We could have written this operation like this:

This does the same thing, but because it uses another variable, this method uses more memory, and time, and as such it is not quite as good. It is not wrong; it is not bad. The first way is just better, but the second might be clearer to you. In programming the best way is always the way which you understand the most thoroughly, because it might be you who has to edit a program, and if you really don't understand how it works how can you do this properly? So in the program the four by four part of the array is loaded up with integers, and could look something like this,

Figure 4 - Two dimensional arrays : Array of integers

Now we need to figure out how to total each row and put it into the fifth element of that row. The fifth element of the row really has its own a separate identifier. This is the_array[row,MAX]. As row varies in the loop between one and four, MAX remains constant. So the total will be stored in the fifth element of the n'th row. In the first row we wish to perform the calculation

Of course instead of the constant subscripts, we are going to use the loop counter variable row and column as in the code fragment below.

This piece of code adds together the first four elements of each row and puts the result into the fifth element. Next we want to total up the first four elements in each column and put the result into its fifth element. The operation we wish to perform on the first column is

When totalling the rows the outside FOR loop was driven by the variable row. We now want to go vertically so it will be the second index which varies. This means that we will sweep across the array in a vertical mode for columns rather than the horizontal mode of rows. The code which does the column totalling is only subtly different from the row totalling code.

The code which writes out the array is copied from the program sort_array in chapter five adapted to work on a two-dimensional array. Well, earlier I promised to explain why it was ok to do the whole of program row_column _total using and reusing only two loop counter variables. This really comes down to a very simple concept. A looping structure is the piece of code where a variable is under control of the loop. Once the program leaves the loop, the loop no longer has any control over the variable used as a control variable. The variable is therefore available to be used again. The range of control of FOR, REPEAT - UNTIL and WHILE loops are begun with the reserved word, and ended with either a semi-colon in the case of single statement loops or the reserved word END. Such as in the examples below.

this is an example of a single statement loop which ends at the semi-colon. This is exactly the same as

adding a BEGIN - END pair extends the range of the loops control to the reserved word END.

This fragment will work exactly the same as the other two above. The BEGIN - END pair only extends the range of the loop to allow you to put more statements under its control, such as you have seen in other programs. So once the program leaves the loop, we can then start another loop using the same control variables.

1.3. Statements! What are statements?

A statement is a single complete instruction, and statements are separated by semi-colons. A compound statement is two or more simple statements grouped together between a BEGIN and an END.

This is a statement.

And this is a compound statement.

Date: 2016-03-03; view: 657