Stacks, Queues & Recursion Stacks: LIFO Last In First Out Queues: FIFO First In First Out

QUEUES FIFO Queue is a linear structure in which Deletions can take place at one end only, called the Front and Insertions can take place only at other end, called the Rear. Three everyday examples of such a structure Waiting Automobiles for Fuel People Waiting in Line at Bank Programs with the same Priority Another structure called priority queue AAA Front DDD Rear AAA BBB CCC DDD

Representation of Queues FRONT: Containing the Location of the Front Element REAR: Containing the Location of the Rear Element FRONT = NULL will indicate the Queue is Empty Deletion: FRONT := FRONT + 1 Insertion: REAR := REAR + 1 After N Insertions, the Rear Element of the Queue will Occupy QUEUE [N]

Representation of Queues Cont… FRONT-1 AAA BBB CCC DDD ……. ……. …… REAR -4 1 2 3 4 5 6 N FRONT-2 BBB CCC DDD ……. ……. …… REAR -4 1 2 3 4 5 6 N FRONT-2 BBB CCC DDD EEE FFF …… REAR -6 1 2 3 4 5 6 N FRONT-3 CCC DDD EEE FFF …… REAR -6 1 2 3 4 5 6 N

Circular Queues QUEUE [1] comes after QUEUE [N] in the array Instead of increasing REAR to N+1 we reset REAR=1 QUEUE [REAR]:= ITEM Instead of Increasing FRONT to N+1 we reset FRONT= 1 Queue contains only one Element FRONT = REAR  NULL For No Element FRONT := NULL REAR := NULL

(a) Initially Empty FRONT-0 REAR -0 1 2 3 4 5 (b) A,B,C FRONT-1 A B C Inserted REAR -3 1 2 3 4 5 (c) A Deleted FRONT-2 B C REAR - 3 1 2 3 4 5 (d) D and then FRONT-2 B C D E E Inserted REAR - 5 1 2 3 4 5 (e) B and C FRONT-4 D E Deleted REAR - 5 1 2 3 4 5

(f) F Inserted FRONT-4 F D E REAR -1 1 2 3 4 5 (g) D Deleted FRONT-5 F E REAR -1 1 2 3 4 5 (h) G and then FRONT-5 F G H E H Inserted REAR -3 1 2 3 4 5 (i) E Deleted FRONT-1 F G H REAR -3 1 2 3 4 5 (j) F Deleted FRONT-2 G H REAR -3 1 2 3 4 5

(k) K Inserted FRONT-2 G H K REAR -4 1 2 3 4 5 (l) G and H FRONT-4 K Deleted REAR -4 1 2 3 4 5 (m) K Deleted FRONT-0 Queue Empty REAR -0 1 2 3 4 5

QINSERT (QUEUE, N, FRONT, REAR, ITEM) This procedure inserts an element ITEM into a queue. [Queue already filled?] If FRONT =1 and REAR = N, or if FRONT=REAR+1 Then write: OVERFLOW and return [Find new value of REAR] If FRONT:=NULL [QUEUE Initially empty] Then : Set FRONT:=1 and REAR:=1 Else If REAR =N then Set REAR:=1 Else: Set REAR:=REAR+1 [End of If structure] Set QUEUE[REAR]:=ITEM [ This inserts new element] Return

QDELETE (QUEUE, N, FRONT, REAR, ITEM) This procedure deletes an element from a queue and assigns it to the variable item. [QUEUE already empty?] If FRONT:=NULL, then write: UNDERFLOW and Return Set ITEM:=QUEUE[FRONT] [Find new value of FRONT] If FRONT=REAR, then [Queue has only one element to start] Set FRONT:=NULL and REAR:=NULL Else if FRONT:=N then Set FRONT:=1 Else Set FRONT:=FRONT+1 [End of If Structure] Return

STACKS LIFO A stack is a linear structure in which items are added or removed only at one end. Three everyday examples of such a structure Stack of dishes Stack of pennies Stack of folded towels In particular the last item to be added to stack is the first item to be removed STACKS are also called “PILES” AND “PUSH- DOWN”

