1. 1 DATA STRUCTURES: LISTS

2. 2 LISTS ARE USED TO WORK WITH A GROUP OF VALUES IN AN ORGANIZED MANNER. A SERIES OF MEMORY LOCATIONS CAN BE DIRECTLY REFERENCED AND MANIPULATED AS A SINGLE ENTRY.

3. 3 EXAMPLE: ASSUME THAT WE HAVE TO MAINTAIN SEVERAL RELATED VALUES OF THE SAME TYPE (i.e. 5 GRADES). THE FOLLOWING MAY BE USED. grade1 grade2 grade3 grade4 grade5 98 78 65 87 45

4. 4 IF THE LIST OF GRADES IS LONG, THEN THIS BECOMES INEFFICIENT TO WORK WITH. A REASONABLE ALTERNATIVE IS TO ORGANIZE THE VALUES UNDER ONE STRUCTURE; THE ARRAY.

5. 5 int list [5]; A 5 COMPONENT LIST 0 1 2 3 4 list EXAMPLE:

6. 6 STRUCTURED DATA TYPE THE ARRAY IS A DATA TYPE THAT IS A COLLECTION OF COMPONENTS OF A SIMPLER TYPE (COMPOSITE) WITH A FIXED NUMBER OF ITEMS (STATIC). ALL ARE OF THE SAME TYPE (HOMOGENOUS). EACH COMPONENT CAN BE ACCESSED INDIVIDUALLY BY SPECIFYING ITS POSITION WITHIN THE COLLECTION (ORDERED).

7. 7 TO ACCESS THE ARRAY VARIABLE AS A UNIT, THE ARRAY NAME IS USED. TO ACCESS AN INDIVIDUAL COMPONENT, THE NAME OF THE ARRAY VARIABLE, AND AN EXPRESSION THAT SPECIFIES THE INDIVIDUAL COMPONENT TO BE ACCESSED IS USED. EXAMPLE: list[3] ACCESSING INDIVIDUAL COMPONENTS

8. 8 THE GENERAL FORM FOR DEFINING AND ALLOCATING MEMORY FOR AN ARRAY TYPE IS: DEFINING ARRAYS component_type type_name [ array_size ];

9. 9 const int NUM_OF_STUDENTS = 25; char grades[NUM_OF_STUDENTS]; char grade; EXAMPLE:

10. 10 type_name IS A USER DEFINED IDENTIFIER. THE array_size GIVES THE RANGE OF INDEX VALUES (FROM 0 TO array_size-1). IT DETERMINES HOW MANY COMPONENTS THERE ARE IN THIS ARRAY TYPE. THE component_type DESCRIBES THE TYPE OF THE ELEMENTS OF THE ARRAY. ONCE AN ARRAY STRUCTURE HAS BEEN DEFINED, VARIABLES OF THAT TYPE CAN BE DECLARED.

11. 11 THE ASSIGNMENT STATEMENT AND ARRAYS TO STORE THE VALUES 98, 78, 65, 87, 45 INTO THE ARRAY list. list[0] = 98; list[1] = 78; list[2] = 65; list[3] = 87; list[4] = 45;

12. 12 TO INTERCHANGE THE VALUE OF TWO COMPONENTS ( list[3] WITH list[4] ), THE FOLLOWING STATEMENT WILL ACCOMPLISH THIS (ASSUME THAT temp HAS BEEN DECLARED EARLIER). temp = list[3]; list[3] = list[4]; list[4] = temp; (USED WHEN ARRANGING VALUES)

13. 13 list[3] 87 ? temp INITIAL MEMORY STATUS list[4] 45 list[3] 87 87 temp AFTER 1st ASSIGNMENT list[4] 45 list[3] 45 87 temp AFTER 2nd ASSIGNMENT list[4] 45 list[3] 45 87 temp AFTER 3rd ASSIGNMENT list[4] 87

14. 14 cin >> list[0] >> list[1] >> list[2] >> list[3] >> list[4]; WOULD ALLOW FOR 5 VALUES TO BE ENTERED TO ARRAY VARIABLE list. TO PRINT 5 COMPONENTS cout << list[0] << list[1] << list[2] << list[3] << list[4]; CAN BE USED. INPUT/OUTPUT OF ARRAY ELEMENTS

15. 15 INPUT/OUTPUT USING REPETITIVE STRUCTURES LOOPS CAN BE USED TO SYSTEMATICALLY MANIPULATE OR REFERENCE ARRAY COMPONENTS. for (i = 0; i < 5; i++) cin >> list[i]; for (i = 0; i < 5; i++) cout << list[i];

16. 16 THE ASSIGNMENT STATEMENT AND ARRAYS : for (i = 0; i < 5; i++) { cin >> test1 >> test2 >> test3; total_grade = test1 + test2 + test3; list[i] = total_grade; } :

17. 17 ARRAY PROCESSING WITH REPETITIVE STRUCTURE USING THE EARLIER DECLARATION OF ARRAY VARIABLE list AND THE INPUT CODE SEGMENT (ASSUME total, larger, AND average HAVE BEEN DEFINED EARLIER), THE FOLLOWING CODE SEGMENT COMPUTES THE AVERAGE. : total = 0; for (i = 0; i < 5; i++) total += list[i]; average = total / 5; :

