Using Arrays in Abstract Data Types

2003 Prentice Hall, Inc. All rights reserved.

Using Arrays in Abstract Data Types


What is an Abstract Data Type

• A built-in data type is an int, float, double, etc.• An Abstract Data Type (ADT) is a collection of

data and a set of operations on the data. You can use an ADT’s operations, if you know their specifications, without knowing how the operations are implemented or how the data is stored. Ultimately, you will implement an ADT with a data-structure, which is a construct you can define within a programming language to store a collection of data.

• Examples of ADT: lists, stacks, queues, trees, graphs, etc.


ADT: SIMPLE LIST

Examples of lists: lists of student id’s in a class, grocery items, lists of records in a collection, list of club members, etc….

Create a list

Insert an element

Arrange elements in sorted order

Find if an element is in the list

Delete an element

Print the list of elements

WHAT ARE BASIC OPERATIONS ON A LIST?


What operations are likely to be performed on lists?

Create/Insert an element

Delete an element

Arrange elements in sorted order (whatever sort criteria)

Print the list of elements

Find if an element is in the list

Print statistics about list (if numeric)

Grocery items:ChipsSalsaCoke

Tissues Sprite

Jelly beans

Original list

Grocery items:ChipsSalsaCoke

Tissues Sprite

Jelly beansBeer

Add Beer

Grocery items:ChipsSalsaCokeSprite

Jelly beansBeer

Delete tissues

Grocery items:BeerChipsCoke

Jelly beans SalsaSprite

Sort alphabetically

Grocery items:BeerCoke Sprite

Jelly beans ChipsSalsa

Sort by grocery aisles

Is beer on the list?


Implementation of the ADT List

One way to implement a “list” is using an array to hold the elements in the list…..

Now have to figure out how to : insert, delete, sort, find, etc….

In the next lessons, we will slowly build up these functionalities until we can integrate them all into a “list” program. EVENTUAL GOAL : CREATE A PROGRAM TO MAINTAIN A LIST OF STUDENTS……….


Let’s make a simpler list

• Instead of strings, we will have a list of letters

const int MAXCHARS = 7;

char alpharray[MAXCHARS];

B J K M S Z

0 1 2 3 4 5 6 7


Print Elements in a list

for (i=0; i<numofelements; i++)

cout << alpharray[i] << endl;

Input elements into the list:// numtoinsert should be set to the number of initial elements

to insert

for (i=0; i<numtoinsert; i++)

cin >> alpharray[i];


Insert an element into an array

• Simple insert routine: find end of array, insert element:

alpharray[endofarray] = newelement;

endofarray++;

B J K M S Z

B J K M S Z L

Before:

After inserting L


Insert a letter in the list

• Should it be inserted at the end of the list (in this case we need to know what is the end of the list)?

• Should the new element be inserted into the beginning of the list?

• Is the list stored in some special order and elements should be inserted to maintain that order – e.g., if the list is stored in alphabetical order the new element must be inserted in alphabetical order?

• Should the user choose where to store the new element?


Assume the following letters are stored in array named alpharray: B, J, K, M, S, and Z. Write a program which calls a function adlet(), which accepts both the alphabet array and a new letter as parameters and inserts the new letter in the correct alphabetical order in the alphabet array.

B J K M S Z

alphabet [0] [1] [2] [3] [4] [5] [6] [7] …...

B J K L M S ZAfter adding ‘L’

Before:

INSERTING INTO A ARRAY BASED Alphabetical LIST


ALGORITHM:

•Prompt user for new letter to add

•Find the position (index) of where this letter should go in the alphabetical array. (This is called a linear search.)

•Move all letters after this position down to free up the space

•Insert letter into array****


#include <iostream>void insertletter(char[],char,int&);

int main() { const int MAXCHARS = 30; const int STARTCHARS=6; char alpharray[MAXCHARS] = {‘B’, ‘J’, ‘K’, ‘M’,’S’,’Z’}; char newlet; int sizeofarray=STARTCHARS;

while (5) { //loop forever

cout << “ Enter a letter to add:”; cin >> newlet; insertletter(alpharray,newlet,sizeofarray); } }

CONTINUED…..


Find position for new letter

//find position for new letter

while (alpharray[i] < addlet && i < sizeofarray)

i++;

newpos =i;


Find position for new letter

//move chars over --- should check for full array first

if (sizeofarr == MAXCHARS) …..

for (i=sizeofarr; i>newpos; i--)

alpharray[i] = alpharray[i-1];


