Doubly-Linked Lists

• Same basic functions operate on list

• Each node has a forward and backward link:
NULL 88 42 109 NULL

head_ptr

• What advantages does a doubly-linked list offer?

 Doubly-Linked Lists
• Same basic functions operate on list
• Each node has a forward and backward link:

NULL 88 42 109 NULL

head_ptr
• What advantages does a doubly-linked list offer?
Cursor can move forwards and backwards in list.
Stacks and Queues

Kruse and Ryba Ch 2 and 3

 What is a stack?
• It is an ordered group of homogeneous items of elements.
• Elements are added to and removed from the top of the
stack (the most recently added items are at the top of the
stack).
• The last element to be added is the first to be removed
(LIFO: Last In, First Out).
 Stack Specification
• Definitions: (provided by the user)
– MAX_ITEMS: Max number of items that might be on
the stack
– ItemType: Data type of the items on the stack
• Operations
– MakeEmpty
– Boolean IsEmpty
– Boolean IsFull
– Push (ItemType newItem)
– Pop (ItemType& item) (or pop and top)
 Push (ItemType newItem)

• Function: Adds newItem to the top of

the stack.
• Preconditions: Stack has been
initialized and is not full.
• Postconditions: newItem is at the top
of the stack.
 Pop (ItemType& item)
• Function: Removes topItem from stack and
returns it in item.
• Preconditions: Stack has been initialized
and is not empty.
• Postconditions: Top element has been
removed from stack and item is a copy of
the removed element.
 Stack Implementation
#include "ItemType.h"
// Must be provided by the user of the class
// Contains definitions for MAX_ITEMS and ItemType

class StackType {
public:
StackType();
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Push(ItemType);
void Pop(ItemType&);
private:
int top;
ItemType items[MAX_ITEMS];
};
Stack Implementation (cont.)
StackType::StackType()
{
top = -1;
}
void StackType::MakeEmpty()
{
top = -1;
}
bool StackType::IsEmpty() const
{
return (top == -1);
}
 Stack Implementation (cont.)
bool StackType::IsFull() const
{
return (top == MAX_ITEMS-1);
}

void StackType::Push(ItemType newItem)

{
top++;
items[top] = newItem;
}

void StackType::Pop(ItemType& item)

{
item = items[top];
top--;
}
Stack overflow
• The condition resulting from trying to push
an element onto a full stack.
if(!stack.IsFull())
stack.Push(item);
Stack underflow
• The condition resulting from trying to pop
an empty stack.
if(!stack.IsEmpty())
stack.Pop(item);
 Implementing stacks using
templates
• Templates allow the compiler to generate
multiple versions of a class type or a
function by allowing parameterized types.
Implementing stacks using templates
template<class ItemType> (cont.)
class StackType {
public:
StackType();
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Push(ItemType);
void Pop(ItemType&);
private:
int top;
ItemType items[MAX_ITEMS];
};
 Example using templates
// Client code
StackType<int> myStack;
StackType<float> yourStack;
StackType<StrType> anotherStack;
myStack.Push(35);
yourStack.Push(584.39);
The compiler generates distinct class types
and gives its own internal name to each of
the types.
 Function templates
• The definitions of the member functions must be
rewritten as function templates.
template<class ItemType>
StackType<ItemType>::StackType()
{
top = -1;
}
template<class ItemType>
void StackType<ItemType>::MakeEmpty()
{
top = -1;
}
 Function templates (cont.)
template<class ItemType>
bool StackType<ItemType>::IsEmpty() const
{
return (top == -1);
}

template<class ItemType>
bool StackType<ItemType>::IsFull() const
{
return (top == MAX_ITEMS-1);
}

template<class ItemType>
void StackType<ItemType>::Push(ItemType newItem)
{
top++;
items[top] = newItem;
}
 Function templates (cont.)
template<class ItemType>
void StackType<ItemType>::Pop(ItemType& item)
{
item = items[top];
top--;
}
Implementing stacks using dynamic
array allocation
template<class ItemType> private:
class StackType { int top;
public: int maxStack;
StackType(int); ItemType *items;
};
~StackType();
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Push(ItemType);
void Pop(ItemType&);
 Implementing stacks using
dynamic array allocation (cont.)
template<class ItemType>
StackType<ItemType>::StackType(int max)
{
maxStack = max;
top = -1;
items = new ItemType[max];
}

template<class ItemType>
StackType<ItemType>::~StackType()
{
delete [ ] items;
}
 Example: postfix expressions
• Postfix notation is another way of writing arithmetic
expressions.

• In postfix notation, the operator is written after the

two operands.
infix: 2+5 postfix: 2 5 +
• Expressions are evaluated from left to right.

• Precedence rules and parentheses are never needed!!

Example: postfix expressions
(cont.)
 Postfix expressions:
Algorithm using stacks (cont.)
 Postfix expressions:
Algorithm using stacks
WHILE more input items exist
Get an item
IF item is an operand
stack.Push(item)
ELSE
stack.Pop(operand2)
stack.Pop(operand1)
Compute result
stack.Push(result)
stack.Pop(result)
Write the body for a function that replaces each copy of an
item in a stack with another item. Use the following
specification. (this function is a client program).

ReplaceItem(StackType& stack, ItemType oldItem,

ItemType newItem)
Function: Replaces all occurrences of oldItem with
newItem.
Precondition: stack has been initialized.
Postconditions: Each occurrence of oldItem in stack has
been replaced by newItem.