18. 18 FINDING THE LARGEST SCORE: : larger = list[0]; for (i = 1; i < 5; i++) if (list[i] > larger) larger = list[i]; :

19. 19 AN ARRAY VARIABLE CAN BE PASSED AS A PARAMETER TO A FUNCTION. A FUNCTION CAN NOT RETURN ALL THE ARRAY COMPONENTS THROUGH THE return STATEMENT. ARRAYS ARE ALWAYS PASSED BY REFERENCE IN C++, UNLESS THE RESERVED WORD const IS USED IN FRONT OF THE FORMAL PARAMETER. ARRAYS AND FUNCTIONS

20. 20 EXAMPLE: USING THE PREVIOUS DECLARATIONS OF ARRAY list THAT NOW CONTAINS STUDENTS GRADES IN ASCENDING ORDER, REARRANGE THE GRADES (USING ANOTHER LIST) IN DESCENDING ORDER. ALSO ASSUME newlist IS DECLARED TO BE OF TYPE Grades. A CALL TO FUNCTION WHICH WILL DO THE THIS LOOKS LIKE. Rearrange_List (list, newlist);

21. 21 0 1 2 3 4 45 65 78 87 98 0 1 2 3 4 98 87 78 65 45 newlist list

22. 22 THE FUNCTION: void Rearrange_List (const Grades ascend, Grades descend) // this function reverses the components // of the first array into the second. // The first parameter is passed by value, // the second one is passed by reference. { int count; for (count = 0; count < 5; count ++) descend[count] = ascend[4 - count]; return; }

23. 23 MULTI-DIMENSIONAL LISTS

24. 24 DATA REPRESENTED IN TABULAR FORM IS REFERENCED AS A TWO-DIMENSIONAL ENTITY. MORE COMPLICATED REPRESENTATIONS REQUIRE MULTIPLE REFERENCE PATHS.

25. 25 APRIL 1992 S M T W TH F S WEEK 1 1 2 3 4 WEEK 2 5 6 7 8 9 10 11 WEEK 3 12 13 14 15 16 17 18 WEEK 4 19 20 21 22 23 24 25 WEEK 5 26 27 29 30 28 ANDREW’S BIRTHDAY

26. 26 TWO-DIMENSIONAL ARRAYS DATA STRUCTURE USED TO REPRESENT A TABLE WITH ROWS AND COLUMNS. A COMPONENT IN A TWO-DIMENSIONAL ARRAY IS ACCESSED BY GIVING WHAT CORRESPONDS TO THE ROW AND COLUMN OF THE ITEM. IN A TWO-DIMENSIONAL ARRAY TWO ARRAY SIZES MUST BE DESCRIBED.

27. 27 typedef int Calendar[5][7]; Calendar month; EXAMPLE:

28. 28 TO ACCESS A COMPONENT IN A TWO-DIMENSIONAL ARRAY AN EXPRESSION THAT INDICATES WHERE THE COMPONENT LIES ON EACH DIMENSION IS USED. month [4][2] FIFTH THIRD DIMENSION DIMENSION COORDINATE COORDINATE REPRESENTS ANDREW’S BIRTHDAY

29. 29 const int WEEKS = 52; const int DAYS = 7; typedef int WholeYear[WEEKS][DAYS]; WholeYear year; year IS A TWO-DIMENSIONAL ARRAY WITH 364 COMPONENTS AS A TABLE WITH 52 ROWS AND 7 COLUMNS. ANOTHER EXAMPLE:

30. 30 [0][1][2]... [6] [0] [1] [2]. [51] ARRAY year

31. 31 ANOTHER WAY OF INDEXING THE SAME STRUCTURE : const int NUM_WEEKS = 52; enum Days {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY}; typedef int WholeYear[NUM_WEEKS][Days]; WholeYear year; YEAR HAS THE SAME NUMBER OF ROWS AND COLUMNS IN BOTH EXAMPLES, BUT THE SECOND COMPONENT INDEXED DIFFERENTLY. year[2][MONDAY] = 15;

32. 32 ANOTHER METHOD OF DECLARING TWO-DIMENSIONAL ARRAYS. APRIL 1992 (5 ONE DIMENSIONAL ARRAYS, EACH OF LENGTH 7)

33. 33 typedef int Week[7]; typedef Week Calendar[5]; Calendar month; EXAMPLE:

34. 34 IT IS ADVANTAGEOUS TO DEFINE AN ARRAY OF ARRAYS. IF THE ROWS HAVE BEEN DEFINED FIRST AS A ONE-DIMENSIONAL ARRAY, EACH CAN BE PASSED TO A MODULE EXPECTING A ONE-DIMENSIONAL ARRAY OF THE SAME TYPE AS A PARAMETER.

