Scribd
Upload
41 views

Queues: CS 302 - Data Structures Sections 5.3 and 5.4

Queues are data structures that follow the FIFO (first in, first out) principle. Elements are added to the rear of the queue and removed from the front. Queues have two common implementations - array-based and linked list-based. The array-based implementation uses a fixed-size array while the linked list implementation dynamically allocates memory as needed. Both support O(1) time complexity for enqueue and dequeue operations but the linked list uses more memory. An example application is recognizing palindromes by adding characters to both a stack and queue and comparing contents.

Uploaded by

Md. Ridwanul Islam 1812608642
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
41 views

Queues: CS 302 - Data Structures Sections 5.3 and 5.4

Queues are data structures that follow the FIFO (first in, first out) principle. Elements are added to the rear of the queue and removed from the front. Queues have two common implementations - array-based and linked list-based. The array-based implementation uses a fixed-size array while the linked list implementation dynamically allocates memory as needed. Both support O(1) time complexity for enqueue and dequeue operations but the linked list uses more memory. An example application is recognizing palindromes by adding characters to both a stack and queue and comparing contents.

Uploaded by

Md. Ridwanul Islam 1812608642
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 49

Queues

CS 302 – Data Structures


Sections 5.3 and 5.4
What is a queue?
• It is an ordered group of homogeneous items.
• Queues have two ends:
– Items are added at one end.
– Items are removed from the other end.
• FIFO property: First In, First Out
– The item added first is also removed first
Queue Implementations

Array-based

Linked-list-based
Array-based Implementation
template<class ItemType> private:
class QueueType { int front, rear;
public: ItemType* items;
QueueType(int); int maxQue;
~QueueType(); };
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Enqueue(ItemType);
void Dequeue(ItemType&);
Implementation Issues
• Optimize memory usage.
• Conditions for a full or empty queue.
• Initialize front and rear.
linear array circular array
Optimize memory usage
Full/Empty queue conditions
“Make front point to the element preceding the front
element in the queue!”

NOW!
Initialize front and rear
Array-based Implementation (cont.)
template<class ItemType>
QueueType<ItemType>::QueueType(int max)
{
maxQue = max + 1;
front = maxQue - 1; O(1)
rear = maxQue - 1;
items = new ItemType[maxQue];
}
Array-based Implementation (cont.)

template<class ItemType>
QueueType<ItemType>::~QueueType()
{
delete [] items; O(1)
}
Array-based Implementation (cont.)

template<class ItemType>
void QueueType<ItemType>::MakeEmpty()
{
front = maxQue - 1; O(1)
rear = maxQue - 1;
}
Array-based Implementation (cont.)
template<class ItemType>
bool QueueType<ItemType>::IsEmpty() const
{
return (rear == front);
} O(1)
template<class ItemType>
bool QueueType<ItemType>::IsFull() const
{
return ( (rear + 1) % maxQue == front);
}

O(1)
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.
Queue overflow

• The condition resulting from trying to add an element


onto a full queue.

if(!q.IsFull())
q.Enqueue(item);
Array-based Implementation (cont.)
template<class ItemType>
void QueueType<ItemType>::Enqueue
(ItemType newItem)
{
rear = (rear + 1) % maxQue;
items[rear] = newItem; O(1)
}
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.
Queue underflow

• The condition resulting from trying to


remove an element from an empty queue.

if(!q.IsEmpty())
q.Dequeue(item);
Array-based Queue
Implementation (cont.)
template<class ItemType>
void QueueType<ItemType>::Dequeue
(ItemType& item)
{
front = (front + 1) % maxQue;
O(1)
item = items[front];
}
Linked-list-based
Implementation
• Allocate memory for each new element
dynamically
• Link the queue elements together
• Use two pointers, qFront and qRear, to
mark the front and rear of the queue
A “circular” linked queue design

(see textbook for details)


Linked-list-based
Implementation
// forward declaration of NodeType (i.e., like function prototype)
template<class ItemType>
struct NodeType;
 
template<class ItemType>
class QueueType {
public:
QueueType();
~QueueType();
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Enqueue(ItemType);
void Dequeue(ItemType&);
private:
NodeType<ItemType>* qFront;
NodeType<ItemType>* qRear;
};
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.
Enqueue (non-empty queue)
Special Case: empty queue
• Need to make qFront point to the new node

qFront = NULL New Node

qRear = NULL

newNode
Enqueue
template <class ItemType>
void QueueType<ItemType>::Enqueue(ItemType
Enqueue
newItem)
{
NodeType<ItemType>* newNode;
 
newNode = new NodeType<ItemType>;
newNode->info = newItem;
newNode->next = NULL;
if(qRear == NULL) // special case
qFront = newNode; O(1)
else
qRear->next = newNode;
qRear = newNode;
}
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.
Dequeue (queue contains more
than one elements)
Special Case: queue contains a
single element
• We need to reset qRear to NULL also
qFront After dequeue:
Node qFront = NULL
qRear qRear = NULL
Dequeue
template <class ItemType>
void QueueType<ItemType>::Dequeue(ItemType&
Dequeue item)
{
NodeType<ItemType>* tempPtr;
 
tempPtr = qFront;
item = qFront->info;
qFront = qFront->next; O(1)
if(qFront == NULL) // special case
qRear = NULL;
delete tempPtr;
}
qRear, qFront - revisited
• Are the relative positions of qFront and
qRear important?