(You may use any of the member functions of the

StackType, but you may not assume any knowledge of
how the stack is implemented).
 Stack tempStack
{
ItemType item;
StackType tempStack;

while (!Stack.IsEmpty()) { 3 1
Stack.Pop(item);
if (item==oldItem)
2 5
1 3
tempStack.Push(newItem);
Stack
else
tempStack.Push(item);
}
while (!tempStack.IsEmpty()) {
tempStack.Pop(item); 3
Stack.Push(item);
}
oldItem = 2 5
} newItem = 5 1
 What is a queue?
• It is an ordered group of homogeneous items of
elements.
• Queues have two ends:
– Elements are added at one end.
– Elements are removed from the other end.
• The element added first is also removed first
(FIFO: First In, First Out).

tail queue head

elements elements
4 3 2 1
enter exit
no changes of order
 Queue Specification
• Definitions: (provided by the user)
– MAX_ITEMS: Max number of items that might be on
the queue
– ItemType: Data type of the items on the queue

• Operations
– MakeEmpty
– Boolean IsEmpty
– Boolean IsFull
– Enqueue (ItemType newItem)
– Dequeue (ItemType& item) (serve and retrieve)
 Enqueue (ItemType newItem)
• Function: Adds newItem to the rear of the
queue.
• Preconditions: Queue has been initialized
and is not full.
• Postconditions: newItem is at rear of queue.
 Dequeue (ItemType& item)
• Function: Removes front item from queue
and returns it in item.
• Preconditions: Queue has been initialized
and is not empty.
• Postconditions: Front element has been
removed from queue and item is a copy of
removed element.
 Implementation issues
• Implement the queue as a circular
structure.
• How do we know if a queue is full or
empty?
• Initialization of front and rear.
• Testing for a full or empty queue.
Make front point to the element preceding the front
element in the queue (one memory location will be
wasted).
Initialize front and rear
Queue is empty
now!!
rear == front
 Queue Implementation
template<class ItemType> private:
class QueueType { int front;
public: int rear;
QueueType(int); ItemType* items;
QueueType(); int maxQue;
~QueueType(); };
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Enqueue(ItemType);
void Dequeue(ItemType&);
 Queue Implementation (cont.)
template<class ItemType>
QueueType<ItemType>::QueueType(int
max)
{
maxQue = max + 1;
front = maxQue - 1;
rear = maxQue - 1;
items = new ItemType[maxQue];
}
 Queue Implementation (cont.)

template<class ItemType>
QueueType<ItemType>::~QueueType()
{
delete [] items;
}
 Queue Implementation (cont.)

template<class ItemType>
void QueueType<ItemType>::
MakeEmpty()
{
front = maxQue - 1;
rear = maxQue - 1;
}
 Queue Implementation (cont.)
template<class ItemType>
bool QueueType<ItemType>::IsEmpty() const
{
return (rear == front);
}

template<class ItemType>
bool QueueType<ItemType>::IsFull() const
{
return ( (rear + 1) % maxQue == front);
}
 Queue Implementation (cont.)
template<class ItemType>
void QueueType<ItemType>::Enqueue
(ItemType newItem)
{
rear = (rear + 1) % maxQue;
items[rear] = newItem;
}
 Queue Implementation (cont.)
template<class ItemType>
void QueueType<ItemType>::Dequeue
(ItemType& item)
{
front = (front + 1) % maxQue;
item = items[front];
}
 Queue overflow

• The condition resulting from trying to add

an element onto a full queue.

if(!q.IsFull())
q.Enqueue(item);
 Queue underflow

• The condition resulting from trying to

remove an element from an empty queue.

if(!q.IsEmpty())
q.Dequeue(item);
Example: recognizing palindromes
• A palindrome is a string that reads the same
forward and backward.
Able was I ere I saw Elba
• We will read the line of text into both a stack and
a queue.
• Compare the contents of the stack and the queue
character-by-character to see if they would
produce the same string of characters.
Example: recognizing palindromes
Example: recognizing palindromes
#include <iostream.h> cout << "Enter string: " << endl;
#include <ctype.h>
while(cin.peek() != '\\n') {
#include "stack.h"
#include "queue.h“ cin >> ch;
if(isalpha(ch)) {
int main()
{ if(!s.IsFull())
StackType<char> s; s.Push(toupper(ch));
QueType<char> q; if(!q.IsFull())
char ch; q.Enqueue(toupper(ch));
char sItem, qItem; }
}
int mismatches = 0;
Example: recognizing palindromes
while( (!q.IsEmpty()) && (!s.IsEmpty()) ) {
s.Pop(sItem);
q.Dequeue(qItem);

if(sItem != qItem)
++mismatches;
}
if (mismatches == 0)
cout << "That is a palindrome" << endl;
else
cout << That is not a palindrome" << endl;
return 0;
}
 Case Study: Simulation

• Queuing System: consists of servers and

queues of objects to be served.

• Simulation: a program that determines how

long items must wait in line before being
served.
 Case Study: Simulation (cont.)
• Inputs to the simulation:
(1) the length of the simulation
(2) the average transaction time
(3) the number of servers
(4) the average time between job
arrivals
 Case Study: Simulation (cont.)

• Parameters the simulation must vary:

(1) number of servers
(2) time between arrivals of items

• Output of simulation: average wait time.