Lecture Slides on Stack and Queue ADTs. Prepared by Dr. Ramana. IIT Jodhpur

Transcription

1 Lecture Slides on Stack and Queue ADTs Prepared by Dr. Ramana IIT Jodhpur

2 Stack ADT Last element inserted is removed first Operations PUSH (elemtype e) - inserts an item POP () - removes an element from top TOP () - returns the element at the top IsEmpty() - return true if stack is empty IsFull() - returns true if stack is full MakeNull() - to initialize stack variables All operations are performed in O(1), constant time

3 Implementation Using Arrays variables top - points the position to insert the next element maxlength maximum stack size S[maxLength] stores elements of type elementtype

4 IsFull and IsEmpty IsFull () If top > maxlentgh then return TRUE Else return FALSE IsEmpty () If top == 1 then return TRUE Else return FALSE

5 PUSH and POP operations PUSH (elemtype e) If (IsFull()) then Print Stack is full Else S[top] = e top = top + 1 POP() If (IsEmpty()) then Print Empty Stack Else top = top - 1

6 TOP and MAKENULL operations Top() If (IsEmpty()) Else Return ERROR MakeNull(int n) top = 1 Return S[top-1] MaxLength = n

7 Applications String reversal Function calls implementation A stack is maintained to store the activation records Each activation record (also known stack frame) stores details of local variables and their values, return address (that is program counter value), parameters to be passed to function Arithmetic expression evaluation Backtracking Towers of Hanoi and many more...

8 Arithmetic Express Evaluation Usual representation infix To be converted to postfix format as the precedences can easily be embedded in evaluation Two phase Converting infix to postfix Evaluating postfix expression

9 Operator Precedence/ Associativity Low to high + - * / % ^ (exponetiation operator) Associativity Left to right, + - * / % a * b / c = (a * b) / c, if two operators of same priority are compared, then the left one's priority is higher than right one's. Right to left, ^ a ^ b ^ c = a^(b^c) if two operators of same priority are compared, then the right one's priority is higher than left one's. Note only some binary operators are mentioned here. Generally a programming language supports a rich set of operators.

10 Converting infix to postfix (steps) 1. Read infix expression and initialze stack to store operators 2. Start read one token, T, at a time for the expresssion 3. If T is an operand then write T to output 4. Else /* T is operator */ 1. If prec(t) > prec( TOP() ) then PUSH (T) 2. Else if prec(t) == prec( TOP() ) AND T is right associative then PUSH (T) 3. Else 1.While ( prec(t) < prec(k=top()) 1.POP(), write K to output 2.PUSH (T) 5. Repeat steps 2 to 4 until all tokens are read from infix exp

11 Example: infix exp * 4 2 Write 5 to output, OUT=5 PUSH (+), STACK = { + } Write 3 to output, OUT=5 3 PUSH (*), STACK = {+ * } Write 4 to output, OUT=5 3 4 TOP(), POP ( ), OUT=5 3 4 *, STACK={ + } TOP(), POP( ), OUT=5 3 4 * +, STACK={ } PUSH ( - ), STACK = { - } Write 2 to output, OUT=5 3 4 * + 2 No more tokens, POP all from stack and write to output, OUT = * + 2 -

12 Evaluating Postfix * Operand stack to be maintained PUSH (5) PUSH (3) PUSH (4) O1 = TOP(), POP() O2 = TOP(), POP() temp = O1 * O2 PUSH (temp)

13 O1 = TOP(), POP() (Cont.) O2 = TOP(), POP() temp = O1 + O2, PUSH (temp) PUSH (2) O1 = TOP(), POP() O2 = TOP(), POP() temp = O1 + O2, 17 2 PUSH(temp) End of postfix expression, so result is in stack.

14 Evaluating postfix expression (for binary operators) 1. Operand stack to be maintained 2. Read postfix expression 1. If operand then PUSH 2. Else if operator 1.Rightoperand = TOP(); POP () 2.Leftoperand = TOP(); POP () 3.Temp = Leftoperand OP Rightoperand 4.PUSH (Temp) 3. Repeat from step 2 until reaching the end of the postfix exp 4. Final result will apprear at top of the stack

15 Dealing with parenthesis During infix to postfix conversion Always PUSH left parenthesis When right parenthesis is encountered, POP all items from the stack until the corresponding left parenthesis and write the items to the output

16 Queue ADT First in first out behaviour (FIFO) Items are removed from front end and insertions happen at rear end of QUEUE Operations EnQueue (elemtype e) inserts element e at the end DeQueue ( ) - deletes first element from queue Front ( ) - returns first element on queue IsEmpty(), IsFull(), MakeNull( )

17 Applications Numerous real world applications Queues in super market, petrol bunks, ticket counters, In computers and any other service stations Job scheduling in operating systems Job scheduling in printers Packet scheduling in network routers

18 Implementation Two pointers front points first element to be deleted from queue rear points the next position where the newly arriving element can be inserted maxlength maximum queue size QUEUE[maxLength] - stores elements of type elementtype

19 Empty queue condition Empty and Full Queue If rear == front then return TRUE Else return FALSE Full queue condition If rear > maxlength then return TRUE Else return FALSE EnQueue(elemType e) If IsFull ( ) then Print Queue Overflow Else Queue[rear] = e rear = rear + 1

20 (Cont.) addone(int i) Return i + 1 DeQueue( ) If IsEmpty () then print Queue Underflow Else front = addone(front) Front ( ) If IsEmpty () return ERROR Else return QUEUE[front]

21 Example Action front rear Initial Q 1 1 EnQueue ( A) A 1 2 EnQueue ( B) A B 1 3 EnQueue ( C) A B C 1 4 EnQueue ( D) A B C D 1 5 DeQueue () B C D 2 5 DeQueue () C D 3 5 EnQueue (X) C D Error QUEUE OVERFLOW as rear > maxqlength of 4

22 Issues EnQueue and DeQueue operations are expected to take constant time. However, IsFull() may report Queue Overflow even before queue is really full. To overcome from this, either EnQueue or DeQueue operation to be made as O(n) operation Ex, when an element is dequeued, all elements can be shifted left by one position to use the position that became free Alternatively Circular Queues can be used to perform each operation in O(1) time and to ensure reporting Queue Overflow event only when queue is really full.

23 Circular Queues Can be visualized as a queue that has no real end and it can loop / wrap around the buffer However, memory is not physically created as a ring, therefore a linear representation is used and rear and front pointers are warped around, if permitted and when reached maximum queue length.

24 addone(int i) (Cont.) return ( i % maxlentgh) + 1 Empty queue condition If rear == front then return TRUE Elese return FALSE Full queue condition If addone(rear) == front then return TRUE Else return FALSE

25 ENQUEUE & DEQUEUE EnQueue(elemType e) If IsFull ( ) then Print Queue Overflow Else Queue[rear] = e rear = addone(rear) DeQueue() If IsEmpty ( ) then Print Queue Underflow Else front = addone(front)