1. Problem Solving for Programming Session 8 Static Data Structures

2. Data Types We have looked at several data types so far (e.g. integer, boolean, string, etc. ) Of these, the string data type is different because it is composed of two or more instances of a different data type: character. In the example below, the string, myString, is composed of eight characters. Each of these characters has a unique reference (0-7) which indicates its position in the string.

3. User-Defined Data Types There are other instances where it would be useful to group related items into a single data type in the same way characters can be grouped together into a string. Take, for example, a patient record. A patient record consists of several related data items (e.g. familyName, postCode, birthMonth) Most programming languages provide a mechanism for grouping related data into records using either user- defined data types or objects. In pseudo code, a user-defined data type for a patient record might look something like the following:

4. User-Defined Data Types NEWTYPE PatientRecord IS RECORD string: title, familyName, givenName ; integer: birthDay, birthMonth, birthYear ; string: streetAddress, postalTown, postCode, telephone ; integer: joinDay, joinMonth, joinYear, checkUpDay, checkUpMonth, checkUpYear ; ENDRECORD

5. User-Defined Data Types We can now create variables of this new data type in the same way we would create variables of any other data type: PatientRecord: patientOne ; PatientRecord: patientTwo ; And we can access the record’s fields using dot (.) notation patientOne.title  professor ; patientOne.familyName  ‘Higgins’ ; patientOne.birthDay  15 ;....... We can also perform assignment statements on our records: patientTwo.title  patientOne.title ; patientTwo  patientOne ;

6. Static and Dynamic data Structures A string is an example of a static data structure: it has a fixed size (a typical string allows 2,147,483,647 characters or bytes) Static data structures can neither grow (if more memory capacity is needed) nor shrink, if capacity is unused. For this reason programming languages also provide dynamic data structures Dynamic data structures can expand or shrink, using only as much memory as needed Static data structuresDynamic data structures Array, table,....List, stack, queue

7. Static Data Structures – Arrays We can think of an array as a set of linked boxes Each box is capable of holding one item of data All the data stored in the array must be of the same data type, as well as being related The graphic below shows an array of six cake weights, holding integer values Note that the array is indexed from 0 to 5 and not 1 to 6. This is called zero indexing

8. Static Data Structures – Arrays Consider the following scenario: Bob wants to find the average weight of large chocolate cakes baked by Barbara. Barbara works in batches of nine cakes. She tells Bob a cake weight and he adds it to a running total. When Bob has all the cake weights, he can calculate the average weight.

9. Static Data Structures – Arrays We might approach this problem as follows: real: weight, totalWeight, averageWeight ; integer: counter ; integer: numberOfCakes IS 9 ; totalWeight  0 ; FOR counter GOES FROM 1 TO numberOfCakes Get (Barbara, REFERENCE: weight) ; totalWeight  totalWeight + weight ; ENDFOR averageWeight  totalWeight ÷ numberOfCakes ; Display averageWeight ; Where we are getting out data from.

10. Static Data Structures – Arrays The problem here is that after calculating the average weight the weight of each cake is effectively lost. A way around this would be to start by declaring variables for each cake weight: but what if we were dealing with batches of 100 or even 1000 cakes? A more productive approach would be to store the cake weights in an array. Once they are in the array we can use them at any point in our program (to find the lightest, heaviest, etc.)

11. To declare an array we can use the following pseudo code: ARRAY: weights OF [9] real ; This gives us an array called weights with 9 places. This array can hold only real numbers When declaring arrays be careful you have thought the size through carefully. If the array is too small you will run out of space; too large and you will be wasting memory Static data Structures – Arrays

12. Static Data Structures – Arrays We can access the data in any cell of an array using the array’s index. For example: weights [2]  2.0 ; weights [index] – 1  cakeWeight ;

13. Static data Structures – Arrays Some programming languages automatically initialize arrays (numeric values to zero and string values to null). Others demand that arrays be initialized by the programmer at the point of creation (what might happen if some cells in an array are not initialized?) We can initialize each cell of an array individually: weights [0]  3.2 ; weights [1]  4.6 ; However, with larger arrays this is not feasible. With larger arrays some kind of repetition structure is required

14. Static Data Structures – Arrays The most appropriate structure to initialize an array is a count controlled loop. As we will always know the dimensions of the array we would use a FOR loop: integer counter ; FOR counter GOES from 0 to 8 weights [counter]  0 ; ENDFOR Here every value in the array of cake weights is initialized to zero

15. Static Data Structures – Arrays Most programming languages have a predefined function that allows us to access the length of an array (In java this function is called simply length) Using this function, we could rewrite our initialization code as follows: integer counter ; FOR counter GOES from 0 to LENGTH (weights) - 1 weights [counter]  0 ; ENDFOR The -1 is needed because the length function returns the size of the array (In the cakes weights example, 9)

16. Static Data Structures – Arrays Our code to get our cake weights into an array might look as follows: ARRAY: weights OF [9] real ; integer: counter ; FOR counter GOES FROM 0 TO LENGTH(weights) - 1 Display (‘Enter a cake weight: ‘) ; GET (Barbara, REFERENCE: weights [counter] ENDFOR

17. Static Data Structures – Arrays And to calculate the average cake weight and the heaviest cake: real: average, totalWeight, heaviestCake ; average  0 ; totalWeight  0 ; average  0 ; FOR counter GOES from 0 to LENGTH (weights) – 1 totalWeight  totalWeight + weights [counter] ; IF (weights [counter] > heaviestCake) heaviestCake  weights [counter] ; ENDIF ENDFOR IF (totalWeight > 0.0) average  total ÷ LENGTH (weights) ; ENDIF Display (average) Display (heaviestCake)

18. Searching an Array Suppose we are looking for cakes that weigh to little (below 1.8kg). As we have all the cake weights stored in an array, all we have to do is search that array for the target values: How might we do this? weights2.01.82.11.92.0 1.72.01.9 [0]

19. Searching an Array We might use a boolean flag to indicate whether or not the values has been found. boolean: found  false ; Then we might iterate through the array using a loop until we find the target value or not. What kind of loop would be the most appropriate here?

20. Searching an Array boolean: found  false ; integer: counter  0 ; WHILE (counter < LENGTH (weights)) AND (NOT found) found  weights [counter] < 1.8 ; counter  counter + 1 ; ENDWHILE IF (found) Display (‘Low cake weight found at element no. ‘, counter) ; ENDIF Can you see any limitations with this approach? How might it be improved?

21. Searching an Array This approach will only ever allow us to find a single value below the required weight. How could we alter the code so that multiple possible values below 1.8kg can be found?