.

2

3

 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 queue object like this

 Empty Queue Enqueue(70)

 Enqueue(80)  Enqueue(50)

 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 empty and full queue gives 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 n rear = (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; 012… n-1 R  R = (R+1) mod n

 Dequeue(Q)  item begin front=rear if front=rear QueueEmpty; else front = (front+1) mod n; item = Q[front]; end; (n-1 )  Note: only (n-1 ) space used; F R X X X XX X X X X XX X

 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  “Tag” can determine the states of the queue solely!

 1. Set newBack == (myBack+1)%Queue_capacity  2. If newBack == myFront Signal “Queue Full” otherwise: Set Array[myBack] == value Set myBack == newBack

 If queue is empty signal “Queue Empty” Otherwise Set 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

 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 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 data << " "; Cur = Cur->next; }while(Cur != Rear->next); cout << endl; } Rear

 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

 Insert to middle of a Circular Linked List between Pre and Cur Prev New New->next = Cur; Prev->next = New; RearCur

 Insert to end of a Circular Linked List Rear New New->next = Cur;// same as: New->next = Rear->next; Prev->next = New;// same as: Rear->next = New; Rear = New; Prev Cur

 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 Rear Cur Prev->next = Cur->next;// same as: Rear->next = Cur->next delete Cur; Prev

 Delete a middle node Cur from a Circular Linked List Prev Rear Cur Prev->next = Cur->next; delete Cur;

 Delete the end node from a Circular Linked List Rear Prev->next = Cur->next; // same as: Rear->next; delete Cur; Rear = Prev; Prev Cur

.