Download - C++ Plus Data Structures
![Page 1: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/1.jpg)
1
C++ Plus Data Structures
Nell DaleChapter 5
Linked Structures
Modified from the slides by Sylvia Sorkin, Community College of Baltimore County - Essex Campus
![Page 2: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/2.jpg)
2
Definition of Stack
Logical (or ADT) level: A stack is an ordered group of homogeneous items (elements), in which the removal and addition of stack items can take place only at the top of the stack.
A stack is a LIFO “last in, first out” structure.
![Page 3: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/3.jpg)
Stack ADT Operations
MakeEmpty -- Sets stack to an empty state.
IsEmpty -- Determines whether the stack is currently
empty.
IsFull -- Determines whether the stack is currently full.
Push (ItemType newItem) -- Adds newItem to the top of the stack.
Pop (ItemType& item) -- Removes the item at the top
of the stack and returns it in item.3
![Page 4: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/4.jpg)
ADT Stack Operations
Transformers MakeEmpty Push Pop
Observers IsEmpty IsFull
change state
observe state
4
![Page 5: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/5.jpg)
5
Another Stack Implementation
One advantage of an ADT is that the kind of implementation used can be changed.
The dynamic array implementation of the stack has a weakness -- the maximum size of the stack is passed to the constructor as parameter.
Instead we can dynamically allocate the space for each stack element as it is pushed onto the stack.
![Page 6: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/6.jpg)
6
Tracing Client Codeletter ‘V’
char letter = ‘V’;
StackType< char > myStack;
myStack.Push(letter);
myStack.Push(‘C’);
myStack.Push(‘S’);
if ( !myStack.IsEmpty( ) ) myStack.Pop( letter );
myStack.Push(‘K’);
![Page 7: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/7.jpg)
7
Tracing Client Codeletter ‘V’
char letter = ‘V’;
StackType< char > myStack;
myStack.Push(letter);
myStack.Push(‘C’);
myStack.Push(‘S’);
if ( !myStack.IsEmpty( ) ) myStack.Pop( letter );
myStack.Push(‘K’);
Private data:
topPtr NULL
![Page 8: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/8.jpg)
8
Tracing Client Codeletter
char letter = ‘V’;
StackType< char > myStack;
myStack.Push(letter);
myStack.Push(‘C’);
myStack.Push(‘S’);
if ( !myStack.IsEmpty( ) ) myStack.Pop( letter );
myStack.Push(‘K’);
Private data:
topPtr ‘V’
‘V’
![Page 9: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/9.jpg)
9
Tracing Client Codeletter
char letter = ‘V’;
StackType< char > myStack;
myStack.Push(letter);
myStack.Push(‘C’);
myStack.Push(‘S’);
if ( !myStack.IsEmpty( ) ) myStack.Pop( letter );
myStack.Push(‘K’);
Private data:
topPtr ‘C’ ‘V’
‘V’
![Page 10: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/10.jpg)
10
Tracing Client Codeletter
char letter = ‘V’;
StackType< char > myStack;
myStack.Push(letter);
myStack.Push(‘C’);
myStack.Push(‘S’);
if ( !myStack.IsEmpty( ) ) myStack.Pop( letter );
myStack.Push(‘K’);
Private data:
topPtr ‘S’ ‘C’ ‘V’
‘V’
![Page 11: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/11.jpg)
11
Tracing Client Codeletter
char letter = ‘V’;
StackType< char > myStack;
myStack.Push(letter);
myStack.Push(‘C’);
myStack.Push(‘S’);
if ( !myStack.IsEmpty( ) ) myStack.Pop( letter );
myStack.Push(‘K’);
Private data:
topPtr ‘S’ ‘C’ ‘V’
‘V’
![Page 12: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/12.jpg)
12
Tracing Client Codeletter
char letter = ‘V’;
StackType< char > myStack;
myStack.Push(letter);
myStack.Push(‘C’);
myStack.Push(‘S’);
if ( !myStack.IsEmpty( ) ) myStack.Pop( letter );
myStack.Push(‘K’);
Private data:
topPtr ‘C’ ‘V’
‘S’
![Page 13: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/13.jpg)
13
Tracing Client Codeletter
char letter = ‘V’;
StackType< char > myStack;
myStack.Push(letter);
myStack.Push(‘C’);
myStack.Push(‘S’);
if ( !myStack.IsEmpty( ) ) myStack.Pop( letter );
myStack.Push(‘K’);
Private data:
topPtr ‘K’ ‘C’ ‘V’
‘S’
![Page 14: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/14.jpg)
14
// DYNAMICALLY LINKED IMPLEMENTATION OF STACK
#include "bool.h"
#include "ItemType.h" // for ItemType
template<class ItemType>
struct NodeType {
ItemType info;
NodeType<ItemType>* next;
}
14
Dynamically Linked Implementation of Stack
. info . next
‘A’ 6000
![Page 15: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/15.jpg)
// DYNAMICALLY LINKED IMPLEMENTATION OF STACK continued
template<class ItemType>
class StackType {
public:
StackType( ); // constructor
// Default constructor.
// POST: Stack is created and empty.
void MakeEmpty( );
// PRE: None.
// POST: Stack is empty.
bool IsEmpty( ) const;
// PRE: Stack has been initialized.
// POST: Function value = (stack is empty)
bool IsFull( ) const;
// PRE: Stack has been initialized.
// POST: Function value = (stack is full)15
![Page 16: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/16.jpg)
// DYNAMICALLY LINKED IMPLEMENTATION OF STACK continued
void Push( ItemType item );
// PRE: Stack has been initialized.
// Stack is not full.
// POST: newItem is at the top of the stack.
void Pop( ItemType& item );
// PRE: Stack has been initialized.
// Stack is not empty.
// POST: Top element has been removed from stack.
// item is a copy of removed element.~StackType( ); // destructor
// PRE: Stack has been initialized.
// POST: Memory allocated for nodes has been
// deallocated.
private:
NodeType<ItemType>* topPtr ;
};
16
![Page 17: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/17.jpg)
17
class StackType<char>
StackType
MakeEmpty
Pop
Push
IsFull
IsEmpty Private data:
topPtr
~StackType
![Page 18: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/18.jpg)
18
Implementing a Stack as a Linked Structure
![Page 19: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/19.jpg)
// DYNAMICALLY LINKED IMPLEMENTATION OF STACK continued
// member function definitions for class StackType
template<class ItemType>
StackType<ItemType>::StackType( ) // constructor
{
topPtr = NULL;
}
template<class ItemType>
void StackType<ItemType>::IsEmpty( ) const
// Returns true if there are no elements
// on the stack; false otherwise
{
return ( topPtr == NULL );}
19
![Page 20: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/20.jpg)
20
Push( )
Allocate space for new item
Put new item into the allocated space
Put the allocated space into the stack
![Page 21: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/21.jpg)
Using operator new
If memory is available in an area called the free store (or heap), operator new allocates the requested object, and returns a pointer to the memory allocated.
The dynamically allocated object exists until the delete operator destroys it.
21
![Page 22: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/22.jpg)
22
Adding newItem to the stack
newItem = ‘B’;
NodeType<char>* location;
location = new NodeType<char>;
location->info = newItem;
location->next = topPtr;
topPtr = location;
topPtr ‘X’ ‘C’ ‘L’
‘B’newItem
![Page 23: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/23.jpg)
23
Adding newItem to the stack
newItem = ‘B’;
NodeType<char>* location;
location = new NodeType<char>;
location->info = newItem;
location->next = topPtr;
topPtr = location;
topPtr ‘X’ ‘C’ ‘L’
‘B’newItem
location
![Page 24: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/24.jpg)
24
Adding newItem to the stack
newItem = ‘B’;
NodeType<char>* location;
location = new NodeType<char>;
location->info = newItem;
location->next = topPtr;
topPtr = location;
topPtr ‘X’ ‘C’ ‘L’
‘B’newItem
location
![Page 25: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/25.jpg)
25
Adding newItem to the stack
newItem = ‘B’;
NodeType<char>* location;
location = new NodeType<char>;
location->info = newItem;
location->next = topPtr;
topPtr = location;
topPtr ‘X’ ‘C’ ‘L’
‘B’newItem
location ‘B’
![Page 26: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/26.jpg)
26
Adding newItem to the stack
newItem = ‘B’;
NodeType<char>* location;
location = new NodeType<char>;
location->info = newItem;
location->next = topPtr;
topPtr = location;
topPtr ‘X’ ‘C’ ‘L’
‘B’newItem
location ‘B’
![Page 27: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/27.jpg)
27
Adding newItem to the stack
newItem = ‘B’;
NodeType<char>* location;
location = new NodeType<char>;
location->info = newItem;
location->next = topPtr;
topPtr = location;
topPtr ‘X’ ‘C’ ‘L’
‘B’newItem
location ‘B’
![Page 28: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/28.jpg)
28
template<class ItemType>
void StackType<ItemType>::Push ( ItemType newItem )
// Adds newItem to the top of the stack.
{
NodeType<ItemType>* location;
location = new NodeType<ItemType>;
location->info = newItem;
location->next = topPtr;
topPtr = location;
}
28
Implementing Push
![Page 29: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/29.jpg)
29
Pop( )
Set item to Info (top node)
Unlink the top node from the stack
Deallocate the old top node
![Page 30: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/30.jpg)
The object currently pointed to by the pointer is deallocated, and the pointer is considered unassigned. The memory is returned to the free store.
Using operator delete
30
![Page 31: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/31.jpg)
31
Deleting item from the stack
NodeType<ItemType>* tempPtr;
item = topPtr->info;
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
topPtr
item
‘B’ ‘X’ ‘C’ ‘L’
tempPtr
![Page 32: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/32.jpg)
32
Deleting item from the stack
NodeType<ItemType>* tempPtr;
item = topPtr->info;
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
topPtr
item
‘B’ ‘X’ ‘C’ ‘L’
tempPtr
‘B’
![Page 33: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/33.jpg)
33
Deleting item from the stack
NodeType<ItemType>* tempPtr;
item = topPtr->info;
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
topPtr
item
‘B’ ‘X’ ‘C’ ‘L’
tempPtr
‘B’
![Page 34: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/34.jpg)
34
Deleting item from the stack
NodeType<ItemType>* tempPtr;
item = topPtr->info;
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
topPtr
item
‘B’ ‘X’ ‘C’ ‘L’
tempPtr
‘B’
![Page 35: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/35.jpg)
35
Deleting item from the stack
NodeType<ItemType>* tempPtr;
item = topPtr->info;
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
topPtr
item
‘X’ ‘C’ ‘L’
tempPtr
‘B’
![Page 36: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/36.jpg)
36
template<class ItemType>
void StackType<ItemType>::Pop ( ItemType& item )
// Removes element at the top of the stack and
// returns it in item.
{
NodeType<ItemType>* tempPtr;
item = topPtr->info;
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
}
36
Implementing Pop
![Page 37: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/37.jpg)
template<class ItemType>
bool StackType<ItemType>::IsFull( ) const
// Returns true if there is no room for
// another NodeType node on the free store;
// false otherwise.
{
location = new NodeType<ItemType>;
if ( location == NULL )
return true;
else
{
delete location;
return false;
}
}
37
![Page 38: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/38.jpg)
38
Why is a destructor needed?
When a local stack variable goes out of scope, the memory space for data member topPtr is deallocated. But the nodes that topPtr points to are not automatically deallocated.
A class destructor is used to deallocate the dynamic memory pointed to by the data member.
![Page 39: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/39.jpg)
template<class ItemType>
void StackType<ItemType>::MakeEmpty( )
// Post: Stack is empty; all elements deallocated.
{
NodeType<ItemType>* tempPtr;;
while ( topPtr != NULL )
{
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
}
}
template<class ItemType>
StackType<ItemType>::~StackType( ) // destructor
{
MakeEmpty( );
}39
![Page 40: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/40.jpg)
40
What is a Queue?
Logical (or ADT) level: A queue is an ordered group of homogeneous items (elements), in which new elements are added at one end (the rear), and elements are removed from the other end (the front).
A queue is a FIFO “first in, first out” structure.
![Page 41: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/41.jpg)
Queue ADT Operations
MakeEmpty -- Sets queue to an empty state.
IsEmpty -- Determines whether the queue is currently
empty.
IsFull -- Determines whether the queue is currently full.
Enqueue (ItemType newItem) -- Adds newItem to the rear of the queue.
Dequeue (ItemType& item) -- Removes the item at the
front of the queue and returns it in item.
41
![Page 42: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/42.jpg)
ADT Queue Operations
Transformers MakeEmpty Enqueue Dequeue
Observers IsEmpty IsFull
change state
observe state
42
![Page 43: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/43.jpg)
43
class QueType<char>
QueType
~QueType
Enqueue
Dequeue . . .
Private Data:
qFront
qRear
‘C’ ‘Z’ ‘T’
![Page 44: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/44.jpg)
// DYNAMICALLY LINKED IMPLEMENTATION OF QUEUE
#include "ItemType.h" // for ItemType
template<class ItemType>
class QueType {
public:
QueType( ); // CONSTRUCTOR
~QueType( ) ; // DESTRUCTORbool IsEmpty( ) const;
bool IsFull( ) const;
void Enqueue( ItemType item );
void Dequeue( ItemType& item );
void MakeEmpty( );
private:
NodeType<ItemType>* qFront;
NodeType<ItemType>* qRear;
};
44
![Page 45: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/45.jpg)
// DYNAMICALLY LINKED IMPLEMENTATION OF QUEUE continued
// member function definitions for class QueType
template<class ItemType>
QueType<ItemType>::QueType( ) // CONSTRUCTOR
{
qFront = NULL;
qRear = NULL;
}
template<class ItemType>
bool QueType<ItemType>::IsEmpty( ) const
{
return ( qFront == NULL )
}
45
![Page 46: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/46.jpg)
template<class ItemType>
void QueType<ItemType>::Enqueue( ItemType newItem )
// Adds newItem to the rear of the queue.
// Pre: Queue has been initialized.
// Queue is not full.
// Post: newItem is at rear of queue.
{
NodeType<ItemType>* ptr;
ptr = new NodeType<ItemType>;
ptr->info = newItem;
ptr->next = NULL;
if ( qRear == NULL )
qFront = ptr;
else
qRear->next = ptr;
qRear = ptr;
}46
![Page 47: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/47.jpg)
template<class ItemType>
void QueType<ItemType>::Dequeue( ItemType& item )
// Removes element from from front of queue
// and returns it in item.
// Pre: Queue has been initialized.
// Queue is not empty.
// Post: Front element has been removed from queue.
// item is a copy of removed element.
{
NodeType<ItemType>* tempPtr;
tempPtr = qFront;
item = qFront->info;
qFront = qFornt->next;
if ( qFront == NULL )
qRear = NULL;
delete tempPtr;
} 47
![Page 48: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/48.jpg)
48
What is a 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.
![Page 49: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/49.jpg)
49
Implementing the Unsorted List as a Linked Structure
![Page 50: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/50.jpg)
ADT Unsorted List Operations
Transformers MakeEmpty InsertItem DeleteItem
Observers IsFull LengthIs RetrieveItem
Iterators ResetList GetNextItem
change state
observe state
process all
50
![Page 51: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/51.jpg)
#include “ItemType.h” // unsorted.h . . .
template <class ItemType>class UnsortedType{public : // LINKED LIST IMPLEMENTATION
UnsortedType ( ) ;~UnsortedType ( ) ;void MakeEmpty ( ) ;bool IsFull ( ) const ; int LengthIs ( ) const ; void RetrieveItem ( ItemType& item, bool& found ) ;void InsertItem ( ItemType item ) ; void DeleteItem ( ItemType item ) ; void ResetList ( );void GetNextItem ( ItemType& item ) ;
private :NodeType<ItemType>* listData;int length;NodeType<ItemType>* currentPos;
} ; 51
![Page 52: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/52.jpg)
52
class UnsortedType<char>
MakeEmpty
~UnsortedType
DeleteItem . . .
InsertItem
UnsortedType
RetrieveItem
GetNextItem
‘X’ ‘C’ ‘L’
Private data:
length 3
listData
currentPos
![Page 53: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/53.jpg)
// LINKED LIST IMPLEMENTATION ( unsorted.cpp )
#include “itemtype.h”
template <class ItemType>
UnsortedType<ItemType>::UnsortedType ( ) // constructor
// Pre: None.
// Post: List is empty.
{
length = 0 ;
listData = NULL;
}
template <class ItemType>
int UnsortedType<ItemType>::LengthIs ( ) const
// Post: Function value = number of items in the list.
{
return length;
} 53
![Page 54: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/54.jpg)
template <class ItemType>
void UnsortedType<ItemType>::RetrieveItem( 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 has been stored in item; otherwise, item is unchanged.
{ 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 ) ; }
}
}54
![Page 55: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/55.jpg)
template <class ItemType>
void UnsortedType<ItemType>::InsertItem ( 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++ ;
}
55
![Page 56: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/56.jpg)
56
Inserting ‘B’ into an Unsorted List
‘X’ ‘C’ ‘L’
Private data:
length 3
listData
currentPos
![Page 57: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/57.jpg)
57
location = new NodeType<ItemType>;
‘X’ ‘C’ ‘L’
Private data:
length 3
listData
currentPos
item
location
‘B’
![Page 58: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/58.jpg)
58
location->info = item ;
‘X’ ‘C’ ‘L’
Private data:
length 3
listData
currentPos
item
location
‘B’
‘B’
![Page 59: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/59.jpg)
59
location->next = listData ;
‘X’ ‘C’ ‘L’
Private data:
length 3
listData
currentPos
item
location
‘B’
‘B’
![Page 60: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/60.jpg)
60
listData = location ;
‘X’ ‘C’ ‘L’
Private data:
length 3
listData
currentPos
item
location
‘B’
‘B’
![Page 61: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/61.jpg)
61
length++ ;
‘X’ ‘C’ ‘L’
Private data:
length 4
listData
currentPos
item
location
‘B’
‘B’
![Page 62: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/62.jpg)
62
Implementing the Sorted List as a Linked Structure
![Page 63: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/63.jpg)
63
class SortedType<char>
MakeEmpty
~SortedType
DeleteItem . . .
InsertItem
SortedType
RetrieveItem
GetNextItem
‘C’ ‘L’ ‘X’
Private data:
length 3
listData
currentPos
![Page 64: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/64.jpg)
64
InsertItem algorithm for Sorted Linked List
Find proper position for the new element in the sorted list using two pointers predLoc and location, where predLoc trails behind location.
Obtain a node for insertion and place item in it.
Insert the node by adjusting pointers.
Increment length.
![Page 65: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/65.jpg)
65
Implementing SortedType member function InsertItem
// LINKED LIST IMPLEMENTATION (sorted.cpp)
#include “ItemType.h”
template <class ItemType>
void SortedType<ItemType> :: InsertItem ( ItemType item )
// Pre: List has been initialized. List is not full. item is not in list.
// List is sorted by key member.
// Post: item is in the list. List is still sorted.{
.
.
.
}
![Page 66: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/66.jpg)
66
InsertItem()
Set location to listData
Set predLoc to NULL
Set moreToSearch to (location != NULL)
WHILE moreToSearch
SWITCH (item.ComparedTo(location->info))
case GREATER : Set predLoc to location
Set location to location->next
Set moreToSearch to (location != NULL)
case LESS: Set moreToSearch to false
Set newNode to the address of a newly allocated node
Set newNode->info to item
Set newNode->next to location
Set predLoc->next to newNode
Increament length
![Page 67: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/67.jpg)
67
Inserting ‘S’ into a Sorted List
‘C’ ‘L’ ‘X’
Private data:
length 3
listData
currentPos
predLoc location
moreToSearch
![Page 68: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/68.jpg)
68
Finding proper position for ‘S’
‘C’ ‘L’ ‘X’
Private data:
length 3
listData
currentPos
predLoc location
NULL
moreToSearch true
![Page 69: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/69.jpg)
69
‘C’ ‘L’ ‘X’
Private data:
length 3
listData
currentPos
predLoc location
Finding proper position for ‘S’
moreToSearch true
![Page 70: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/70.jpg)
70
‘C’ ‘L’ ‘X’
Private data:
length 3
listData
currentPos
predLoc location
Finding proper position for ‘S’
moreToSearch false
![Page 71: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/71.jpg)
71
‘C’ ‘L’ ‘X’
Private data:
length 4
listData
currentPos
predLoc location
Inserting ‘S’ into proper position
moreToSearch false
‘S’
![Page 72: C++ Plus Data Structures](https://reader033.vdocuments.net/reader033/viewer/2022061520/56813fea550346895daae38a/html5/thumbnails/72.jpg)
72
Summary
Array-based or linked representation for stacks queues unsorted lists sorted lists
Variations: doubly linked lists circular lists …