1 DATA STRUCTURES: LISTS. 2 LISTS ARE USED TO WORK WITH A GROUP OF VALUES IN AN ORGANIZED MANNER. A...

transcript

DATA STRUCTURES:

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.

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

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.

int list[5];

A 5 COMPONENT LIST

0 1 2 3 4

EXAMPLE:

STRUCTURED DATA TYPETHE 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 OFTHE SAME TYPE (HOMOGENOUS). EACH COMPONENTCAN BE ACCESSED INDIVIDUALLY BY SPECIFYING ITS

POSITION WITHIN THE COLLECTION (ORDERED).

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

THE GENERAL FORM FOR DEFINING AND ALLOCATING MEMORY FOR AN ARRAY TYPE IS:

DEFINING ARRAYS

component_type type_name [array_size];

const int NUM_OF_STUDENTS = 25;

char grades[NUM_OF_STUDENTS];

char grade;

EXAMPLE:

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.

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;

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)

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

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 ARRAYELEMENTS

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];

THE ASSIGNMENT STATEMENT AND ARRAYS

for (i = 0; i < 5; i++){ cin >> test1 >> test2 >> test3; total_grade = test1 + test2 + test3; list[i] = total_grade;} :

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; :

FINDING THE LARGEST SCORE:

:larger = list[0];for (i = 1; i < 5; i++) if (list[i] > larger) larger = list[i]; :

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

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);

0 1 2 3 4

45 65 78 87 98

0 1 2 3 4

98 87 78 65 45newlist

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;}

MULTI-DIMENSIONAL LISTS

DATA REPRESENTED IN TABULAR FORM IS REFERENCED AS A TWO-DIMENSIONAL ENTITY.

MORE COMPLICATED REPRESENTATIONS REQUIRE MULTIPLE

REFERENCE PATHS.

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

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.

typedef int Calendar[5][7];

Calendar month;

EXAMPLE:

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

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:

[0] [1] [2] . . . [6]

ARRAY year

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;

ANOTHER METHOD OF DECLARING TWO-DIMENSIONAL ARRAYS.

APRIL 1992 (5 ONE DIMENSIONAL ARRAYS, EACH OF LENGTH 7)

typedef int Week[7];typedef Week Calendar[5];

Calendar month;

EXAMPLE:

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.

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

for (row = 0; row < 20; row ++) for (column = 0; column < 3; column ++) cin >> class_grades[row][column];

EXAMPLE:

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;} :

ARRAY PROCESSINGIT 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.

INITIALIZE THE ARRAYEACH 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;

SUM THE ROWSfor (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)

SUM THE COLUMNSfor (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)

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;}

MULTI-DIMENSIONAL ARRAYSC++ 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.

typedef int Total[3][4][5];

Total value;

THE NUMBER OF COMPONENTS IN value IS 3 * 4 * 5 = 60

45value [1][0][0]

value[0][3][4]

value [2][3][3]

value [1][2][2]

value [0][1][1]

3-DIMENSIONAL ARRAY value

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];

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)

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;} :

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;}

1 DATA STRUCTURES: LISTS. 2 LISTS ARE USED TO WORK WITH A GROUP OF VALUES IN AN ORGANIZED MANNER. A...

Documents