Operations On Stack PUSH: is the term to insert an element into a stack POP: is the term to delete an element from a stack Example: Suppose the following 6 elements are pushed in order onto an empty stack AAA, BBB, CCC, DDD, EEE, FFF This means: EEE cannot be deleted before FFF is deleted, DDD cannot be deleted before EEE and FFF is deleted and so on. AAA BBB CCC FFF DDD EEE EEE DDD FFF TOP CCC BBB AAA

POSTPONED DECISIONS Stacks are frequently used to indicate the order of the processing of data when certain steps of the processing must be postponed until other conditions are fulfilled. C B B B A A A

Operation Of Stack CreateStack (Size) DestroyStack(Stack) Function: Initialize Stack to an Empty State Input: None Precondition: None Output: Stack Post condition: Stack is Empty DestroyStack(Stack) Function: Remove all the Elements from Stack Input: Stack Precondition: Stack has been created

Operation Of Stack Cont…. EmptyStack (Stack) Function: Test whether stack is Empty Input: Stack Precondition: Stack has been created Output: EmptyStack (Boolean) FullStack(Stack) Function: Test whether stack is Full Precondition: Stack has been created Output: FullStack (Boolean)

Operation Of Stack Cont…. Push (Stack, NewValue) Function: Add new value in a Stack Input: Stack, New Value Precondition: Stack has been created and not Full Output: Stack Post condition: New Value will be added in the Stack New Top will be assigned Pop(Stack, PoppedValue) Function: Remove the top value from the Stack Input: Stack Precondition: Stack has been created and not Empty Output: Stack, Popped Value Post condition: New Top will be assigned

PUSH (STACK, TOP, MAXSTR, ITEM) This procedure pushes an ITEM onto a stack If TOP = MAXSTR, then Print: OVERFLOW, and Return. Set TOP := TOP + 1 [Increases TOP by 1] Set STACK [TOP] := ITEM. [Insert ITEM in TOP position] Return POP (STACK, TOP, ITEM) This procedure deletes the top element of STACK and assign it to the variable ITEM If TOP = 0, then Print: UNDERFLOW, and Return. Set ITEM := STACK[TOP] Set TOP := TOP - 1 [Decreases TOP by 1]

Arithmetic Expressions Precedence Level Highest Exponentiation ( ) Next Highest Multiplication (*) and Division ( / ) Lowest: Addition (+) and subtraction (-) Infix Notation A + B C – D (G / H) + A Polish Notation (Prefix Notation) + AB - CD (/ GH) + A = + / GHA Reverse Polish Notation (Postfix or Suffix Notation) AB + CD - GHA / +

Evaluation of Expression The Computer Usually Evaluates an Arithmetic expression written in infix notation into steps First converts the expression to postfix notation Evaluates the postfix expression Stack is the Main Tool that is Used to Accomplish given Task. INFIX PREFIX ( A + B ) * C [ + A B ] * C = * + A B A + ( B * C ) A + [ * B C ] = + A * B C ( A + B ) / ( C – D ) [+ AB] / [- CD] = / + AB-CD

This Algorithm Finds the VALUE of an Arithmetic Expression P Written in Postfix Notation. Add a right parenthesis “)” at the end of P. Scan P from left to right and repeat step 3 and 4 for each element of P until “)”is encountered. If an operand is encountered, put it in STACK. If an operator X is encountered then: Remove the two top elements of STACK Evaluate B X A Place the result of (b) back on STACK. [End of IF Structure] [End of STEP2 loop] Set VALUE equal to the top element on STACK. Exit

Stack Postfix Operation Q: 5 * ( 6 + 2 ) – 12 / 4 P : 5 , 6 , 2 , + , * , 12 , 4 , / , - , ) Symbol Scanned STACK 5 5 6 5,6 2 5,6,2 + 5,8 * 40 12 40,12 4 40, 12, 4 / 40, 3 - 37 )