void insertletter(char alpharray[], char addlet, int& sizeofarr){ int i=0, endpos,newpos; //find position for new letter while (alpharray[i] < addlet && i < sizeofarr) i++; newpos =i; //move chars over --- should check for full array first for (i=sizeofarr; i>newpos; i--) alpharray[i] = alpharray[i-1];

alpharray[newpos] = addlet; //insert new letter sizeofarr++; //print out array for(i=0; i<sizeofarr; i++) cout <<alpharray[i]; }


Analysis of the simple insertion algorithm

• In the worst case --- How many comparisons are needed to find the position of the letter to be inserted?

• In the worst case --- How many letters have to be shifted to make room for a new letter to be inserted?

• Are these the same cases?


void insertletter(char alpharray[], char addlet, int& sizeofarr)

{

int i=0, endpos,newpos;

//find position for new letter

while (alpharray[i] < addlet && i < sizeofarr)

i++;

newpos =i;

//move chars over --- should check for full array first

for (i=sizeofarr; i>newpos; i--)

alpharray[i] = alpharray[i-1];

alpharray[newpos] = addlet; //insert new letter

sizeofarr++; //print out array

for(i=0; i<sizeofarr; i++) cout <<alpharray[i];

What happens if the array is full?

Can we use this code to insert elements into an empty list?

If (sizeofarr == 0) { alpharray[0] = addlet; sizeofarr++; return 0; }


Delete an element from a list

• Must find the element to delete:• Then move everything over


Delete

Let’s assume we are given the position of the item to delete in delpos;

DeleteElement(char alpharray[], int delpos, int& sizeofarr)

{

for (i=delpos+1; i<sizeofarr; i++)

alpharray[i-1] = alpharray[i];

sizeofarr--;

}


ADT LIST:

• DONE: Insert element at end of a list; Insert element into previously sorted list

• TO DO: Sort List, Delete element, Create list, Find Element…..


ADT: List

• Operation: sort.

• Given a list of unordered values in an array, sort the values so that they can be printed in sorted order.


SIMPLE Sorting

• Sorting is a typical operation to put the elements in an array in order.

• Internal Sorts [for small data sets]selectionbubble (exchange)

• External Sorts [for large data sets]


Simple Sorting Selection sort

Find smallest element, andput at the head of the list, repeatwith remainder of list. The algorithm can also be formulated by finding the largest element and putting that at the head of the list


Selection Sort

index (k) sm_index

0 2swap 21, 9

1 1swap 13, 13

2 3swap 21, 15

3 4swap 21, 17

21 159 13 17

15 179 13 21

99 152121 13 17

15 21219 13 1717

2121 15159 13 17

Find smallest element, andput at the head of the list,repeatwith remainder of list

Scan 1

Scan 2

Scan 3

Scan 4


Selection Sort

const int size = 5;void sort(double [size]);void swap(double [size], int, int) // prototypes

int main(void){ int index;

double my_list[ ] = {21, 13, 9, 15, 17};

sort(my_list); // function call

cout<<"\nThe sorted array is: \n";for(index=0; index<size; index++)

cout<<'\t'<<my_list[index]<<endl;

…}


Let’s build up the algorithm

outer loop – array scans, each scan starts from the element after the previous scan

inner loop – find smallest element

swap smallest element with start of scan

next outer loop


Selection Sort

void sort(double testArray[]){ int n, k, sm_index, moves=0; double smallest;

for(k=0; k<size; k++) // size-1 = number of passes{

}}

smallest=testArray[k];sm_index=k;

swap(testArray, sm_index, k); // call to swap()

for(n=k+1; n<size; n++) if(testArray[n]<smallest) { smallest=testArray[n];

sm_index=n; }


Selection Sort

void swap(double testArray[], int smaller, int pass){ // pass = current position: k

double temp;

temp=testArray[pass];testArray[pass]=testArray[smaller];testArray[smaller]=temp;

}


for(k=0; k<size; k++) // size-1 = number of passes{

}}

smallest=testArray[k];sm_index=k;

swap(testArray, sm_index, k); // call to swap()

for(n=k+1; n<size; n++) if(testArray[n]<smallest) { smallest=testArray[n];

sm_index=n; }

How many times is the inner if statement called?

How many times is the “sm_index” being reset?

How many times is the swap() function called?


30

4.6 Sorting Arrays

• Sorting data– Important computing application

– Virtually every organization must sort some data • Massive amounts must be sorted

• Bubble sort (sinking sort) – Several passes through the array

– Successive pairs of elements are compared • If increasing order (or identical), no change

• If decreasing order, elements exchanged

– Repeat these steps for every element


31

Simple SortingBubble sort

• As we scan the list swap elements out of order.• After the first scan, the largest element will be at

the end of the list. • Keep scanning the list until all of the elements are

in the correct place.

• Bubble sort – because the small elements bubble up to the top…..


32

4.6 Sorting Arrays

• Example:– Go left to right, and exchange elements as necessary

• One pass for each element

– Original: 3 4 2 7 6

– Pass 1: 3 2 4 6 7 (elements exchanged)

– Pass 2: 2 3 4 6 7

– Pass 3: 2 3 4 6 7 (no changes needed)

– Pass 4: 2 3 4 6 7

– Pass 5: 2 3 4 6 7

– Small elements "bubble" to the top (like 2 in this example)


Bubble Sort

