UNIT2 1 To be able to implement Stack

UNIT-2 1. To be able to implement Stack ADT using arrays. 2. To be able to implement Stack ADT using linked list. 3. To analyze various application of stacks. 4. To implement infix to postfix conversion. 5. To be able to implement Queue ADT using arrays. 6. To be able to implement Queue ADT using linked list. 7. To understand the concept of Circular Queue. 8. To implement Circular Queue ADT. 9. To understand the concept of Double Ended Queue. 10. To be able to implement Double Ended Queue ADT using arrays. 11. To be able to implement Double Ended Queue ADT using linked list.

STACKS • Linear list. • One end is called top. • Other end is called bottom. • Additions to and removals from the top end only.

STACK ADT A stack is a Last In First Out (LIFO) data structure in which all insertions and deletions are takes place at one end, called the top. Stack maintains a variable called top, which keeps track of the top most element in the stack. Any insertions or deletions should be based upon the value of top. In the stack, the elements are removed in the reverse order of that in which they were added to the stack that is last element inserted is to be deleted first. Basic Stack Operations: push : To insert an item into stack pop : To delete an item from stack traversal : To display an items is. Full : To know whether the stack is full or not is. Empty : To know whether the stack is empty or not 3

STACK ADT Example 1: When the elements are inserted in the order as A, B, C, D then the size of the stack is 4 and the top most element in the stack is D. When deletion operation is performed on stack continuously then the order in which the elements are deleted is D, C, B, A. 4

STACKS Standard operations: � Is. Empty … return true iff stack is empty Is. Full … return true iff stack has no remaining capacity Top … return top element of stack Push … add an element to the top of the stack Pop … delete the top element of the stack � � �

STACKS Stack Create. S(max. Stack. Size) : : = #define MAX_STACK_SIZE 100 /* maximum stack size */ typedef struct { int key; /* other fields */ } element; Element stack[MAX_SSTACK_SIZE]; Int top = -1; Boolean Is. Empty(stack) : : = top<0; Boolean Is. Full(Stack) : : = top >= MAX_STACK_SIZE – 1;

STACKS ADT Stack is Object: a finite ordered list with 0 / more elements. Functions: for all stack belong Stack, item belong element, max. Stack. Size belongs positive integer. Stack Create(max. Stack. Size): : = create an empty stack whose maximum size is max. Stack. Size Boolean Is. Full(stack , max. Stack. Size): : = if (number of elements in stack == max. Stazk. Size) return TRUE else return FALSE Stack Push(stack) : : = if (Is. Full(stack)) stack. Full else insert item into top of stack and return Boolean Is. Empty(stack) : : = if (stack == Create. S(max. Stack. Size)) return TRUE else return FALSE Element Pop(stack) : : = if (Is. Empty(stack)) return else remove and return the element at the top of the stack

STACKS Use a 1 D array to represent a stack. Stack elements are stored in stack[0] through stack[top]. � �

STACKS Derive From array. List a b c 0 1 2 d e 3 4 5 6 Push(the. Element) => if full then either error or increase capacity and then add at stack[top+1] Suppose we increase capacity when full O(capacity) time when full; otherwise O(1) Pop() => if not empty, delete from stack[top] O(1) time � � �

STACKS Push a b c d e 0 1 2 3 4 top void push(element item) {/* add an item to the global stack */ if (top >= MAX_STACK_SIZE - 1) Stack. Full(); /* add at stack top */ stack[++top] = item; }

STACKS Pop a b c d e 0 1 2 3 4 top element pop() { if (top == -1) return Stack. Empty(); return stack[top--]; }

STACKS Stack. Full() void Stack. Full() { fprintf(stderr, “Stack is full, cannot add element. ”); exit(EXIT_FAILURE); }

STACKS Stack Using Dynamic Arrays Stack Create. S( ) : : = void typedef struct { int key; /* other fields */ } element; element *stack; MALLOC (stack , sizeof(*stack)); Int capacity= 1; Int top = -1; Boolean Is. Empty(Stack) : : = top<0; Boolean Is. Full(Stack) : : = top >= capacity – 1;