35. 35 INPUT/OUTPUT WITH TWO DIMENSIONAL ARRAYS ASSUME A TWO-DIMENSIONAL ARRAY VARIABLE class_grades DECLARED AS: typedef int Cis113[20][3]; Cis113 class_grades; AND 20 LINES OF INPUT EACH CONTAINING 3 TEST SCORES. THE DATA CAN BE ENTERED BY READING THEM ONE LINE AT A TIME (FOR 20 LINES).

36. 36 : for (row = 0; row > class_grades[row][column]; : EXAMPLE:

37. 37 TO DISPLAY THE CONTENTS OF THE ARRAY, THE SAME CODE SEGMENT LOGIC IS USED. : for (row = 0; row < 20; row ++) { for (column = 0; column < 3; column++) cout << class_grades[row][column]; cout << endl; } :

38. 38 ARRAY PROCESSING IT IS POSSIBLE TO REFERENCE AND MANIPULATE ARRAY COMPONENTS DIRECTLY AND SELECTIVELY AS INDIVIDUAL VALUES. IN SOME APPLICATIONS, IT MAY BE POSSIBLE THAT EACH COMPONENT IS SYSTEMATICALLY ACCESSED. INITIALIZING, TOTALING, ROWS AND COLUMN SUMMING, AND OTHER COMPUTATIONS ARE SOME EXAMPLES.

39. 39 INITIALIZE THE ARRAY EACH ARRAY LOCATION IS ACCESSED AND SET TO A SPECIFIC VALUE (ZERO IN THIS CASE). for (row = 0; row < NUMBER_OF_ROWS; row ++) for (column = 0; column < NUMBER_OF_COLUMNS; column ++) class_grades[row][column] = 0;

40. 40 SUM THE ROWS for (row = 0; row < NUMBER_OF_ROWS; row ++) { total = 0; for (column = 0; column < NUMBER_OF_COLUMNS; column ++) total += class_grades[row][column]; cout << "Row sum: " << total << endl; } ADDS ALL 3 GRADES FOR EACH STUDENT (20 STUDENTS IN TOTAL)

41. 41 SUM THE COLUMNS for (column = 0; column < NUMBER_OF_COLUMNS; column++) { total = 0; for (row = 0; row < NUMBER_OF_ROWS; row++) total += class_grades[row][column]; cout << "Column sum: " << total << endl; } ADDS ALL STUDENTS EXAM GRADES FOR ALL EXAMS (3 EXAMS IN TOTAL FOR EACH STUDENT)

42. 42 FIND THE AVERAGE OF THE VALUES OF A COLUMN for (column = 0; column < NUMBER_OF_COLUMNS; column ++) { total = 0; for (row = 0; row < NUMBER_OF_ROWS; row ++) total += class_grades[row][column]; average = total / NUMBER_OF_ROWS; cout << "Average score for test " << column << " is " << average << endl; }

43. 43 MULTI-DIMENSIONAL ARRAYS C++ DOES NOT PLACE ANY LIMIT ON THE NUMBERS OF DIMENSIONS AN ARRAY CAN HAVE. IN N-DIMENSIONAL ARRAYS EACH COMPONENT IS ACCESSED BY N INDICES, EACH OF WHICH REPRESENTS THE COMPONENT’S POSITION WITHIN THAT DIMENSION.

44. 44 typedef int Total[3][4][5]; Total value; THE NUMBER OF COMPONENTS IN value IS 3 * 4 * 5 = 60

45. 45 value [1][0][0] value[0][3][4] value [2][3][3] value [1][2][2] value [0][1][1] 3-DIMENSIONAL ARRAY value

46. 46 ANOTHER EXAMPLE: const int NUMBER_OF_STUDENTS = 100; const int NUMBER_OF_COURSES = 4; const int NUMBER_OF_EXAMS = 3; typedef int GradeType[NUMBER_OF_COURSES] [NUMBER_OF_EXAMS] [NUMBER_OF_STUDENTS];

47. 47 GradeType num_grades; int id; int course; int exam; int current_exam; int total_grade; THE NUMBER OF COMPONENTS IN num_grades IS 1200 (4 * 3 * 100)

48. 48 A CODE SEGMENT TO SUM AND PRINT THE TOTAL GRADE FOR ALL EXAMS (TAKEN SO FAR) IN EACH COURSE, BY EVERY STUDENT. : for (id = 0; id < NUMBER_OF_STUDENTS; id ++) { total_grade = 0; for (course = 0; course < NUMBER_OF_COURSES; course ++) for (exam = 0; exam < current_exam; exam ++) total_grade += num_grades[course][exam][id]; cout << "ID # " << id << " The total grade to date is " << total_grade << endl; } :

49. 49 A CODE SEGMENT TO SUM ALL STUDENTS' GRADES FOR EACH COURSE. for (course = 0; course < NUMBER_OF_COURSES; course ++) { total_grade = 0; for (id = 0; id < NUMBER_OF_STUDENTS; id ++) for (exam = 0; exam < current_exam; exam ++) total_grade += num_grades[course][exam][id]; cout << "Course # " << course << " The grand total is " << total_grade << endl; }