ADT Unsorted List Outline What is a list? C++ Data Types Simple - - PowerPoint PPT Presentation

ADT Unsorted List

Outline

• What is a list?

C++ Data Types

Composite

array struct union class

Address

pointer reference

Simple

Integral Floating char short int long enum float double long double

Concept: ADT List

• Abstract Data Type: A data type whose properties

(domain and operations) are specified independently

• f any particular implementation.
• ADT list is a homogeneous collection of elements,

with linear relationship among elements

• each element except the first has a unique

predecessor, and each element except the last has a unique successor.)

• Each element in list can be of any type: simple,

composite, address, or list, …

• Often times, element is a struct or a class type
• one field/attribute of the struct/class is used as key

field (used to search for element, sort elements)

Examples

You anticipate a busy day ahead, and decide to write down tasks that you need to finish: Typically you write down things as they occur to you… Check emails and answer urgent emails Make doctor’s appointment Attend a meeting Start on math homework Revise history essay …. Elements (tasks) are arranged in no particular order. This is an Unsorted List.

Examples: cont’d

You anticipate a busy day ahead, and decide to write down tasks that you need to finish: Check emails and answer urgent emails Make doctor’s appointment Attend a meeting Start on math homework Revise history essay …. If you assign a priority to each task, and rearrange todo-list in the

• rder of priority, then it’s a sorted list

1 Start on math homework 2 Revise history essay 3 Attend a meeting 5 Make doctor’s appointment 8 Check emails…

Sorted and Unsorted Lists

UNSORTED LIST Elements are placed into the list in no particular

• rder.

e.g., a to-do list a shopping list you write them down when something occurs to you… SORTED LIST elements are stored in sorted order -- numerically or alphabetically by elements themselves, or by a component/field of element (called a KEY member) .

• class list sorted by

students last name

• to-do list sorted by
• priority
• shopping list sorted

alphabetically

ADT Unsorted List Operations

Transformers

• MakeEmpty
• PutItem
• DeleteItem

Observers

• IsFull
• GetLength
• GetItem

Iterators

• ResetList
• GetNextItem

change state

• bserve state

process all

What is a Generic Data Type?

• Build ADT Unsorted List as a generic data type,

means that items being stored in the list is not specified, i.e., it can be of any type

• Advantage: we implement it once, and use it to store

different lists:

• list of to-dos, list of numbers, list of student

records, …

• We have used generic data type before:
• vector<int>, vector<double>, vector<DateType> …
• vector is a generic data type implemented in C++

Standard Template Library

Recall from CS2…

• function template

template<class T> void swap (T & x, T & y) { T tmp; tmp = x; x = y; y = tmp; } double a[2]={3,4}; swap (a[1], a[2]);

• class template

