Chapter 9 Data Structures: Arrays and Structs Lecture Notes Prepared By: Blaise W. Liffick, PhD Department of Computer Science Millersville University

Chapter 9

Data Structures: Arrays and Structs

Lecture Notes Prepared By:

Blaise W. Liffick, PhDDepartment of Computer ScienceMillersville UniversityMillersville, PA [email protected]

© 2004 Pearson Addison-Wesley. All rights reserved 9-2

9.1 The Array Data Type

• Array elements have a common name– The array as a whole is referenced through the

common name

• Array elements are of the same type — the base type

• Individual elements of the array are referenced by sub-scripting the group name– element’s relative position used, beginning with 0

• Array stored in consecutive memory locations


Additional Array Details

• Subscripts are denoted as expressions within brackets: [ ]

• Base type can be any fundamental, library-defined, or programmer -defined type

• The index type is integer and the index range must be 0 ... n-1, for array of size n


Array Declaration

element-type array-name [array-size];

Type of all the values in the array

Name of the entire collection of values

Integer expression indicating number of elements in the array


Example 1

element-type array-name [array-size] = {initialization-list};

float x[8] = {16.0, 12.0, 6.0, 8.0, 2.5, 12.0, 14.0, -54.5};

16.0 12.0 6.0 8.0 2.5 12.0 14.0 -54.5


Example 1 (con’t)

cout << x[0];

x[3] = 25.0;

sum = x[0] + x[1];

sum += x[2];

x[3] += 1.0;

x[2] = x[0] + x[1];


Example 2

const int NUM_EMP = 10;

bool onVacation[NUM_EMP];

int vacationDays[NUM_EMP];

enum day {sunday, monday, tuesday, wednesday, thursday, friday, saturday};

day dayOff[NUM_EMP];

float plantHours[7];


Figure 9.3 Arrays onVacation, vacationDays, and dayOff


Array Initialization• List of initial values enclosed in braces ({ })

following assignment operator (=)• Values from initialization list are assigned in order

to array elements• Length of initialization list cannot exceed size of

the array• If too few values, value assigned is system

dependent• Size of array can be automatically set to number

of initializing values using empty brackets ([ ])


Array Subscripts• Enclosed in brackets ([ ])

• Indicates which element is referenced by position

• Array subscript value is different than array element value

• Subscript can be an expression of any integral type

• To be valid, subscript must be a value between 0 and one less than the array size


9.2 Sequential Access to Array Elements

• Random Access– Access elements is any order

• Sequential Access– Process elements in sequential order starting

with the first


Example of Sequential Access

int cube[10];

for (int i = 0; i < 10; i++)

cube[i] = i * i * i;


Strings and Arrays of Characters

• string object uses an array of char

• Can reference individual character of a string object in different ways– name[ i ]– name.at( i )

• Other member functions of string class– message.length( i )


9.3 Array Arguments

• Use <, ==, >, +, -, etc. to test and modify array elements individually

• Can pass array elements to functionsexchange (s[3], s[5]);


Listing 9.3 Function to exchange the contents of two floating-point memory locations


Passing an Array Argument

• Arrays are always passed by reference

• Pass entire array to a function by writing just its name (no subscripts or brackets) in the argument list of the function call

• In function definition and prototype, user empty brackets ([ ]) to identify array

• Use keyword const to indicate that array argument cannot be changed by function


Example 1

const int MAX_SIZE = 5;

float x[MAX_SIZE ];

float y[MAX_SIZE ];

. . .

if (sameArray(x, y, MAX_SIZE))

cout << “Arrays are identical.” << endl;

else

cout << “Arrays are different.” << endl;


Listing 9.4 Function sameArray


Example 2

const int MAX_SIZE = 5;

float x[MAX_SIZE ] = {1.8, 2.2, 3.4, 5.1, 6.7};

float y[MAX_SIZE ] = {2.0, 4.5, 1.3, 4.0, 5.5};

float z[MAX_SIZE];

. . .

addArray(MAX_SIZE, x, y, z);


Listing 9.5 Function addArray

// File: addArray.cpp// Stores the sum of a[i] and b[i] in c[i]

// Sums pairs of array elements with subscripts ranging from 0// to size – 1// Pre: a[i] and b[i] are defined (0 <= i <= size-1)// Post: c[i] = a[i] + b[i] (0 <= i <= size-1)