What about
this?
qRear, qFront - revisited
• Are the relative positions of qFront and
qRear important?

Hard to
dequeue!
Other Queue functions
template<class ItemType>
QueueType<ItemType>::QueueType()
{
qFront = NULL;
qRear = NULL; O(1)
}
 

template<class ItemType>
void QueueType<ItemType>::MakeEmpty()
{
NodeType<ItemType>* tempPtr;
 
while(qFront != NULL) {
tempPtr = qFront; O(N)
qFront = qFront->next;
delete tempPtr;
}
qRear=NULL;
}
Other Queue functions (cont.)
template<class ItemType>
QueueType<ItemType>::~QueueType()
{
MakeEmpty();
}
O(N)
Other Queue functions (cont.)
template<class ItemType>
bool QueueType<ItemType>::IsEmpty() const
{
return(qFront == NULL);
}
 
O(1)
template<class ItemType>
bool QueueType<ItemType>::IsFull() const
{
NodeType<ItemType>* ptr;
 

ptr = new NodeType<ItemType>;


if(ptr == NULL)
return true;
else { O(1)
delete ptr;
return false;
}
}
Comparing queue implementations
Big-O Comparison of Queue Operations
Operation Array Linked
Implementation Implementation
Class constructor O(1) O(1)
MakeEmpty O(1) O(N)
IsFull O(1) O(1)
IsEmpty O(1) O(1)
Enqueue O(1) O(1)
Dequeue O(1) O(1)
Destructor O(1) O(N)
Compare queue implementations in
terms of memory usage
• Example 1: Assume a queue of strings
– Array-based implementation
• Assume a queue (size: 100) of strings (80 bytes each)
• Assume indices take 2 bytes
• Total memory: (80 bytes x 101 slots) + (2 bytes x 2
indices) = 8084 bytes
– Linked-list-based implementation
• Assume pointers take 4 bytes
• Memory per node: 80 bytes + 4 bytes = 84 bytes
Comparing
queue
implementations
(cont.)
Compare queue implementations in
terms of memory usage (cont.)
• Example 2: Assume a queue of short integers
– Array-based implementation
• Assume a queue (size: 100) of short integers (2 bytes each)
• Assume indices take 2 bytes
• Total memory: (2 bytes x 101 slots) + (2 bytes x 2 indexes) =
206 bytes
– Linked-list-based implementation
• Assume pointers take 4 bytes
• Memory per node: 2 bytes + 4 bytes = 6 bytes
Comparing
queue
implementations
(cont.)
Array- vs Linked-list-based
Queue Implementations
• Array-based implementation is simple but:
– The size of the queue must be determined when
the queue object is declared.
– Space is wasted if we use less elements.
– Cannot "enqueue" more elements than the array
can hold.
• Linked-list-based queue alleviates these
problems but time requirements might
increase.
Example: recognizing palindromes
• A palindrome is a string that reads the same
forward and backward.

Able was I ere I saw Elba 


Example: recognizing palindromes

(1) Read the line of text into both a stack and a queue.

(2) 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
#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;
}
Exercise 37: Implement a client function that
returns the number of items in a queue. The queue
is unchanged.

int Length(QueueType& queue)


Function: Determines the number of items in the
queue.
Precondition: queue has been initialized.
Postconditions: queue is unchanged

You may not assume any knowledge of how the queue


is implemented.
int Length(QueType& queue)
{
QueType tempQ;
ItemType item;
int length = 0; What are the time
while (!queue.IsEmpty()) requirements using big-O?
{
queue.Dequeue(item);
tempQ.Enqueue(item); O(N)
length++;
}
while (!tempQ.IsEmpty())
{
tempQ.Dequeue(item);
queue.Enqueue(item);
}
return length;
}
int Length(QueType& queue)
{
QueType tempQ;
ItemType item;
How would you implement it
int length = 0; as member function?
while (!queue.IsEmpty())
{
Case 1: array-based
queue.Dequeue(item);
tempQ.Enqueue(item); f r
length++;
} r f
while (!tempQ.IsEmpty())
{
tempQ.Dequeue(item); rear - front maxQue – (front – rear)
queue.Enqueue(item);
} What would be the time
return length; requirements in this case
} using big-O?
O(1)
int Length(QueType& queue)
{
QueType tempQ;
ItemType item;
How would you implement it
int length = 0; as member function?
while (!queue.IsEmpty())
{ Case 2: linked-list-based
queue.Dequeue(item);
tempQ.Enqueue(item);
length++;
}
while (!tempQ.IsEmpty())
{
tempQ.Dequeue(item);
queue.Enqueue(item);
} What would be the time
return length; requirements in this case
} using big-O?
O(N)

You might also like