template<class T> class Pair { { public: Pair (T f, T s); // … private: T first; T second; }

Pair<int> pair1 (3,4);

generic programming without template?

For now, we simulate a generic data type without using template:

• implement ADT list to store elements of a user-

defined class ItemType

• User (of ADT list) can define ItemType to

encapsulate any type of items as needed

• as long as ItemType provides member function to

compare two items’ keys

• In sample code, member function is named

ComparedTo, and returns an enumerated type value LESS, GREATER, or EQUAL. )

Private data value ComparedTo Print Initialize

class ItemType

ItemType Class Interface Diagram

// SPECIFICATION FILE ( unsorted.h ) #include “ItemType.h” class UnsortedType // declares a class data type { public : // 8 public member functions void UnsortedType ( ); bool IsFull ( ) const; int GetLength ( ) const ; // returns length of list ItemType GetItem ( ItemType item, bool& found); void PutItem ( ItemType item ); void DeleteItem ( ItemType item ); void ResetList ( ); ItemType GetNextItem (); private : // 3 private data members int length; ItemType info[MAX_ITEMS]; int currentPos; };

Class Constructor Rules

1 A constructor cannot return a function value, and has no return value type. 2 A class may have several constructors. The compiler chooses the appropriate constructor by the number and types of parameters used. 3 Constructor parameters are placed in a parameter list in the declaration of the class object. 4 The parameterless constructor is the default constructor. 5 If a class has at least one constructor, and an array of class objects is declared, then one of the constructors must be the default constructor, which is invoked for each element in the array.

Class Interface Diagram

UnsortedType class

IsFull GetLength ResetList DeleteItem PutItem UnsortedType GetItem GetNextItem

Private data: length info [ 0 ]

[ 1 ] [ 2 ] [MAX_ITEMS-1]

currentPos

this (using static array) is just one way to implement it…

14

// IMPLEMENTATION FILE ARRAY-BASED LIST ( unsorted.cpp ) #include “itemtype.h” void UnsortedType::UnsortedType ( ) // Pre: None. // Post: List is empty. { length = 0; } void UnsortedType::InsertItem ( ItemType item ) // Pre: List has been initialized. List is not full. // item is not in list. // Post: item is in the list. { info[length] = item; length++; }

Before Inserting Hsing into an
 Unsorted List

length 3 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

. . .

[MAX_ITEMS-1]

The item will be placed into the length location, and length will be incremented.

After Inserting Hsing into an
 Unsorted List

length 4 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

Hsing . . .

[MAX_ITEMS-1]

17

int UnsortedType::GetLength( ) const // Pre: List has been inititalized. // Post: Function value == ( number of elements in // list ). { return length; } bool UnsortedType::IsFull ( ) const // Pre: List has been initialized. // Post: Function value == ( list is full ). { return ( length == MAX_ITEMS ); }

18

ItemType UnsortedType::GetItem ( ItemType item, bool& found ) // Pre: Key member of item is initialized. // Post: If found, item’s key matches an element’s key in the list // and a copy of that element is returned; // otherwise, input item is returned. { bool moreToSearch; int location = 0; found = false; moreToSearch = ( location < length ); while ( moreToSearch && !found ) { switch ( item.ComparedTo( info[location] ) ) { case LESS : case GREATER : location++; moreToSearch = ( location < length ); case EQUAL : found = true; item = info[ location ]; break; } } return item }

Getting Ivan from an Unsorted List

moreToSearch: true found: false location: 0

length 4 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

Hsing . .

[MAX_ITEMS-1]

Getting Ivan from an Unsorted List

length 4 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

Hsing . .

[MAX_ITEMS-1]

moreToSearch: true found: false location: 1

Getting Ivan from an Unsorted List

length 4 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

Hsing . . .

[MAX_ITEMS-1]

moreToSearch: true found: false location: 2

Getting Ivan from an Unsorted List

length 4 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

Hsing . . .

[MAX_ITEMS-1]

moreToSearch: true found: false location: 3

Getting Ivan from an Unsorted List

length 4 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

Hsing . . .

[MAX_ITEMS-1]

moreToSearch: false found: false location: 4

void UnsortedType::DeleteItem ( ItemType item ) // Pre: item’s key has been inititalized. // An element in the list has a key that matches item’s. // Post: No element in the list has a key that matches item’s. { int location = 0 ; while (item.ComparedTo (info [location] ) != EQUAL ) location++; // move last element into position where item was located info [location] = info [length - 1 ] ; length-- ; }

Deleting Bradley from an Unsorted List

location: 0

length 4 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

Hsing . . .

[MAX_ITEMS-1]

Key Bradley has not been matched.

Deleting Bradley from an Unsorted List

location: 1 Key Bradley has been matched.

length 4 info [ 0 ] Maxwell

[ 1 ] Bradley

[ 2 ]

Asad

[ 3 ]

Hsing . . .

[MAX_ITEMS-1]

Deleting Bradley from an Unsorted List

location: 1

length 4 info [ 0 ] Maxwell

[ 1 ] Hsing

[ 2 ]

Asad

[ 3 ]

Hsing . . .

[MAX_ITEMS-1]

Placed copy of last list element into the position where the key Bradley was before.

Deleting Bradley from an
 Unsorted List

location: 1

length 3 info [ 0 ] Maxwell

[ 1 ] Hsing

[ 2 ]

Asad

[ 3 ]

Hsing . . .

[MAX_ITEMS-1]

Decremented length.

void UnsortedType::ResetList ( ) // Pre: List has been inititalized. // Post: Current position is prior to first element in list. { currentPos = -1; } ItemType UnsortedType::GetNextItem () // Pre: List has been initialized. Current position is defined. // Element at current position is not last in list. // Post: Current position is updated to next position. // item is a copy of element at current position. { currentPos++; item = info [currentPos]; }

Example: Iterating through an unsorted list

void PrintList (UnsortedList list) { int length; ItemType item; list.ResetList(); for (int i=1; i<=length; i++) { item = list.GetNextItem(); item.Print (); } }

This is a common way to access all items in a list one by one, following linear relationship

// SPECIFICATION FILE ( itemtype.h ) const int MAX_ITEM = 5 ; enum RelationType { LESS, EQUAL, GREATER }; class ItemType // declares class data type { public : // 3 public member functions RelationType ComparedTo ( ItemType ) const; void Print ( ) const; void Initialize ( int number ) ; private : // 1 private data member int value ; // could be any different // type, including a class } ;

Specifying class ItemType to store int

// IMPLEMENTATION FILE ( itemtype.cpp ) // Implementation depends on the data type of value. #include “itemtype.h” #include <iostream> RelationType Itemtype::ComparedTo(ItemType otherItem) const { if ( value < otherItem.value ) return LESS; else if ( value > otherItem.value ) return GREATER; else return EQUAL; } void ItemType::Print ( ) const { using namespace std; cout << value << endl; } void ItemType::Initialize ( int number ) { value = number; }

Practice #1

• Download source codes to your computer
• cpUnsortedList
• Compile and link unsorted.cpp, ItemType.cpp, listDriver.cpp and run it
• Declare an ItemType to store Appointment class
• so that we can create a unsortedList of appointments…
• Wrap DateType up in ItemType
• or give an alias to DateType as ItemType?
• Modify listDriver.cpp to test unsorted list of appointment.
• How do you modify an element in the list?
• e.g., change description of a particular appointment in the list

Practice #2: switch to use operators

• Modify UnsortedList so that comparison operators are used instead of

CompareTo() method

• Now we can use any data type that have overloaded comparison
• perators with unsorted list:
• for example: to create a list of int:
• give an alias to int as ItemType before defining UnsortedList

typedef int ItemType; // class UnsortedList{ public: … ItemType GetItem (ItemType item, bool & found); … private: ItemType info[MAX_ITEMS]; };

What is a pointer variable?

• A pointer variable is a variable whose value is the address
• f a location in memory.
• To declare a pointer variable, you must specify type of

value that the pointer will point to. int* ptr; // ptr will hold the address of an int char* q; // q will hold the address of a char

Using a pointer variable

int x; x = 12; int* ptr; ptr = &x;

NOTE: Because ptr holds the address of x, we say that ptr “points to” x

2000 12 x 3000 2000 ptr

2000 12 x 3000 2000 ptr

int x; x = 12; int* ptr; ptr = &x; std::cout << *ptr;

NOTE: the int pointed to by ptr is denoted by *ptr

Unary operator * is deference (indirection) operator

int x; x = 12; int* ptr; ptr = &x; *ptr = 5; // changes the value

// at adddress ptr to 5

Using dereference operator

2000 12 5 x 3000 2000 ptr

char ch; ch = ‘A’; char* q; q = &ch; *q = ‘Z’; char* p; p = q; // the right side has value 4000

// now p and q both point to ch

Another Example

4000 A Z ch 5000 6000 4000 4000 q p

38

C++ Data Types

Structured

array struct union class

Address

pointer reference

Simple

Integral Floating char short int long enum float double long double

2000 ptr

Dynamically Allocated Data

char* ptr; ptr = new char; *ptr = ‘B’; std::cout << *ptr;

New is an operator

Dynamically Allocated Data

char* ptr; ptr = new char; *ptr = ‘B’; std::cout << *ptr; 


NOTE: Dynamic data has no variable name

2000 ptr

Dynamically Allocated Data

char* ptr; ptr = new char; *ptr = ‘B’; std::cout << *ptr; 


2000 ptr ‘B’

Dynamically Allocated Data

char* ptr; ptr = new char; *ptr = ‘B’; std::cout << *ptr; delete ptr;

2000 ptr

NOTE: delete deallocates memory pointed to by ptr.

?

NULL Pointer

There is a pointer constant called NULL available in cstddef. NULL is not a memory address; it means that the pointer variable points to nothing.

It is an error to dereference a pointer whose value is

• NULL. It is the programmer’s job to check for this.

while (ptr != NULL)

{

. . . // ok to use *ptr here }

The object or array currently pointed to by the pointer is deallocated, i.e.,the memory is returned to the free store (or heap). Square brackets are used with delete to deallocate a dynamically allocated array of classes.

Using operator delete

int* ptr = new int; *ptr = 3; ptr = new int; // changes value of ptr *ptr = 4;

What happens here?

3 ptr 3 ptr 4

Memory Leak

A memory leak occurs when dynamic memory (that was created using operator new) has been left without a pointer to it by the programmer, and so is inaccessible. int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; 8 ptr

• 5

ptr2

How else can an object become inaccessible?

Causing a Memory Leak

int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; ptr = ptr2; // here the 8 becomes inaccessible

8 ptr

• 5

ptr2 8 ptr

• 5

ptr2

• occurs when two pointers point to the same object and delete is

applied to one of them.

int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; ptr = ptr2;

A Dangling Pointer

8 ptr

• 5

ptr2 FOR EXAMPLE,

int* ptr = new int; *ptr = 8; int* ptr2 = new int; *ptr2 = -5; ptr = ptr2; delete ptr2; // ptr is left dangling ptr2 = NULL;

Leaving a Dangling Pointer

8 ptr

• 5

ptr2 8 ptr NULL ptr2

Now: implement a list using linked list

• A list is a homogeneous collection of

elements, with a linear relationship between elements.

• That is, each list element (except the

first) has a unique predecessor, and each element (except the last) has a unique successor.

ADT Unsorted List Operations

Transformers

• MakeEmpty
• PutItem
• DeleteItem

Observers

• IsFull
• GetLength
• GetItem

Iterators

• ResetList
• GetNextItem

change state

• bserve state

process all

53

#include “ItemType.h” // unsorted.h . . . class UnsortedType { public : // LINKED LIST IMPLEMENTATION // The public interface is the same private : // The private part is different NodeType<ItemType>* listData; int length; NodeType<ItemType>* currentPos; }; Do we have to keep a length field? Do we need an IsFull?

class UnsortedType<char>

MakeEmpty ~UnsortedType DeleteItem

. . .

PutItem UnsortedType GetItem GetNextItem

‘X’ ‘C’ ‘L’ Private data: length 3 listData currentPos ?

55

// LINKED LIST IMPLEMENTATION ( unsorted.cpp ) #include “itemtype.h” UnsortedType::UnsortedType ( ) // constructor // Pre: None. // Post: List is empty. { length = 0; listData = NULL; } int UnsortedType::GetLength( ) const // Post: Function value = number of items in the list. { return length; }

56

ItemType UnsortedType::GetItem( ItemType item, bool& found ) // Pre: Key member of item is initialized. // Post: If found, item’s key matches an element’s key in the list // a copy of that element is returned; otherwise, // origianl item is returned. { bool moreToSearch; NodeType<ItemType>* location; location = listData; found = false ; moreToSearch = ( location != NULL ); while ( moreToSearch && !found ) { if ( item == location->info ) // match here { found = true; item = location->info; } else // advance pointer { location = location->next; moreToSearch = ( location != NULL ); } 
 } return item; }

57

void UnsortedType::PutItem ( ItemType item ) // Pre: list is not full and item is not in list. // Post: item is in the list; length has been incremented. { NodeType<ItemType>* location; // obtain and fill a node location = new NodeType<ItemType>; location->info = item; location->next = listData; listData = location; length++; }

Inserting ‘B’ into an Unsorted List

‘X’ ‘C’ ‘L’

Private data: length 3 listData currentPos ?

location = new NodeType;

‘X’ ‘C’ ‘L’

Private data: length 3 listData currentPos ? item location ‘B’

location->info = item ;

‘X’ ‘C’ ‘L’

Private data: length 3 listData currentPos ? item location ‘B’ ‘B’

location->next = listData ;

‘X’ ‘C’ ‘L’

Private data: length 3 listData currentPos ? item location ‘B’ ‘B’

listData = location ;

‘X’ ‘C’ ‘L’

Private data: length 3 listData currentPos ? item location ‘B’ ‘B’

length++ ;

‘X’ ‘C’ ‘L’

Private data: length 4 listData currentPos ? item location ‘B’ ‘B’