void addArray (int size, // IN: the size of the arrays const float a[], // IN: the first array const float b[], // IN: the second array float c[]) // OUT: result array{ // Add corresponding elements of a and b and store in c for (int i = 0; i < size; i++) c[i] = a[i] + c[i];}


9.4 Reading Part of an Array

• Sometimes it is difficult to know how many elements will be in an array– 150 students in one section– 200 students in another section

• Always allocate enough space for largest possible amount needed

• Remember to start reading with index [0]

• Must keep track of how many elements used


Listing 9.7 Function readScoresFile


Listing 9.7 Function readScoresFile (continued)


9.5 Searching and Sorting Arrays

• Two common array processing problems– Searching– Sorting

• E.g.– look for a particular score, highest score, etc.– rearrange an array of scores in increasing order


Finding the Smallest Value

1. Assume the first element is smallest so far and save its subscript

2. For each array element after the first one

2.1 If the current element < the smallest so far

2.1.1 Save the subscript of current element


Listing 9.8 Function findIndexOfMin


Listing 9.8 Function findIndexOfMin (continued)


Array Search - Interface• Input arguments

– int items[ ] // array to search– int size // number of items in array– int target // item to find

• Output arguments– none

• Returns– if found, subscript of first location in array– if not found, -1


Array Search - Algorithm

1. For each array element

1.1 If the current element contains the target

1.2 Return the subscript of the current element

2. Return -1.


Listing 9.9 The function linSearch


Sorting an Array in Ascending Order

• Many programs execute more efficiently if data is in order before processing starts

• Possible to order in either ascending or descending arrangement

• Selection sort just one of many ways to do this– reuses previous components of search and swap

operations


Selection Sort

• Input argumentsfloat items[ ] // array to sort

int n // number of items to sort

• Output argumentsint items [ ] // original array sorted

• Local variablesint i // subscript of first element

int minSub // subscript of smallest item


Selection Sort - Algorithm

1. Starting with the first item in the array (subscript 0) and ending with the next-to-last-item:

1.1 Set i equal to the subscript of the first item in the subarray to be processed in the next steps

1.2 Find the subscript (minSub) of the smallest item in the subarray with subscripts ranging from i through n-1

1.3 Exchange the smallest item found in step 1.2 with item i


Listing 9.10 Function selSort


9.6 Analyzing Algorithms: Big-O Notation• Need to estimate efficiency of algorithms in

order to compare

• Approximate the effect on an algorithm of a change in the number of items, n, that the algorithm processes

• Look at how an algorithm’s execution time increases with n (i.e. its growth rate).– Expressed in terms of largest contributing

factor of polynomial describing processing time


Table 9.4 Table values of n and n2


Analysis of a Search Algorithm

• Search an array of n elements using linear search method

• Target can be anywhere in the array

• For random data, it’s equally likely target is at end of array as at beginning

• On average, must search n/2 array elements

• Linear search is O(n) process


Analysis of Sort Algorithm

• Focus on the number of array element comparisons and exchanges required

• For selection sort, requires n-1 comparisons for 1st pass, n-2 for 2nd, etc.

• Total number of comparisons is

1 + 2 + 3 + . . . + (n-2) + (n-1)

which is n (n-1) = n2/2 - n/2

2

or O(n2)


9.7 The struct Data Type

• struct used to store related data items • Individual components of the struct are called its

members• Each member can contain different types of data• Three parts

– declaration of structure

– use of structure to define a new variable

– access of members of the structured variable

• Typically declare struct as global


struct Type Declaration

struct struct-type

{

type1 id-list1;

type2 id-list2;

. . .

typen id-listn;

};

struct employee

{

int id;

string name;

char gender;

int numDepend;

float rate;

float totWages;

};

. . .

employee organist, janitor;


Accessing Members of a struct

organist.id = 1234;

organist.name = “Noel Goddard”;

organist.gender = ‘F’;

organist.numDepend = 0;

organist.rate = 12.00;

organist.totWages = 480.0;

. . .

organist.totWages += (organist.rate * 40.0);


9.8 structs as Operands and Arguments

• struct copy or assignment

organist = janitor; // copy janitor to organist

• Copies each member from janitor struct to organist struct


Passing a struct as an Argument

• Actual and formal parameters must be same type struct

• Using structs as arguments can shorten argument list

• Passing structs by value can be inefficient, since it duplicates values of all members


Passing struct by Reference

• Same as other reference parameters– use & to identify in parameter list

• Can also use constant reference– precede parameter with reserved word const– E.g.

void printStats(const examStats& stuExams)


Listing 9.11 Function printStats


Listing 9.12 Function readEmployee


9.9 String as Arrays of Characters

• Declaring and initializing

char name[ ] = “Jackson”; // array size 8

or

char name[8] = “Jackson”; // 7 characters

• Last character stored is ‘\0’ to denote the end of the string in a character array


Reading and Writing Character Arrays

• Can read or write entire character array at once

cin >> name;

cout << name << endl;

• Can read or write each character of of array– must account for null character at end of array


9.10 Common Programming Errors• Arrays

– Out-of-range subscript references

– Unsubscripted array references

– Subscripted references to nonarray variables

– Mixing types in passing arrays to functions

• structs– References to a struct member with no prefix

– Reference to a struct member no incorrect prefix

– Missing semicolon following a struct declaration

Documents

Chapter 9 Data Structures: Arrays and Structs Lecture Notes Prepared By: Blaise W. Liffick, PhD Department of Computer Science Millersville University