ADT Unsorted List

Outline

• What is a list?
 C++ Data Types

Simple

Composite
Integral Floating
array struct union class

char short int long enum

float double long double

Address

pointer reference
 Concept: ADT List
• Abstract Data Type: A data type whose properties
(domain and operations) are specified independently
of 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

order 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 SORTED LIST

Elements are placed into elements are stored in

the list in no particular sorted order --
order. numerically or
e.g., a to-do list alphabetically by
a shopping list elements themselves, or
by a component/field of
you write them down element (called a KEY
when something occurs member) .
to you… • class list sorted by
students last name
• to-do list sorted by
• priority
• shopping list sorted
alphabetically
 ADT Unsorted List Operations
Transformers
• MakeEmpty
• PutItem change state
• DeleteItem
Observers
• IsFull
• GetLength observe state
• GetItem
Iterators
• ResetList
process all
• GetNextItem
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 • class template
template<class T> template<class T>
void swap (T & x, T & y) class Pair {
{ {
public:
T tmp;
Pair (T f, T s);
tmp = x;
// …
x = y; private:
y = tmp; T first;
} T second;
double a[2]={3,4}; }
swap (a[1], a[2]); 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. )
ItemType Class Interface Diagram

class ItemType

ComparedTo

Private data
Print
value

Initialize
// 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
UnsortedType
Private data:
IsFull
length
GetLength
info [0]
GetItem [1]
[2]
PutItem
[MAX_ITEMS-1]
DeleteItem
currentPos this (using static
ResetList array) is just one
GetNextItem way to
implement it…
// 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++;
}
14
 Before Inserting Hsing into an

Unsorted List
length 3 The item will
be placed into
the length location,
info [0] Maxwell and length will be
incremented.
[1] Bradley
[2] Asad
[3]
.
.
.

[MAX_ITEMS-1]
After Inserting Hsing into an

Unsorted List
length 4

info [0] Maxwell

[1] Bradley
[2] Asad
[3] Hsing
.
.
.
[MAX_ITEMS-1]
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 );
}
17
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
}

18
Getting Ivan from an Unsorted List

length 4 moreToSearch: true

found: false
info [0] Maxwell location: 0
[1] Bradley
[2] Asad
[3] Hsing
.
.

[MAX_ITEMS-1]
Getting Ivan from an Unsorted List

length 4 moreToSearch: true

found: false
info [0] Maxwell location: 1
[1] Bradley
[2] Asad
[3] Hsing
.
.

[MAX_ITEMS-1]
Getting Ivan from an Unsorted List
length 4 moreToSearch: true
found: false
info [0] Maxwell
location: 2
[1] Bradley
[2] Asad
[3] Hsing
.
.
.
[MAX_ITEMS-1]
Getting Ivan from an Unsorted List
length 4 moreToSearch: true
found: false
info [0] Maxwell
location: 3
[1] Bradley
[2] Asad
[3] Hsing
.
.
.
[MAX_ITEMS-1]
Getting Ivan from an Unsorted List

length 4 moreToSearch: false

found: false
info [0] Maxwell location: 4
[1] Bradley
[2] Asad
[3] Hsing
.
.
.

[MAX_ITEMS-1]
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
length 4
location: 0
info [0] Maxwell

[1] Bradley
[2] Asad Key Bradley has
not been matched.
[3] Hsing
.
.
.
[MAX_ITEMS-1]
Deleting Bradley from an Unsorted List

length 4

info [0] Maxwell location: 1

[1] Bradley
[2] Asad
[3] Hsing Key Bradley has
. been matched.
.
.
[MAX_ITEMS-1]
Deleting Bradley from an Unsorted List
length 4
location: 1
info [0] Maxwell

[1] Hsing
[2] Asad Placed copy of
[3] Hsing last list element
into the position
.
where the key Bradley
.
was before.
.

[MAX_ITEMS-1]
Deleting Bradley from an

Unsorted List

length 3
location: 1
info [0] Maxwell

