Arrays

1. 8 Arrays Programming Logic and Design, Second Edition, Comprehensive Chapter 8

2. Objectives • After studying Chapter 8, you should be able to: • Understand how arrays are used • Understand how arrays occupy computer memory • Manipulate an array to replace using nested decisions • Declare and initialize an array • Understand the difference between run-time and compile-time arrays Chapter 8

3. Objectives • After studying Chapter 8, you should be able to: • Load array values from a file • Search an array for an exact match • Use parallel arrays • Force subscripts to remain within array bounds • Improve search efficiency by using an early exit • Search an array for a range match Chapter 8

4. Understanding Arrays • An array is a series or list of variables in computer memory, all of which have the same name but are differentiated with special numbers called subscripts • Whenever you require multiple storage locations for objects, you are using a real-life counterpart of a programming array • Each of these real-life arrays help you organize real-life objects Chapter 8

5. How Arrays Occupy Computer Memory • Each variable within an array has the same name and the same data type and each separate array variable is one element of the array • Each array element occupies an area in memory next to, or contiguous to, the others as shown in Figure 8-1 • You indicate the number of elements an array will hold—the size of the array—when you declare the array along with your other variables Chapter 8

6. How Arrays Occupy Computer Memory • Every array element has the same group name, but also has a unique subscript indicating how far away the individual element is from the first element • Therefore any array’s subscripts are always a sequence of integers such as 1 through 5 or 1 through 10 Chapter 8

7. Manipulating an Array to Replace Using Nested Decisions • Consider a program that keeps statistics for a recycling drive competition at a high school • The school is holding a competition between the freshman, sophomore, junior, and senior classes to see which class can collect the greatest number of aluminum cans • Each time a student brings in some cans, a clerk adds a record to a file in the following format, as shown in Figure 8-2 Chapter 8

8. Manipulating an Array to Replace Using Nested Decisions • At the end of the recycling competition after all the records have been collected, the file might contain hundreds of records, each holding a one-digit number representing a class and up to a three-digit number representing cans • If all the records were sorted in order by the student’s class, this report could be a control break report Chapter 8

9. Manipulating an Array to Replace Using Nested Decisions • Assume, however, that the records have not been sorted • Without using an array, could you write the program that would accumulate the four class can-recycling totals? • Of course, the program would have the same mainline logic as the other programs you have seen, as flowcharted in Figure 8-4 Chapter 8

10. Manipulating an Array to Replace Using Nested Decisions • You can use four variables, count1, count2, count3, and count4, to keep running counts of collected-can totals for the four different classes • All four of these counter variables need to be initialized to zero Chapter 8

11. mainLoop() Module for Recycling Program Chapter 8

12. finish() Module for Recycling Program Chapter 8

13. Manipulating an Array to Replace Using Nested Decisions • When you declare an array, you provide a group name for a number of associated variables in memory Chapter 8

14. Modified mainLoop() Using Count Array Chapter 8

15. Manipulating an Array to Replace Using Nested Decisions • Figure 8-9 shows that when the stuClass is 1, the stuCans are added to count[1]; when the stuClass is 4, the stuCans are added to count[4] • In other words, the value in stuCans is added to one of the elements of a count array instead of to a single variable named count1, count2, count3, and count4 • The true benefit of using an array lies in your ability to use a variable as a subscript to the array rather than using a constant such as 1 or 4 Chapter 8

16. Modified mainLoop() Using Variable stuCans as a Subscript Chapter 8

17. Manipulating an Array to Replace Using Nested Decisions • Notice that in Figure 8-10 the process boxes after each decision are exactly the same • Each box contains add stuCans to count [stuClass] Chapter 8

18. Modified finish() Module that Uses an Array Chapter 8

19. Manipulating an Array to Replace Using Nested Decisions • The two steps in Figure 8-11 represent the entiremainLoop() module • When stuClass is 2, stuCans is added to count[2], when stuClass is 4, stuCans is added to count[4], and so on • Within the finish() module in Figure 8-12, the stuClass variable is handy to use as a subscript, but any variable could have been used as long as it was: • Numeric with no decimal places • Initialized to 1 • Incremented by 1 each time the logic passes through the loop Chapter 8

20. Array Declaration and Initialization • In the can-recycling program, the four count array elements were declared and initialized to 0s in the housekeeping() module • The count values need to start at 0 so they can be added to during the course of the program • Separately declaring and initializing each count element is acceptable only if there are a small number of counts • Programming languages do not require the programmer to name each of the 30 counts: count[1], count[2], and so on • Instead, you make a declaration such as one of those in Figure 8-13 Chapter 8

21. Array Declaration and Initialization • Declaring a numeric array does not necessarily set its individual elements to zero • To start all array elements with the same initial value, you can use an initialization loop within the housekeeping() module • An initialization loop is a loop structure that provides initial values for every element in any array Chapter 8

22. A housekeeping() ModuleDemonstrating One Method of Initializing Array Elements Chapter 8

23. Run-Time and Compile-Time Arrays • The array that you used to accumulate class counts in the can-recycling program is a run-time array or execution-time array, because of the values that you want to use, the final can counts, are created during an actual run, or execution, of the program • Some arrays are not run-time, but rather compile-time arrays • Compiling is the act of translating a high-level language into machine code (1s and 0s) • A compile-time array is one whose final desired values are fixed at the beginning of the program Chapter 8

