2 3 a queue is a waiting line……. it’s in daily life:- a line of persons waiting to check...
Post on 16-Dec-2015
224 Views
Preview:
TRANSCRIPT
.
2
A QUEUE IS A CONTAINER IN WHICH:
. INSERTIONS ARE MADE ONLY AT THE BACK;
. DELETIONS, RETRIEVALS, ANDMODIFICATIONS ARE MADE ONLYAT THE FRONT.
3
PUSH (ALSO CALLED ENQUEUE) -- TOINSERT AN ITEM AT THE BACK
POP (ALSO CALLED DEQUEUE) -- TODELETE THE FRONT ITEM
IN A QUEUE, THE FIRST ITEM
INSERTED WILL BE THE FIRST ITEM
DELETED: FIFO (FIRST-IN, FIRST-OUT)
A queue is a waiting line……. It’s in daily life:-
A line of persons waiting to check out at a supermarket.
A line of persons waiting to purchase a ticket for a film.
A line of planes waiting to take off at an airport.
A line of vehicles at a toll booth.
Difference between Stack and Queues:
Stack is last-in-first-out (LIFO)
Queue is first-in-first-out (FIFO)
Unlike stacks in which elements are popped and pushed only at the ends of the list,
Collection of data elements: items are removed from a queue at one end,
called the FRONT of the queue; and elements are added at the other end,
called the BACK
Basic operations Construct a queue Check if empty Enqueue (add element to back) Front (retrieve value of element from front) Dequeue (remove element from front)
Consider an array in which to store a queue
Note additional variables needed myFront, myBack
Picture a queueobject like this
Empty Queue
Enqueue(70)
Enqueue(80)
Enqueue(50)
Dequeue()
Dequeue()
Enqueue(90)
Enqueue(60)
Problems We quickly "walk off the end" of the array
Possible solutions Shift array elements Use a circular queue
Note that both emptyand full queuegives myBack == myFront
Use Linear Array to implement a queue.
Waste of memory: The deleted elements can not be re-used. Solution: to use circular queue. Two implementations:
Using n-1 space. Using n space + full tag
Create(Q)
Q: Array[0…n-1]
front = rear = 0 //initialize Enqueue(item, Q) Queue
begin
rear = (rear+1) mod nrear = (rear+1) mod n; //rear moves forward;
if rear = front
QueueFull; // Queue is full.
rear = rear-1 mod n; // rear back to the previous position;
else
Q[rear]=item;
end;
0 1 2 … n-1
R R = (R+1) mod n
Dequeue(Q) item
begin
if front=rear front=rear
QueueEmpty;
else
front = (front+1) mod n;
item = Q[front];
end;
end; Note: only ((n-1 n-1 ) ) space used;
FFRR
X
X
XX X
X
X
X
X
XXX
If an item were stored in the last position, and an Enqueure() occurred.
myBack would be incremented by 1, giving it the same value as myFront .
However, myFront == myBack indicates the queue is empty.
Thus, we cannot distinguish between empty and full.
We may avoid this situation by maintaining one empty position, so that myFront will never equal to myBack unless the queue is empty.
Construct:Create an array, set capacity, myFront=myBack=0
Empty:test myFront==myBack
Front :if not empty:
print array[myFront]
A parameter “Tag” is introduced to help to make sure the queue is Empty or Full:
Boolean
If Tag = True, combined with other conditions => queue is Full
If Tag = False, combined with other conditions => queue is Null
““TagTag”” ccan determine the states of the queue solely!an determine the states of the queue solely!
1. Set newBack == (myBack+1)%Queue_capacity
2. If newBack == myFrontSignal “Queue Full”
otherwise:Set Array[myBack] == valueSet myBack == newBack
If queue is emptysignal “Queue Empty”
OtherwiseSet myFront=(myFront+1)%Queue_capacity
Circular Linklist
A Circular Linked List is a special type of Linked List
It supports traversing from the end of the list to the beginning by making the last node point back to the head of the list
A Rear pointer is often used instead of a Head pointer
Rear
10 20 40 7055
Circular linked lists are usually sorted Circular linked lists are useful for
playing video and sound files in “looping” mode
They are also a stepping stone to implementing graphs, an important topic in comp171
#include <iostream>
using namespace std;
struct Node{
int data;
Node* next;
};
typedef Node* NodePtr;
Nodes contain references to other nodes Example
Issues Easy to find succeeding elements Start from head of list for preceding elements
Reference-based linked list Insertion / deletion = O(1) Indexing = O(n) Easy to dynamically increase size of list
Array Insertion / deletion = O(n) Indexing = O(1) Compact, uses less space Easy to copy, merge Better cache locality
1. Original list & new element temp
2. Modify temp.next cursor.next
3. Modify cursor.next temp
4. Modify cursor temp
1. Find before such that before.next = cursor
2. Modify before.next cursor.next
3. Delete cursor
4. Modify cursor before.next
insertNode(NodePtr& Rear, int item)//add new node to ordered circular linked list
deleteNode(NodePtr& Rear, int item)//remove a node from circular linked list
print(NodePtr Rear)//print the Circular Linked List once
void print(NodePtr Rear){
NodePtr Cur;
if(Rear != NULL){
Cur = Rear->next;
do{
cout << Cur->data << " ";
Cur = Cur->next;
}while(Cur != Rear->next);
cout << endl;
}
}
Rear
10 20 40 7055
Insert into an empty list
Rear
10
New
NotePtr New = new Node;New->data = 10;
Rear = New;Rear->next = Rear;
Insert to head of a Circular Linked List
Rear
New
New->next = Cur; // same as: New->next = Rear->next;
Prev->next = New; // same as: Rear->next = New;
PrevCur
10 20 40 55 70
Insert to middle of a Circular Linked List between Pre and Cur
Prev
New
New->next = Cur;
Prev->next = New;
RearCur
10 5520
40
70
Insert to end of a Circular Linked List
RearNew
New->next = Cur; // same as: New->next = Rear->next;
Prev->next = New; // same as: Rear->next = New;
Rear = New;
PrevCur
10 20 40 55 70
Delete a node from a single-node Circular Linked List
Rear = Cur = Prev
Rear = NULL;
delete Cur;
10
Delete the head node from a Circular Linked List
RearCur
Prev->next = Cur->next;// same as: Rear->next = Cur->next
delete Cur;
Prev
10 20 40 55 70
Delete a middle node Cur from a Circular Linked List
Prev RearCur
Prev->next = Cur->next;
delete Cur;
10 20 40 55 70
Delete the end node from a Circular Linked List
Rear
Prev->next = Cur->next; // same as: Rear->next;
delete Cur;
Rear = Prev;
Prev Cur
10 20 40 55 70
.
top related