Transforming Infix to Postfix The following Algorithm Transforms the Infix Expression Q into its Equivalent Postfix Expression P The Algorithm uses a STACK to Temporarily Hold Operators and Left Parentheses. The Postfix Expression P will be Constructed from Left to Right using the Operands and Left Parentheses. The Postfix Expression P will be Constructed from Left to Right using the Operands from Q and the Operators which are Removed from STACK We begin by Pushing a Left Parenthesis onto STACK and Adding Right Parentheses at the End of Q The Algorithm is Completed when STACK is Empty.

Algorithm: POLISH (Q, P) PUSH “(” onto STACK, and add “)” to the end of Q Scan Q from left to right and repeat step 3 to step 6 for each element of Q until the STACK is empty. If an operands is encountered, add it to P If a left parenthesis is encountered, push it onto STACK If an operator X is encountered then: Repeatedly POP from STACK and add to P each operator (on the top of STACK) which has the same precedence as or higher precedence than X Add X to STACK [END of IF Structure] If a right parenthesis is encountered then: Repeatedly POP from STACK and add to P each operator (on the top of STACK) until a left parenthesis is encountered. Remove the left parenthesis [END of STEP 2 loop] EXIT

Q: A + ( B * C - ( D / E F ) * G ) * H ) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Symbol STACK Expression P A ( A + ( + A ( ( + ( A B ( + ( A B * ( + ( * A B C ( + ( * A B C - ( + ( - A B C * ( ( + ( - ( A B C * D ( + ( - ( A B C * D / ( + ( - ( / A B C * D E ( + ( - ( / A B C * D E

Q: A + ( B * C - ( D / E F ) * G ) * H ) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Symbol STACK Expression P ( + ( - ( / A B C * D E F ( + ( - ( / A B C * D E F ) ( + ( - A B C * D E F / * ( + ( - * A B C * D E F / G ( + ( - * A B C * D E F / G ) ( + A B C * D E F / G * - * ( + * A B C * D E F / G * - H ( + * A B C * D E F / G * - H ) A B C * D E F / G * - H * + P: A B C * D E F / G * - H * +

RECURSION Recursive Procedure and Function Recursion occurs when a Procedure call itself A Procedure call some other procedure that calls the calling Procedure again It is called a Recursive Procedure Procedure must contain a base criteria Procedure must be closer to the base criteria after each call It is called a Well Defined procedure

Factorial Function Product of Positive Integer from 1 to n Denoted by n! => n! = 1.2.3….(n-2).(n-1).n 0! = 1 , 5! = 1.2.3.4.5 = 120, 6! = 5! . 6 = 720 n! = n . ( n – 1 )! Definition If n = 0 then n! = 1 If n > 0, then n! = n. (n-1) !

Example: Postpone Decision 4! = 4 . 3! 3! = 3 . 2! 2! = 2. 1! 1! = 1. 0! 0! = 1 1! = 1.1 = 1 2! = 2.1 = 2 3! = 3.2 = 6 4! = 4.6 = 24

Reading Assignments: Level Number and Depth of Recursion FACTORIAL (FACT,N) 1 If N = 0 then Set FACT = 1 and Return 2 Set FACT := 1 [Initialize FACT for loop] 3 Repeat for K = 1 to N Set FACT := K * FACT [End of Loop] 4 Return FACTORIAL (FACT, N) 1 If N = 0 then Set FACT = 1 and Return 2 Call FACTORIAL (FACT, N – 1) 3 Set FACT := N * FACT Reading Assignments: Level Number and Depth of Recursion

DEQUES Input Restricted Deque Output Restricted Deque Insertion at Only One End but Deletion from Both Ends Output Restricted Deque Deletion from One End but Insertion at Both Ends

PRIORITY QUEUES Each Element has its own priority Higher Priority Elements will Processed before Lower Priority Elements Same Priority Elements will Processed According to their Order Can be Implemented by a One-Way List or Multiple Queues Reading Assignment Array Representation of Priority Queues

One-Way List Implementation Each Node Contain Three Fields INFO Field: Contains the Data PRN Field : Contains the Priority Number LINK Field : Link to the Next Node Start 1 2 2 AAA BBB CCC 3 4 5 DDD EEE FFF 3 GGG

Quick Sort An Stacks Application Quick Sort works on Divide and Conquer Rule Quick Sort Strategy is to Divide a List or Set into Two Sub-Lists or Sub-Sets. Pick an Element, Called a Pivot, from the List. Reorder the List so that all Elements which are Less than the Pivot come Before the Pivot and so that All Elements Greater than the Pivot come After it. After this Partitioning, the Pivot is in its Final Position. This is called the Partition operation. Recursively Sort the Sub-List of Lesser Elements and the Sub-List of Greater Elements.

Starting from the Right to Find the Number < 44 44 33 11 55 77 90 40 60 99 22 88 66 Starting from the Right to Find the Number < 44 22 33 11 55 77 90 40 60 99 44 88 66 From the Left to Find the Number > 44 22 33 11 44 77 90 40 60 99 55 88 66 22 33 11 40 77 90 44 60 99 55 88 66 22 33 11 40 44 90 77 60 99 55 88 66 Now 44 is on its Correct Position We can Process only One Sub-List at a Time Two Stacks Lower and Upper will be used

Lower Empty Upper Empty Lower 1,6 Upper 4,12 Lower 1,6 Upper 4,10 Boundary Values : Address of the First and Last values of Sub-List Lower 1 Upper 12 Lower Empty Upper Empty Lower 1,6 Upper 4,12 Lower 1,6 Upper 4,10 A[6] A[7] A[8] A[9] A[10] A[11] A[12] 90 77 60 99 55 88 66 66 77 60 99 55 88 90 66 77 60 90 55 88 99 66 77 60 88 55 90 99 First Sub-List Second Sub-List

QUICK ( A, N, BEG, END, LOC ) A : Name of Array N : Number of Elements BEG : Beginning Boundary Value END : Ending Boundary Value LOC : Position of the First Element Local Variables : LEFT RIGHT

1. [Initialize] Set LEFT := BEG, RIGHT := END and LOC := BEG 2 1. [Initialize] Set LEFT := BEG, RIGHT := END and LOC := BEG 2. [Scan from Right to Left] a) Repeat while A[LOC] <= A[RIGHT] RIGHT := RIGHT – 1 [End of Loop] b) If LOC = RIGHT, then : Return c) If [LOC] > A [RIGHT] ,then: 1) [Interchange A [LOC] and A[RIGHT] ] TEMP := A[LOC], A[LOC] = A[RIGHT], A[RIGHT]=TEMP 2) Set LOC := RIGHT 3) Go to Step 3 [End of If Structure]

3. [Scan from Left to Right] a) Repeat while A[LEFT] <= A[LOC] LEFT := LEFT + 1 [End of Loop] b) If LOC = LEFT, then : Return c) If [LEFT] > A [LOC] ,then: 1) [Interchange A [LEFT] and A[LOC] ] TEMP := A[LOC], A[LOC] = A[LEFT], A[LEFT]=TEMP 2) Set LOC := LEFT 3) Go to Step 2 [End of If Structure]

[Initialize] TOP := 0 [PUSH Boundary values of A onto Stacks when 2 or More Elements] If N > 1, then TOP:=TOP+1, LOWER[1]:=1, UPPER[1]:=N Repeat Steps 4 to 7 while TOP != 0 [Pop Sub-List from Stacks] Set BEG := LOWER[TOP] , END := UPPER[TOP] TOP := TOP -1 Call QUICK (A, N, BEG, END, LOC) [Push Left Sub-List onto Stacks when 2 or More Elements] If BEG < LOC - 1 then TOP := TOP + 1, LOWER[TOP] := BEG, UPPER[TOP] := LOC – 1 [End of If Structure] [Push Right Sub-List onto Stacks when 2 or More Elements] If LOC + 1 < END then TOP := TOP + 1, LOWER[TOP] := LOC + 1, UPPER[TOP] := END [End of If Structure] [End of Step 3 Loop] [Exit] (Quick Sort)

Reading Assignments Minimizing Overflow page: 168 Recursion 6.6 Tower of Hanoi 6.7 Implementation of Recursion by Stack 6.8 Double Ended Queue DEQUES 6.10 Priority Queues 6.11