### pld7e_ch06

```Arrays
Objectives
In this chapter, you will learn about:
•
•
•
•
•
•
•
•
2
Arrays and how they occupy computer memory
Using an array to replace nested decisions
Using constants with arrays
Searching an array
Using parallel arrays
Searching an array for a range match
Remaining within array bounds (bounds checking)
Using a for loop to process arrays
Understanding Arrays and How They Occupy
Computer Memory
• Array
– Conceptually – a collection of variables in computer memory
• an array is an aggregate data type
• the term element is used instead of variable
• all elements share the same name (the array name)
• You access an element in the array using a subscript
• each element has the same data type
num weeklyTotals[6]
valid subscripts for weekly Totals is 0 .. 5
• Subscript (aka index and offset)
– Position number of an item in an array
– May be a named constant, literal, variable, or in general, an expression that evaluates to
an integer.
3
How Arrays Occupy Computer
Memory
• Array elements are stored in contiguous memory
• The size of an array is the number of elements it will
hold
• For most languages:
– the value of the smallest subscript is 0
– the value of the largest subscript is array size – 1
(0 based indexing)
4
How Arrays Occupy Computer
Memory (continued)
Figure 6-1 Appearance of a three-element array in computer
memory
5
Declaring Arrays
• Array Declaration
–
<data_type> <array_name> [ <number_of_elements> ]
–
num someVals[3]
//pseudocode
• data type is num
• name is someVals
• size of the array is 3 elements
• valid subscripts are: 0, 1, 2
• Languages have differences in syntax for arrays
– some languages use ( ) instead of [ ]
– style of declaration can be quite different
• Java array declaration:
6
int someVals[] = new int[3];
Arrays in RAPTOR
The index in a RAPTOR array starts at 1!
Arrays in RAPTOR are easily expanded
SET counter[5]
TO 0
indices are: 1, 2, 3, 4, 5
SET counter[7]
TO 0
indices are: 1, 2, 3, 4, 5, 6, 7
SET counter[100] TO 0
Programming Logic and Design, Seventh Edition
indices are: 1, 2, 3, … , 100
7
Using Arrays
• Given this pseudocode declaration: int someVals[3]
– valid references are:
someVals[0], someVals[1], someVals[2]
– invalid references:
someVals[-1], someVals[3]
• would usually generate an error message such as:
– Java: ArrayIndexOutOfBoundsException
– A subscript used in an array reference can be any integer
expression
• variable, literal, named constant, calculation
An array element can be used in any statement in which a variable
of the same type can be used.
8
Using an Array to
Replace Nested If Decisions
• Example:
Human Resources - Department Dependents report
– Count employees who have claimed zero through five
dependents ( 0 – 5 ) to get count for each: count[0] ..
count[5]
• Assume no employee has more than five dependents
• Application produces counts for dependent
categories by using a series of decisions.
• Application does not scale easily to a different range
of dependents
9
Variable dep may
have the values
0 – 5.
Test dep to
determine which
counter to
increment.
be declared to
implement this
solution.
Figure 6-3
10
Flowchart and pseudocode of decision-making process using a series of decisions
Using an Array to
Replace Nested Decisions (continued)
• Replacing the nested-if logic with array logic reduces
the number of statements needed
• Six dependent count accumulators can be redefined as
a single array: int count[6] //valid subscripts are 0 - 5
• The array elements should be initialized to zero since they will be used as
counters.
• Use the variable dep as a subscript for the array:
count[dep]
11
The comma separated list of values
here is called an "initializer list".
This declaration could be written in Java
as:
int count[] = new int[6];
All of the elements in the array would
automatically be initialized to zero in
Java.
This approach has not simplified the
logic because nested-if's are still being
used.
All of this nested-if logic can be replaced
by a single assignment statement.
Figure 6-4 Flowchart and pseudocode of decision-making Version 2
12
Still not there yet…
Can you see the
pattern
developing?
Replace the
integer literal
subscript with the
variable dep
Figure 6-5
13
Flowchart and pseudocode of decision-making process
Version 3
Using an Array to Replace Nested Decisions
(continued)
Aha!
One statement!
Figure 6-6
14
Flowchart and pseudocode of efficient decision-making process using an array
Named constant
What would this
loop look like in
RAPTOR?
Figure 6-7
15
Flowchart and pseudocode for Dependents Report program
Final Version
Using an Array to Replace Nested Decisions
(continued)
“mainline” logic
main()
Sentinelcontrolled loop.
Notice the module
names:
main()
countDependents()
finishUp()
Counter-controlled
loop.
Should have used a
for loop.
Figure 6-7 Flowchart and pseudocode for Dependents Final Version
16
Using Constants with Arrays
• Remember, constants are
– named constants
– literals
• Use the constants in several ways
– array size
– array value
– array subscript
17
Using a Constant as the Size of an Array
•
Avoid “magic numbers” (unnamed constants)
– magic numbers are literals…
•
Declare a numeric named constant to be used:
– in the declaration of the array
– to determine array size in other parts of your code
•
Make sure any subscript remains less than the constant value
•
Many languages provide a mechanism for determining the size of an array
without needing to refer to a named constant.
– Java has a public field called length
– The expression myArray.length would return the number of elements in the array myArray
– RAPTOR provides the Length_of procedure
18
Length_of(counters)
Using Constants as Array Element Values
• Sometimes the values stored in arrays should be
constants
• int ARRAY_SIZE = 12
string MONTH[ARRAY_SIZE] = //initializer list
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December"
• Valid subscripts are 0 – 11
19
[ RAPTOR 1 – 12 ]
Using Constants as Array Element Values
•
Here is a modified version of the previous example which makes it possible for
use to use the array more naturally.
•
num ARRAY_SIZE = 13 //this allows us to ignore element 0
//instead of 0 – 11, now we can use 1 – 12
string MONTH[ARRAY_SIZE] =
"",
"January",
"April",
"July",
"October",
"February",
"May",
"August",
"November",
"March",
"June",
"September",
"December"
•
Valid subscripts are 0 – 12. Subscripts actually used are 1 – 12. Ignore element 0
•
Element 0 is unused, however, note that we still need to give it a value!
– Small price to pay for the simplified functionality
20
Using a Constant as an Array Subscript
• Use a named constant as a subscript in an array
• Example
– Declare a named constant as
• int INDIANA = 5
– Display value with:
output salesArray[INDIANA]
21
Searching an Array
• Sometimes you must search through an array to find a
value or determine if the value is even in the array
– Item numbers are three-digit, non-consecutive numbers
– Customer orders an item
– Program needs to check if item number is valid
• Solution:
– Create an array that holds valid item numbers
– Search array for exact match
22
The list of values
to be assigned to
the array
elements is called
an initializer list.
String foundIt is
being used as a
flag (boolean
variable).
"Constant Array"
Most languages won't let
you create a constant
array.
Declaration for array
VALID_ITEM in Java
would look more like this:
int validItem[ ] =
{ 106, 108, 307,
405, 457, 688 };
Figure 6-8
23
Flowchart and pseudocode for program that verifies item availability
Rest of program is on the next page
String foundIt is being used as a flag
better choice is to use a boolean variable
boolean foundIt = false;
foundIt = true;
Figure 6-8 Flowchart and pseudocode for program that verifies item availability
24
foundIt = "N"
for sub = 0 to SIZE-1
if item = VALID_ITEM[sub] then
foundIt = "Y"
endif
endfor
Using boolean variable foundIt in
Java
foundIt = false;
for ( sub = 0; sub < SIZE; sub++ )
if ( item == validItem[sub] )
foundIt = true;
Figure 6-8 Flowchart and pseudocode for program that verifies item availability
Programming Logic & Design, Sixth Edition
25
Searching an Array (continued)
• Flag
– variable that indicates whether an event occurred
– declared as a string in the book:
String foundIt = "N";
– usually declared as a boolean or integer variable in most languages
• int
found_it = 0;
//0 for false, 1 for true
• boolean
found_it = false;
//Java
• string found_it = “Y”
//PLD textbook
• SET
//RAPTOR
found_it
TO
True
• Technique for searching an array
– Set a subscript variable to 0 to start at the first element
– Initialize a flag variable to false to indicate the desired value has not been found
– Examine each element in the array
– If the value matches, set the flag to true
– If the value does not match, increment the subscript and examine the next array element
26
An example is given later for searching an array
Using Parallel Arrays
•
– Two arrays, each with the same number of elements
•
Valid item numbers
•
Valid item prices
– Each price in valid item price array in same position as corresponding item in valid item number
array
•
Parallel arrays
– Each element in one array associated with an element in the same relative position in other array
– Do a search on one array and find an associated value in another array
– all arrays should be the same size!
•
Look through valid item array for customer item
– When match is found, get price from item price array
27
Figure 6-9
28
Parallel arrays in memory
Using Parallel Arrays
• Parallel arrays
– Two or more arrays contain related data
– A subscript relates the arrays
• Elements at the same position in each array are logically related
– A similar approach is to have an array of structures or
29
Figure 6-10
Flowchart and pseudocode for a program that finds an item’s price using parallel arrays
Program continues on next slide
30
This search logic
works correctly
but is inefficient
because it
doesn't stop
searching if a
match is found.
A more efficient
approach is
shown later.
Figure 6-10 Flowchart and pseudocode of program that finds an item’s price
using parallel arrays (continued)
31
Figure 6-10
Flowchart and pseudocode of program that finds an item’s price using parallel arrays
Programming Logic & Design, Sixth Edition
32
Improving Search Efficiency
• Program should stop searching the array when a
match is found
• Use a flag (boolean variable) as a second condition
for the search criteria ( AND logic )
• Improves efficiency
• The larger the array, the better the improvement by
doing an early exit
33
Pseudocode to search an array for a value
boolean foundIt = false
int
sub = 0 // item and price are defined elsewhere
while foundIt = false and sub < SIZE
if valid_item[sub] = item then
foundIt = true
price
= valid_price[sub]
endif
endwhile
if foundIt = true
print "The price of the item is “ + price
else
endif
Figure 6-11
34
Flowchart and pseudocode of the module that finds item
price, exiting the loop as soon as it is found
Improving Search Efficiency (continued)
Figure 6-11 Flowchart and pseudocode of the module that finds item price,
exiting the loop as soon as it is found (continued)
35
Searching an Array for a Range
Match
• Sometimes programmers want to work with ranges
of values in arrays
– determine discount based on quantity ordered
• First approach
– Array with as many elements as each possible order quantity
– Store appropriate discount for each possible order quantity
36
Searching an Array for a Range
Match (continued)
Max 76 items
Quantity
Rate
0–8
0%
9 – 12
10%
13 – 25
15%
>= 26
20%
Figure 6-13
37
Usable—but inefficient—discount array
Searching an Array for a Range Match (continued)
• Drawbacks of first approach
– Requires very large array; uses a lot of memory
– Stores same value repeatedly
– How do you know you have enough elements?
• Customer can always order more
• Better approach
– Create four discount array elements for each discount rate
– Parallel array with discount range
• Use loop to make comparisons
38
Searching an Array for a Range Match
(continued)
Figure 6-14
Parallel arrays to use for determining discount
For range comparisons, store
either the low- or high-end value
of each range.
quantity
-------0 - 8
9 - 12
13 - 25
26 or more
discount rate
------------no discount
10%
15%
20%
subscript
--------0
1
2
3
Set value of subscript initially to array size – 1 ( 3 )
Use a loop to determine what subscript to use to access the
discount rate in the discount array.
This logic is more challenging than the if-then-else or switch
logic but is very flexible
subscript = 3
This example is checking the low
end of each range.
loop:
while quantity < quan_limit[subscript]
//26, 13, 9, 0
subtract 1 from the subscript
end while
When you exit the loop, use the value of the
subscript to access the discount rate from the
discount array.
39
range check
Checking from
higher to lower
rates
Figure 6-15
40
Program that determines discount rate
Array Size in Memory
• Every array has a finite size
– There are a specific number of elements in the array
– Each element uses some number of bytes (1,2,4,8,etc)
• The number of bytes in an array is always a multiple of number of array
elements
41
Remaining within Array Bounds
Figure 6-16
42
Determining the month string from the user’s numeric entry
Remaining within Array Bounds
• Program logic assumes every number entered by the user is
valid
• If an invalid subscript is used:
– Some languages stop execution and issue an error
– Other languages access a memory location outside of the array
– Java generates an exception ArrayIndexOutOfBoundsException
• Attempting to use an invalid array subscript is a logic error
• Out of bounds
– using a subscript that is not within the acceptable range for the array
• The Program should prevent bounds errors from occuring.
43
Using a for Loop to Process
Arrays
• for loop
–
–
–
–
single statement
Initializes loop control variable
Compares it to a limit
Alters it
• A for loop is especially convenient when working with arrays
– To process every element
• Must stay within array bounds
• Highest usable subscript is one less than array size.
• Java gives us a field we can use in an expression
44
Using a for Loop to Process Arrays (continued)
Figure 6-17
Pseudocode that uses a for loop to display an array of department names
Java for loops to process array elements:
Standard for loop:
for ( int dep = 0; dep < depts.length; dep++ )
System.out.println( depts[dep] );
Enhanced for loop:
for ( int dep : depts )
System.out.println( dep );
45
Summary
• Array
–
–
–
–
series or list of variables in memory
common name
common type
different subscripts
• Use a variable as a subscript to the array to replace
multiple nested decisions
• Some array values determined during program
execution
– Other arrays have hard-coded values (constant array)
46
Summary (continued)
• Search an array
– Initialize the subscript
– Test each array element value in a loop
– Set a flag when a match is found
• Parallel arrays
– each element in one array is associated with the element in
second array
– Elements have same relative position
• For range comparisons, store either the low- or highend value of each range
47
Summary (continued)
• Access data in an array
– Use subscript containing a value that accesses memory
occupied by the array
• Subscript is out of bounds if not within defined
range of acceptable subscripts
• for loop is a convenient tool for working with
arrays
– Process each element of an array from beginning to end
48
Java Arrays
int evenNumbers[] = { 2, 4, 6, 8, 10 };
2
evenNumbers
4
6
8
length = 5
Object of type int[ ]
49
10
```