STACKS Stack. Full()/Dynamic Array Use a variable called capacity in place of MAX_STACK_SIZE Initialize this variable to (say) 1 When stack is full, double the capacity using REALLOC This is called array doubling

STACKS Stack. Full() void Stack. Full() { REALLOC(stack, 2*capacity*sizeof(*stack); capacity *= 2; }

STACK ADT IMPLEMENTATION Stack can be implemented in two ways: 1. using arrays 2. using linked list 16

STACK ADT USING ARRAYS STACK IMPLEMENTATION USING ARRAYS Procedure: Initialize the stack by assigning -1 to the top variable to indicate that the array based stack is empty. A top is an integer value, which contains the array index for the top of the stack. Each time data is pushed or popped, top is incremented or Decremented accordingly, to keep track of the current top of the stack. Stacks implemented as arrays are useful if a fixed amount of data is to be used. 17

STACK ADT USING ARRAYS Algorithm for inserting an element into the stack push() 1. if top>=size then print “stack is full” 2. else read item top=top+1 stack[top]=item endif 3. stop The first step of this algorithm checks for an overflow condition. Overflow occurs when we are trying to insert an item into a stack which is full. If the top value reaches to maximum size of the stack then items cannot be inserted into the stack i. e. stack is full. Otherwise top is incremented by one and item is inserted into 18 the stack.

STACK ADT USING ARRAYS Push Functon void push() { int ele; if(top==SIZE-1) { printf("n stack is full(overflow)n"); return; } else { printf("enter the element to push: "); scanf("%d", &ele); top++; stack[top]=ele; }

STACK ADT USING ARRAYS Algorithm for deleting an element from the stack pop() 1. if top = -1 then print “stack is empty” 2. else 1. item = stack[top] 2. top=top-1 3. endif 4. stop The first step of this algorithm checks for underflow condition. If the top value is -1 then stack is known as underflow or empty. Takeout the element from the location where the top is pointing and store it in the variable then decrement top by one. 20

STACK ADT USING ARRAYS POP Functon void pop() { if(top==-1) printf("n stack is empty(underflow)n"); else printf("the pop element is: %d", stack[top]); top--; }

STACK ADT USING ARRAYS Algorithm for displaying an elements of the stack traversal() 1. if top = -1 1. print “stack empty” 2. else 1. for(i = top; i >= 0; i--) 1. print “stack[i]” 3. endif 4. stop void display() { if(top==-1) { printf("n stack is empty(underflow)"); return } printf("n the elements in stack are: n"); for(i=top; i>=0; i--) printf("->%d", stack[i]); } If the top value is -1 then the stack is empty. If the stack is not empty, assign a top value to variable i, display the item which is pointed at stack[i] , decrement the top value by one and repeat this process until top becomes zero. C program example 1 , also show error simulation 22

STACK ADT USING LINKED LIST STACK IMPLEMENTATION USING LINKED LIST Implementing stacks as linked lists provides a feasibility on the number of nodes by dynamically growing stacks, as a linked list is a dynamic data structure. The stack can grow or shrink as the program demands it to. Disadvantage of using an array to implement a stack or queue is the wastage of space. A variable top always points to top element of the stack. top = NULL specifies stack is empty. 23

STACK ADT USING LINKED LIST Example: The following list consists of five cells, each of which holds a data object and a link to another cell. 24

STACK ADT USING LINKED LIST Push function void push() { struct node*temp; temp=(struct node*)malloc(sizeof(struct node)); printf("n enter data of item: "); scanf("%d", &temp->data); temp->link=top; top=temp; } POP function void pop() { struct node*temp; if(top==NULL) printf("n stack is empty n"); else { temp=top; printf("popped item is %d n", temp->data); top=top->link; free(temp); } } 25

STACK ADT USING LINKED LIST Traversal function void display() { struct node*temp; temp=top; if(top==NULL) printf("stack is empty n"); else { printf("stack elements: n"); while(temp!=NULL) { printf("->%d", temp->data); temp=temp->link; } } } C program example 2 , also show error simulation

STACK APPLICATIONS • Stacks are used in conversion of infix to postfix expression. • Stacks are also used in evaluation of postfix expression. • Stacks are used to implement recursive procedures. • Stacks are used in compiler design. 27

STACK APPLICATIONS TYPES OF EXPRESSIONS Arithmetic expressions can be represented in three ways: Infix notation: The operator is in between the two operands. Examples: A+B 2 + 3 Prefix (Polish notation): The operator precedes the operands. Examples: +AB +23 Postfix (Reverse Polish Notation): The operator follows the operands. Examples: AB+ 23+ 28

STACK APPLICATIONS CONVERSIONS Consider the infix expression: 2 + 3 * (5 – 7) / 9 Let us insert implicit parentheses (2 + ((3 * (5 – 7)) / 9)) Transfer the operators to the beginning of parentheses (+ 2 (/ (* 3 (– 5 7)) 9)) Remove the parentheses: + 2 / * 3 – 5 7 9 This is the equivalent prefix expression. Transfer the operators to the end of parentheses (2 ((3 (5 7 –) *) 9 /) +) Remove the parentheses: 2 3 5 7 – * 9 / + This is the equivalent postfix expression. 29

STACK APPLICATIONS Algorithm to convert infix expression to Postfix: 1. Initialize an empty stack. 2. Repeat the following process until the end of the infix expression. Get next input token (constant, variable, arithmetic operator, left parenthesis, right parenthesis) in the infix expression. If the token is � � A left parenthesis: Push it onto the stack. A right parenthesis: Pop and display stack elements until a left parenthesis is on the top of the stack. Pop the left parenthesis also, but do not display it. An operator: While the stack is nonempty and token has higher or equal priority than the stack’s top element, pop and display. Push token onto the stack. An operand: Display it. � � � � 3. When the infix expression is reached to the end, pop and display stack items until the stack is empty. (Note: Left parenthesis in the stack has lowest priority) 30

STACK APPLICATIONS 31

STACK ADT 1. Algorithm for postfix conversion: void postfix(char inf[15]) Step 1: repeat the steps a to c until inf[i]!='' a. check if infix expression is opening brace push it onto stack check if(inf[i]='(‘) push(inf[i]) b. check if infix expression is alphabetic character add it to postfix express if(isalpha(inf[i])) pf[j++]=inf[i] c. check if infix expression is closing brace if(inf[i]==')') repeat 1 to 2 until stack[top]!=opening brace 1. pf[j++]=pop() 2. x=pop() Otherwise repeat 1 to 2 until prec(stack[top])>=prec(inf[i]) 1. pf[j++]=pop() 2. push(inf[i]) Step 2: repeat the steps a to b until top!=-1 a. pf[j++]=pop() b. pf[j]='' step 3: stop 32

STACK ADT 2. Algorithm for push operation on stack: Step 1: increment top by 1 Step 2: stack[++top]=y Step 3: stop 3. Algorithm for pop operation on stack: Step 1: return stack[top] Step 2: decrement top by 1 Step 3: stop 4. Algorithm for finding precedence of operators : Step 1: check if (c=='*' || c=='/' || c=='%') return(5) step 2: check if (c=='+' || c=='-') return(3) Step 3: if(c=='(') return(1) step 4: stop 33

STACK ADT 5. Algorithm for main function : Step 1: start Step 2: read infix expression Step 3: call postfix(infix) Step 4: print postfix expression result Step 5: stop 34

STACK APPLICATIONS Postfix conversion function void postfix(char inf[15]) else { { char x; while(prec(stack[top]>=prec(inf[i]))) for(i=0; inf[i]!=''; i++) pf[j++]=pop(); { push(inf[i]); if(inf[i]=='(') } push(inf[i]); else if(isalpha(inf[i])) }//end of for pf[j++]=inf[i]; while(top!=-1) else if(inf[i]==')') { { pf[j++]=pop(); while(stack[top]!='(') pf[j]=''; pf[j++]=pop(); }//end of postfix() x=pop(); } } void push(int y) int pop() { { stack[++top]=y; return(stack[top--]); }//end of push() }//end of pop()

STACK APPLICATIONS recedence function int prec(char c) { if(c=='*' || c=='/') return(5); else if(c=='+' || c=='-') return(3); else if(c=='(') return(1); }//end of prec() C program example 3 , also show error simulation

STACK APPLICATIONS Algorithm to evaluate Postfix Expression: 1. Initialize an empty stack. 2. Do Get next token (constant, arithmetic operator) in postfix expression. If token is an operand, push it on the stack. If token is an operator do the following: � � � Pop two values from the stack. (If the stack does not contain two items, report error. ) Apply operator token to these two values. Push the resulting value onto the stack. � � � 3. Continue the process until the end of the expression is encountered. 4. The value of the expression is on the top of the stack (and stack should contain only this value). 37

STACK APPLICATIONS C program example 4 , also show error simulation 38

STACK APPLICATIONS Postfix evaluation function void evaluate(char pf[15]) { float a, b, x; for(i=0; pf[i]!=''; i++) { if(isalpha(pf[i])) { printf("enter value of %c", pf[i]); scanf("%f", &x); push(x); }//end of if else//if operator { b=pop(); a=pop(); switch(pf[i]) { case '+': push(a+b); break; case '-': push(a-b); break; case '*': push(a*b); break; case '/': push(a/b); break; default: printf("invalid operatorn"); }//end of switch }//end of else }//end of for printf("value of expression %f", stack[top--]); }//end of evaluate() void push(float y) { stack[++top]=y; } float pop() { return(stack[top--]); }

STACKS Applications of Stacks • Direct applications Page-visited history in a Web browser Undo sequence in a text editor Chain of method calls in the Java Virtual Machine � � � • Indirect applications Auxiliary data structure for algorithms Component of other data structures � � 40

STACK APPLICATIONS Demonstration of Manual infix to postfix conversion Step 1 A + B * C by placing paranthesis results ( A + ( B * C ) ) Step 2 moves the multiply operator after C ( A + (B C *) ) moves the addition operator to between the last two closing parentheses. This change is made because the closing parentheses for the plus sign is the last parenthesis. We now have ( A ( B C * ) + ) Finally , step 3 removes the parentheses A B C * +

STACK APPLICATIONS Infix Transformations A + B * C – D / E Converts to A B C * + D E / - Above transformation is illustrated in following figure. Example 4 converting infix expression to postfix expression

STACK APPLICATIONS Evaluation of Postfix Expression • In evaluation of postfix expression, it is the operands that are pushed on to the stack. The postfix expression is scanned from left to right. Any operands encountered are pushed on to the stack. When an operator is encountered, the top two operands are popped from the stack. The operation is performed and the result is pushed back on to the stack. In the end, the final value is popped from the stack and returned.

STACK APPLICATIONS Evaluation of Postfix Expression For example given expression is A B C + * And assuming that A is 2, B is 4, and C is 6 , the following figure shows the evaluation of postfix expression. Example 5 evaluation of postfix expression

Queues Definition • A queue is a order / linear list in which data can be inserted at one end, called the rear, and deleted from the other end, called the front. It is a first in–first out (FIFO) restricted data structure. • A queue is same as Ex: 1)a line of people waiting for a bus at bus station. 2)a list of waiting jobs to be processes by a computer. • The fig-1 below shows two examples of a queue. A) A queue of people B) a computer queue 45

Queues ADT Queue is Object: a finite ordered list with 0 / more elements. Functions: for all queue belong Queue, item belong element, max. Queue. Size belongs positive integer. Queue Create(max. Queue. Size): : = create an empty queue whose maximum size is max. Queue. Size Boolean Is. Full(queue , max. Queue. Size): : = if (number of elements in queue == max. Queue. Size) return TRUE else return FALSE Queue Add. Q(queue , item) : : = if (Is. Full. Q(queue)) queue. Full else insert item at rear of queue and return queue Boolean Is. Empty. Q(queue) : : = if (queue == Create. Q(max. Queue. Size)) return TRUE else return FALSE Element Delete. Q(queue) : : = if (Is. Empty. Q(queue)) return else remove and return the item at front of queue 46

Queues Linear list. One end is called front. Other end is called rear. Additions are done at the rear only. Removals are made from the front only.

Bus Stop Queue Bus Stop front rear rear

Bus Stop Queue Bus Stop front rear

Bus Stop Queue Bus Stop front rear

Bus Stop Queue Bus Stop front rear

Revisit Of Stack Applications in which the stack cannot be replaced with 1. Parentheses matching. 2. Towers of Hanoi. 3. Switchbox routing. 4. Method invocation and return. 5. Try-catch-throw implementation. Application in which the stack may be replaced with a q 1. Rat in a maze. 2. Results in finding shortest path to exit.

Wire Routing

Lee’s Wire Router start pin end pin Label all reachable squares 1 unit from start.

Lee’s Wire Router start pin end pin 1 1 Label all reachable unlabeled squares 2 units from start.

Lee’s Wire Router start pin end pin 2 1 2 2 Label all reachable unlabeled squares 3 units from start.

Lee’s Wire Router start pin end pin 3 2 1 2 3 3 2 1 2 2 3 Label all reachable unlabeled squares 4 units from start.

Lee’s Wire Router start pin end pin 4 3 3 2 2 1 1 2 2 2 3 4 4 4 Label all reachable unlabeled squares 5 units from start.

Lee’s Wire Router start pin end pin 5 4 3 3 2 2 1 1 2 2 3 4 4 5 5 5 2 4 5 5 Label all reachable unlabeled squares 6 units from start.

Lee’s Wire Router start pin end pin 3 2 1 2 3 4 5 6 6 5 4 3 2 1 2 4 3 4 6 5 2 6 4 5 6 6 End pin reached. Traceback.

Lee’s Wire Router start pin end pin 3 2 1 2 3 4 5 6 6 5 4 3 2 1 2 4 3 4 6 5 2 6 4 5 6 6 End pin reached. Traceback.

Queue Operations Is. Full. Q … return true iff queue is full Is. Empty. Q … return true iff queue is empty Add. Q … add an element at the rear of the queue Delete. Q … delete and return the front element of the queue

Queue in an Array Use a 1 D array to represent a queue. Suppose queue elements are stored with the front element in queue[0], the next in queue[1

Queue in an Array a b c d e 0 1 2 3 4 5 6 Delete. Q() => delete queue[0] O(queue size) time Add. Q(x) => if there is capacity, add at right end O(1) time

Queues Queue Create. Q(max. Queue. Size) : : = #define MAX_QUEUE_SIZE 100 /* maximum queue size */ typedef struct { int key; /* other fields */ } element; element stack[MAX_QUEUE_SIZE]; int rear = -1; int front = -1; Boolean Is. Empty. Q(queue) : : = front == rear; Boolean Is. Full. Q(queue) : : = rear == MAX_QUEUE_SIZE – 1; 65

Queues Add to a Queue void addq(element item) { /* add an item to the queue */ if(rear == MAX_QUEUE_SIZE-1) queue. Full(); queue[+rear] = item; } 66

Queues Delete from a queue element deleteq() { /* remove element at the front of the queue */ if (front == rear) return queue. Empty(); /* return an error key return queue[ ++ front ] } 67

Queues Objectives: Queue Operations Queue Linked List Design Queue Functions Queue Demonstration 68

Queues Queue operations: The two basic queue operations: 1)Insertion operation (enqueue) 2)Deletion operation (dqueue) Data can be inserted at the rare in queue Data can be deleted at front in queue • • 69

QUEUE ADT IMPLEMENTATION Queue can be implemented in two ways: 1. using arrays 2. using linked list 70

Queues using arrays • We can also implement queue using arrays. • There are mainly two functions in implementation of queue: 1) enqueue 2) dequeue Enqueue • An enqueue to an empty queue is placed in the first element of the array. which becomes both front and rear. • Subsequent enqueues are placed at the array locations following rear i. e if the last element is stored at array location 11, the data for next enqueue is placed in element 12. 71

Queues using arrays Dequeue • A dequeue takes place at the front of the queue. • As an element is deleted from the queue, the queue front is advanced to the next location • Fig-8 shows about physical structure of queue Queue ary count Max size front 7 17 rare 5 11 [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15] ` FIG-8 Physical structure 72

QUEUE USING ARRAY Adding / enqueu function 1 if(rear==SIZE-1) 2 print queue is full / overflow 3 return; 4 else 5 rear++; 6 enter the element to ENQUEUE 7 if(front==-1) 8 front++; 73

QUEUE USING ARRAY Deleting /dequeue function 1. if(front==-1) 2. print queue is empty / underflow 3. return; 4. else 5. print the DEQUEUE element arr[front] 6. if(front==rear) 7. front=rear=-1 8. else 9. front++ 74

QUEUE USING ARRAY displayfunction 1. if(front==-1) 2. print queue is empty / underflow 3. return; 4. print the element in queue are 5. for(i=front; i<=rear; i++) 6. print arr[i] 75

Queues using arrays Disavantages: • In a queue, we delete elements at front and insert elements at rear. • when rear reaches maximum size of an array, we can’t Insert new element though we have space at front end of a queue. • Therefore queue is not full because there are empty elements at the beginning of the array. It shows queue is full. • Fig shows array queue with last elements filled Queue front Queue rare [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Fig array queue with last elements filled Example -7 for queue using array 76

Queues Linked List • There two basic functions in queue using linked list 1) Enqueue 2) Dequeue Enqueue • when we insert data into a queue, the queue’s front and rear pointers must be set to the new node • When we insert data into a queue with data already in it, we must point both the link field in the last node and rear pointer to the new node. • If insert is successful, it returns true else if no memory left for the new node, it returns false • Fig shows enqueue 77

Queues Linked List Dequeue • If the queue is empty, we have underflow and return false • We first ensure that the queue contains data. • If the queue contains data, then set the front pointer to the next item in the queue • If we dequeue the last item, the queue front pointer automatically becomes null pointer. it also assigns null pointer to link filed of the last node. • Fig shows dequeue implementation. 78

Queues Linked List FIGURE -6 Enqueue Example 79

QUEUE USING LINKED LIST struct node { int data; struct node*link; }; struct node*front=NULL, *rear=NULL; 80

QUEUE USING LINKED LIST Enqueue function 1. struct node *temp 2. temp=(struct node*)malloc(sizeof(struct node)) 3. print enter the element to be inserted 4. temp->data=ele 5. temp->link=NULL 6. if(rear==NULL||front==NULL) 7. front=temp 8. else 9. rear->link=temp 10. rear=temp 81

QUEUE USING LINKED LIST Dequeue function 1. struct node*temp; 2. if(front==NULL||rear==NULL) 3. print queue underflow 4. else 5. temp=front; 6. print deleted element temp->data 7. front=front->link 8. free(temp) 82

QUEUE USING LINKED LIST Display function 1. struct node *temp 2. temp=front 3. if(front==NULL||rear==NULL) 4. print queue is empty 5. else 6. while(temp!=NULL) 7. print temp->data 8. temp=temp->link Example -6 for queue using linked list 83

Queues Linked List FIGURE -7 Dequeue Examples 84

Circular Queues • This disadvantage is overcome by shifting all the elements from end to the beginning of the array • In the above example, we shift from element 5 to 0 and 6 to 1 and so on. • A more efficient alternative is found in circular queue • In a circular queue, the last element is logically followed by the first element 85

Circular Queues Circular queue can be implemented in two ways 1. Circular queue using arrays 2. Circular queue using linked lists

Circular Queues Circular queue using arrays Insertion into the circular queue [2] [3] Initially circular queue is empty front= -1 rear= -1 [1] [4] [0] [5]

Circular Queues front=0 and rear=0 front=0 and rear=1

Circular Queues front=0 and rear=2 front=0 and rear=3

Circular Queues front=0 and rear=4 front=0 and rear=5

Circular Queues Circular queue using arrays Deletion from the circular queue front=1 and rear=5 front=2 and rear=5

Circular Queues front=3 and rear=5 Front=4 and rear=5

Circular Queues Circular queue using arrays Insertion from the circular queue front=4 and rear=0 front=4 and rear=1

Circular Queues front=4 and rear=2 front=4 and rear=3

Circular Queue Insert an element into a Circular Queue if(front ==(rear+1)%MAXSIZE) printf("nn. CIRCULAR QUEUE IS OVERFLOW"); else { if(front==-1) front=rear=0; else rear=(rear+1)%MAXSIZE; cqueue[rear]=item; } 95

Circular Queue Delete an element from a circular queue if(front == -1) printf("nn. CIRCULAR QUEUE IS UNDERFLOW"); else { a=cqueue[front]; if(front==rear) front=rear=-1; else front = (front+1)%MAXSIZE; printf("nn. DELETED ELEMENT FROM QUEUE IS : %d ", a); } 96

Circular Queue Display the content of a circular queue if(front == -1) printf("nn. CIRCULAR QUEUE IS UNDERFLOW"); else { for(i=front; i<=rear; i++) { printf(“ %d t“, cqueue[i]); } }

Circular Queue Insert an element into a Circular Queue using linked list void enqueue() { struct node*temp; temp=(struct node*)malloc(sizeof(struct node)); printf("n enter the element to be inserted"); scanf("%d", &temp->data); temp->link=NULL; if(count==0) front=temp; else rear->link=temp; rear->link=front; count++; }

Circular Queue Delete an element from a circular queue void dequeue() { struct node*temp; if(front==NULL||rear==NULL) printf("n queue underflow"); else { count--; if(front==rear) { printf("n deleted element is %d", front->data); free(front); front=rear=NULL; } else { temp=front; printf("n deleted element is %dn", temp->data); front=front->link; rear->link=front; free(temp); } } }

Circular Queue Display the content of a circular queue void display() { int i; struct node*temp; if(front==NULL||rear==NULL) printf("n queue is empty"); else { if(count==0) printf("n queue is empty"); else { temp=front; for(i=0; i<count; i++) { printf("->%d", temp->data); temp=temp->link; } printf(")n"); } }

DEQUEUE A double-ended queue is an abstract data type similar to an simple queue, it allows you to insert and delete from both sides means items can be added or deleted from the front or rear end. 101

DEQUEUE A Deque or deck is a double-ended queue. Allows elements to be added or removed on either the ends.

DEQUEUE TYPES OF DEQUE q Input restricted Deque Elements can be inserted only at one end. Elements can be removed from both the ends. q Output restricted Deque Elements can be removed only at one end. Elements can be inserted from both the ends.

DEQUEUE Deque as Stack and Queue As STACK When insertion and deletion is made at the same side. As Queue When items are inserted at one end and removed at the other end.

DEQUEUE Dequeue is also called as double ended queue and it allows user to perform insertion and deletion from the front and rear position. And it can be easily implemented using doubly linked list. On creating dequeue, we need to add two special nodes at the ends of the doubly linked list(head and tail). And these two nodes needs to be linked between each other(initially). head tail -------------- ---------------- | | ---|----->| | | NULL | 0 | | 0 | NULL | | | |<-----|--- | | | -------------- ---------------- 105

DEQUEUE So, the header node goes before the first node of the queue and the trailer node goes after the last node in the queue. To do insertion at the front position, place the new node next to the head. And to do insertion at the rear position, place the new node before the tail. Similarly, dequeue operation can also be performed at the front and rear positions. Operations Insert a New Element From front Insert a New Element From rear Delete an Element From front Delete an Element From rear 106

DEQUEUE using Array 1. Algorithm for insertion at rear end: Step 1: check if(front==-1) front++ rear++ read the element to insert a[rear] count++; Step 2: check if(rear>=SIZE-1) print Insertion is not possible, overflow!!! return Step 3: Increment the rear by 1 read the element to insert a[rear] count++; Step 4: stop 107

DEQUEUE using Array 2. Algorithm for insertion at front end: Step 1: check if(front==-1) front++ rear++ read the element to insert a[rear] count++ Step 2: check if(rear>=SIZE-1) print Insertion is not possible, overflow!!! return Step 3: Repeat the steps a to d until i>0 a[i]=a[i-1] read the element to insert a[i] count++ rear++; Step 4: stop 108

DEQUEUE using Array 3. Algorithm for deletion at rear end: Step 1: check if (front==-1) Print Deletion is not possible: Dequeue is empty return Step 2: otherwise Print The deleted element is a[rear] Check if(front==rear) front=rear=-1 otherwise rear=rear-1 Step 3: stop 109

DEQUEUE using Array Algorithm for deletion at front end: 1: check if (front==-1) Print Deletion is not possible: Dequeue is empty return Step 2: otherwise Print The deleted element is a[front] Check if(front==rear) front=rear=-1 otherwise front=front-1 Step 3: stop 5. Algorithm for displaying the dequeue: Step 1: check if (front==-1) Print Dequeue is empty return Step 2: otherwise Repeat step a until i<=rear (i=front) Print a[i] Step 3: stop 110

DEQUEUE using Linked list ALGORITHM: Initialize the front and rear nodes with NULL values struct node *front=NULL, *rear=NULL, *cur, *temp 1. Algorithm for insertion at rear end: Step 1: Create a new node cur=(struct node*) malloc (sizeof (struct node)) Step 2: Read the content of node (cur->data) Step 3: Assign new node right link to NULL cur->right=NULL Step 4: Assign new node to front & rear node Check if(rear==NULL&&front==NULL) rear=front=cur Step 5: otherwise rear->right=cur cur->left=rear rear=cur Step 6: stop 111

DEQUEUE using Linked list 2. Algorithm for insertion at front end: Step 1: Create a new node cur=(struct node*) malloc (sizeof (struct node)) Step 2: Read the content of node (cur->data) Step 3: Assign new node right link to NULL cur->right=NULL Step 4: Assign new node to front & rear node Check if(rear==NULL&&front==NULL) rear=front=cur Step 5: otherwise cur->right=front front->left=cur front=cur Step 6: stop 112

DEQUEUE using Linked list 3. Algorithm for deletion at front end: Step 1: check if(front==NULL) Print de. Queue is empty Step 2: otherwise Check if(front==rear) Print Deleted data is front->data front=rear=NULL Step 3: otherwise temp=front; print Deleted data is temp->data front=front->right front->left=NULL free(temp) Step 4: stop 113

DEQUEUE using Linked list 4. Algorithm for deletion at rear end: Step 1: check if(front==NULL) Print de. Queue is empty Step 2: otherwise Check if(front==rear) Print Deleted data is rear->data front=rear=NULL Step 3: otherwise temp=rear; print Deleted data is temp->data if(front==rear) front=rear=NULL rear=rear->left rear->right=NULL free(temp) Step 4: stop 114

DEQUEUE using Linked list 5. Algorithm for displaying the dequeue: Step 1: check if(front==NULL) Print de. Queue is empty Step 2: otherwise temp=front; repeat steps a-b until temp!= NULL a. printf("<-%d ->", temp->data) b. temp=temp->right; Step 3: stop 115

APPLICATIONS OF DEQUE Palindrome-checker

APPLICATIONS OF DEQUE A-Steal job scheduling algorithm The A-Steal algorithm implements task scheduling for several processors(multiprocessor scheduling). The processor gets the first element from the deque. When one of the processor completes execution of its own threads it can steal a thread from another processor. It gets the last element from the deque of another processor and executes it.

APPLICATIONS OF DEQUE OTHER APPLICATIONS OF DEQUE Undo-Redo operations in Software applications.