Programming Logic and Design Seventh Edition

1. Programming Logic and DesignSeventh Edition Chapter 6 Arrays

2. Objectives In this chapter, you will learn about: • 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

3. 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 indexandoffset) • 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.

4. 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)

5. How Arrays Occupy Computer Memory (continued) Figure 6-1 Appearance of a three-element array in computer memory

6. Declaring Arrays • Array Declaration • <data_type> <array_name> [ <number_of_elements> ] • numsomeVals[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: int someVals[] = new int[3];

7. Arrays in RAPTOR Arrays_in_RAPTOR Programming Logic and Design, Seventh Edition

8. Using Arrays • Given the declaration: numsomeVals[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 • Subscript represents the distance from first element • this is the notion of an offset • 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.

9. Using an Array to Replace Nested 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

10. Variable dep may have the values 0 – 5. Test dep to determine which counter to increment. 6 variables had to be declared to implement this solution. Figure 6-3 Flowchart and pseudocode of decision-making process using a series of decisions

11. 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: num 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]

12. 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'sare 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

13. Still not there yet… Can you see the pattern developing? Replace the integer literal subscript with the variable dep Figure 6-5 Flowchart and pseudocode of decision-making process Version 3

14. Using an Array to Replace Nested Decisions (continued) Aha! One statement! Figure 6-6 Flowchart and pseudocode of efficient decision-making process using an array

15. Named constant What would this loop look like in RAPTOR? Figure 6-7 Flowchart and pseudocode for Dependents Report program Final Version

16. Using an Array to Replace Nested Decisions (continued) Figure 6-7 Flowchart and pseudocode for Dependents Final Version Sentinel-controlled loop. • “mainline” logic • main() Notice the module names: main() getReady() countDependents() finishUp() Counter-controlled loop. Should have used a for loop.

17. Using Constants with Arrays • Remember, constants are • named constants • literals • Use the constants in several ways • array size • array value • array subscript

18. 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

19. Using Constants as Array Element Values • Sometimes the values stored in arrays should be constants • num 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

20. 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", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "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

21. Using a Constant as an Array Subscript • Use a named constant as a subscript in an array • Example • Declare a named constant as • num INDIANA = 5 • Display value with: output salesArray[INDIANA]

22. Searchingan Array • Sometimes you must search through an array to find a value or determine if the value is even in the array • Example: mail-order business • 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

23. 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 Flowchart and pseudocode for program that verifies item availability Rest of program is on the next page

24. String foundIt is being used as a flagbetter choice is to use a boolean variable bool foundIt = false; foundIt = true; //bool var Figure 6-8 Flowchart and pseudocode for program that verifies item availability

25. foundIt ="N" forsub = 0 to SIZE-1 if item = VALID_ITEM[sub] then foundIt = "Y" endif endfor Using a boolean variable foundIt 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

26. 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 • IntfoundIt = 0; //0 for false, 1 for true • bool foundIT = false; //C and C++ • 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 An example is given later for searching an array

27. Using Parallel Arrays • Example: mail-order business • 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 • Look through valid item array for customer item • When match is found, get price from item price array

28. Figure 6-9 Parallel arrays in memory

29. 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 objects ( advanced topic )

30. Figure 6-10 Flowchart and pseudocode for a program that finds an item’s price using parallel arrays Program continues on next slide

31. 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)

32. Figure 6-10 Flowchart and pseudocode of program that finds an item’s price using parallel arrays Programming Logic & Design, Sixth Edition

33. 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

34. Java sample code to search an array for a value boolean foundIt = false num sub = 0 // item and price are defined elsewhere while foundIt = false && sub < SIZE if valid_item[sub] = item foundIt = true price = valid_price[sub] endif Endwhile if foundIt = true print "The price of the item is “ + price else print "Item was not found in the array valid_item." badItemCount+= 1 //defined elsewhere } Figure 6-11 Flowchart and pseudocode of the module that finds item price, exiting the loop as soon as it is found

35. 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)

36. Searching an Array for a Range Match • Sometimes programmers want to work with ranges of values in arrays • Example: mail-order business • Read customer order data • 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

37. 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-13Usable—but inefficient—discount array

38. 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

39. Searching an Array for a Range Match (continued) quantity discount rate subscript -------- ------------- --------- 0 - 8 no discount 0 9 - 12 10% 1 13 - 25 15% 2 26 or more 20% 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 = 4 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. Figure 6-14 Parallel arrays to use for determining discount For range comparisons, store either the low- or high-end value of each range. This example is checking the low end of each range.

40. range check Checking from higher to lower rates Figure 6-15 Program that determines discount rate

41. 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

42. Remaining within Array Bounds Figure 6-16 Determining the month string from the user’s numeric entry

43. 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.

44. Using a forLoop to Process Arrays • forloop • 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

45. Using a forLoop 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 );

46. 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)

47. 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 high-end value of each range

48. 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

49. Java Arrays int evenNumbers[] = { 2, 4, 6, 8, 10 }; length = 5 evenNumbers Object of type int[ ]