[1] Hsing
[2] Asad Decremented length.
[3] Hsing
.
.
.
[MAX_ITEMS-1]
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)

{ This is a common
int length; way to access all
items in a list one by one,
ItemType item;
following linear relationship
list.ResetList();
for (int i=1; i<=length; i++)
{
item = list.GetNextItem();
item.Print ();
}
}
Specifying class ItemType to store int
// 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
} ;
// 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
operators 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
of 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; 2000
x = 12; 12
x

int* ptr; 3000

ptr = &x; 2000
ptr
NOTE: Because ptr holds the address of x,
we say that ptr “points to” x
Unary operator * is deference
(indirection) operator
2000
int x;
12
x = 12;
x

3000
int* ptr;
ptr = &x; 2000
ptr
std::cout << *ptr;

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

 Using dereference operator

int x; 2000
x = 12; 12 5
x

int* ptr; 3000

ptr = &x; 2000
ptr
*ptr = 5; // changes the value
// at adddress ptr to 5
 Another Example
char ch;
4000
ch = ‘A’;
A Z

char* q; ch

q = &ch; 5000 6000

4000 4000
*q = ‘Z’; q p
char* p;
p = q; // the right side has value 4000
// now p and q both point to ch
 C++ Data Types

Simple

Structured
Integral Floating
array struct union class

char short int long enum

float double long double

Address

pointer reference 38
 Dynamically Allocated Data

2000
char* ptr;

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

New is an operator
 Dynamically Allocated Data

2000

char* ptr;
ptr

ptr = new char;

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



NOTE: Dynamic data has no variable name

 Dynamically Allocated Data

2000

char* ptr;
ptr

ptr = new char;

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


 Dynamically Allocated Data
2000
?
char* ptr; ptr

ptr = new char;

*ptr = ‘B’; NOTE: delete
deallocates memory
std::cout << *ptr;
pointed to by ptr.
delete 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
}
Using operator delete

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.
What happens here?
int* ptr = new int; 3
*ptr = 3;
ptr
ptr = new int; // changes value of ptr
*ptr = 4;

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;

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

How else can an object become inaccessible?

Causing a Memory Leak

int* ptr = new int; 8

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

8
ptr

-5
ptr2
 A Dangling Pointer
• 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;
8
*ptr2 = -5;
ptr = ptr2; ptr

-5
ptr2

FOR EXAMPLE,
Leaving a Dangling Pointer

int* ptr = new int;

*ptr = 8; 8
int* ptr2 = new int; ptr
*ptr2 = -5;
-5
ptr = ptr2;
ptr2
delete ptr2; // ptr is left dangling
ptr2 = NULL;
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 change state
• DeleteItem
Observers
• IsFull
• GetLength observe state
• GetItem
Iterators
• ResetList
process all
• GetNextItem
#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?

53
class UnsortedType<char>

UnsortedType
Private data:
MakeEmpty
length 3
~UnsortedType
listData ‘X’ ‘C’ ‘L’
GetItem
currentPos ?
PutItem

DeleteItem
.
.
.

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

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

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

57
Inserting ‘B’ into an Unsorted List

Private data:
length 3

listData ‘X’ ‘C’ ‘L’

currentPos ?
 location = new NodeType;
item ‘B’

location

Private data:
length 3

listData ‘X’ ‘C’ ‘L’

currentPos ?
item ‘B’ location->info = item ;

location ‘B’

Private data:
length 3

listData ‘X’ ‘C’ ‘L’

currentPos ?
item ‘B’ location->next = listData ;

location ‘B’

Private data:
length 3

listData ‘X’ ‘C’ ‘L’

currentPos ?
item
listData = location ;
‘B’

location ‘B’

Private data:
length 3

listData ‘X’ ‘C’ ‘L’

currentPos ?
item
length++ ;
‘B’

location ‘B’

Private data:
length 4

listData ‘X’ ‘C’ ‘L’

currentPos ?