24. Run-Time and Compile-Time Arrays Chapter 8

25. Run-Time and Compile-Time Arrays • The rent amounts are hard-coded into the array; that is, they are explicitly assigned to the array elements • The prep() module is shown in Figure 8-18 Chapter 8

26. Flowchart and Pseudocode for prep() Module of Rent Program Chapter 8

27. Flowchart and Pseudocode for the figureRent() Module of the Rent Program Chapter 8

28. The cleanup() Module for the Rent Program Chapter 8

29. Loading an Array from a File • Writing the rent program from the last section requires that you set values for five rent array elements within the prep() module • If you write the rent program for a skyscraper, you might have to initialize 100 array elements • In the prep() module in Figure 8-21, you set the variable count, to one and read a rentRec record from the RENTFILE Chapter 8

30. Flowchart and Pseudocodefor prep() Module that Reads Rents from an Input File Chapter 8

31. Searching for an Exact Match in an Array • Consider a mail-order business in which orders come in with a customer name, address, item number, and quantity ordered, as shown in Figure 8-22 • When a customer orders an item you want to determine whether the customer has ordered a valid item number • You could use a series of six decisions to determine whether the ordered item is valid, but a superior approach is to create an array that holds the list of valid item numbers Chapter 8

32. Searching for an Exact Match in an Array Chapter 8

33. Searching for an Exact Match in an Array • Suppose you create an array with the six elements shown in Figure 8-24 • If a customer orders item 107, a clerical worker can tell whether it is valid by looking down the list and verifying that 107 is a member of the list • The technique for verifying that an item number exists involves setting a subscript to 1 and setting a flag variable to indicate that you have not yet determined whether the customer’s order is valid • A flag is a variable that you set to indicate a true or false state Chapter 8

34. Flowchart and Pseudocode Segments for Finding an Exact Match for a Customer Item Number Chapter 8

35. Using Parallel Arrays • Suppose you have prices for six available items as shown in Figure 8-26 • You could write a program in which you read in a customer order record and then use the customer’s item number as a subscript to pull a price from an array • To use this method, you would need an array with at least 688 elements Chapter 8

36. Using Parallel Arrays • Two corresponding arrays are parallel arrays because each element in one array is associated with the element in the same relative position in the other array Chapter 8

37. ready() Module for Price Program Chapter 8

38. Using Parallel Arrays • You can write the getPrice() module as shown in Figure 8-29 Chapter 8

39. Using Parallel Arrays • The general procedure is to read each item number, look through each of the validItem values separately, and when a match for the custItemNo on the input record is found, pull the corresponding parallel price out of the list of validItemPrices • You must create a variable to use as a subscript for the arrays • Within the getPrice() module, if custItemNo is not the same as validItem[x], then add 1 to x • Because x now holds the value of 2, next you compare the customer’s requested item number to validItem[2] Chapter 8

40. Remaining within Array Bounds • The getPrice() module in Figure 8-29 is not perfect • The logic makes one dangerous assumption: that every customer will order a valid item number • If a customer is looking at an old catalog and orders item 007, the program will never find a match • When you use a subscript that is not within the range of acceptable subscripts, your subscript is said to be out of bounds Chapter 8

41. Remaining within Array Bounds • You can improve the price-finding program by adding a flag variable and a test to the getPrice() module • You can set the flag when you find a valid item in the validItem array, and after searching the array, check whether the flag has been altered Chapter 8

42. Improving Search Efficiency Using an Early Exit • The mail-order program is still a little inefficient • The problem is that if lots of customers order item 006 or 008, their price is found on the first or second pass through the loop • The program continues searching through the item array, however, until x exceeds the value 6 • Leaving a loop as soon as a match is found is called an early exit; it improves the program’s efficiency Chapter 8

43. The getPrice() Module with Early Exit Chapter 8

44. Searching an Array for a Range Match • Sometimes, programmers want to work with ranges of values in arrays • A range of values is any set of contiguous values, for example 1 through 5 Chapter 8

45. Searching an Array for a Range Match Chapter 8

46. Searching an Array for a Range Match • This approach has three drawbacks: • It requires a very large array that uses a lot of memory • You must store the same value repeatedly. For example, each of the first nine elements receives the same value, zero • Where do you stop adding array elements? Is a customer order quantity of 75 items enough? What if a customer orders 100 or 1000 items? No matter how many elements you place in the array, there’s always a chance that a customer will order more Chapter 8

47. Searching an Array for a Range Match Chapter 8

48. Flowchart and Pseudocodefor Discount Determination Chapter 8

49. Summary • An array is a series or list of variables in computer memory, all of which have the same name but are differentiated with special numbers called subscripts • When you declare an array, you declare a programming structure that contains multiple elements, each of which has the same name and the same data type • You often can use a variable as a subscript to an array, replacing multiple nested decisions Chapter 8

50. Summary • You can declare and initialize all of the elements in an array using a single statement that provides a type, a name, and a quantity of elements for the array • An array whose values are determined during the execution of a program is a run-time array, or execution-time array • An array whose final desired values are fixed at the beginning of the program is a compile-time array Chapter 8