• Put smaller first


• No change

• Put smaller first21 252513 9 1717

2121 252513 9 17

99 252121 13 17

9 2513 21 17


Bubble Sort

• Begin again and put smaller first

• No change


21 179 13 25

17 21219 13 2525

2121 171313 9 25

2121 17179 13 25


Bubble Sort Example 2

• Begin --Put smaller first


• No change

• Put smaller first19 252518 13 1212

1919 252518 13 12

1313 251919 18 12

13 2518 19 12


Bubble Sort – Example 2

• Begin again and put smaller first

• No change


19 1213 18 25

12 191913 18 2525

1919 121818 13 25

1919 121213 18 25


Bubble Sort – Example 2

• Begin again -- no change

• Swap – put smaller first

• Begin Again -- swap

• Sorted list

12 1913 18 25

18 191912 13 2525

1212 191313 18 25

1818 191913 12 25


38

Let’s build up the algorithm – bubble sort

outer loop – array scans, each scan starts from the first element of the list until _________

inner loop

compare adjacent elements and swap

next outer loop


39

4.6 Sorting Arrays

• Swapping variablesint x = 3, y = 4;

y = x;

x = y;

• What happened?– Both x and y are 3!

– Need a temporary variable

• Solutionint x = 3, y = 4, temp = 0;

temp = x; // temp gets 3

x = y; // x gets 4

y = temp; // y gets 3

2003 Prentice Hall, Inc.All rights reserved.

Outline40

fig04_16.cpp(1 of 3)

1 // Fig. 4.16: fig04_16.cpp2 // This program sorts an array's values into ascending order.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 int main()13 {14 const int arraySize = 10; // size of array a15 int a[ arraySize ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };16 int hold; // temporary location used to swap array elements17 18 cout << "Data items in original order\n";19 20 // output original array21 for ( int i = 0; i < arraySize; i++ )22 cout << setw( 4 ) << a[ i ];23


Outline41


24 // bubble sort 25 // loop to control number of passes 26 for ( int pass = 0; pass < arraySize - 1; pass++ ) 27 28 // loop to control number of comparisons per pass 29 for ( int j = 0; j < arraySize - 1; j++ ) 30 31 // compare side-by-side elements and swap them if32 // first element is greater than second element 33 if ( a[ j ] > a[ j + 1 ] ) { 34 hold = a[ j ]; 35 a[ j ] = a[ j + 1 ]; 36 a[ j + 1 ] = hold; 37 38 } // end if 39

Do a pass for each element in the array.

If the element on the left (index j) is larger than the element on the right (index j + 1), then we swap them. Remember the need of a temp variable.


Outline42


fig04_16.cppoutput (1 of 1)

40 cout << "\nData items in ascending order\n";41 42 // output sorted array43 for ( int k = 0; k < arraySize; k++ )44 cout << setw( 4 ) << a[ k ];45 46 cout << endl;47 48 return 0; // indicates successful termination49 50 } // end main

Data items in original order

2 6 4 8 10 12 89 68 45 37

Data items in ascending order

2 4 6 8 10 12 37 45 68 89


43

Can we improve the algorithm?

• In the first example, we did not have to keep scanning the list since the list was sorted after the “2nd” scan……

Check to see if any swaps were performed on the previous inner loop. If none were performed do not scan the list anymore since it is sorted. ---- WE CAN END THE ALGORITHM EARLY: EARLY TERMINATION how can we accomplish this?


Outline44

24 // bubble sort 25 int flag = 1; 26 for ( int pass = 0; (pass < arraySize – 1) && flag; pass++ ) 27 flag = 0; 28 // loop to control number of comparisons per pass 29 for ( int j = 0; j < arraySize - 1; j++ ) 30 31 // compare side-by-side elements and swap them if32 // first element is greater than second element 33 if ( a[ j ] > a[ j + 1 ] ) { 34 hold = a[ j ]; 35 a[ j ] = a[ j + 1 ]; • a[ j + 1 ] = hold; • flag = 1; //set flag since swap occurred

37 38 } // end if 39

Bubble sort with early termination

Possible early termination


Outline45

24 // bubble sort 25 // loop to control number of passes 26 for ( int pass = 0; pass < arraySize - 1; pass++ ) 27 28 // loop to control number of comparisons per pass 29 for ( int j = 0; j < arraySize - 1; j++ ) 30 31 // compare side-by-side elements and swap them if32 // first element is greater than second element 33 if ( a[ j ] > a[ j + 1 ] ) { 34 hold = a[ j ]; 35 a[ j ] = a[ j + 1 ]; 36 a[ j + 1 ] = hold; 37 38 } // end if 39

How many times does the outer loop execute in the worst case?

How many times is the swap performed (inner loop) in the worst case?

Date post:	02-Jan-2016
Category:	Documents
Upload:	dante-martinez
View:	34 times
Download:	7 times

Using Arrays in Abstract Data Types

Documents