VTU NOTES QUESTION PAPERS NEWS RESULTS FORUMS THE STACK

Transcription

1 Contents: Definition and Examples Representing stacks in C Example: infix, prefix, and postfix Exercises THE STACK Definition and Examples A stack is an ordered collection of items into which new items may be inserted and from which items may be deleted at one end, called the top of the stack. A stack is a dynamic, constantly changing object as the definition of the stack provides for the insertion and deletion of items. It has single end of the stack as top of the stack, where both insertion and deletion of the elements takes place. The last element inserted into the stack is the first element deleted-last in first out list (LIFO). After several insertions and deletions, it is possible to have the same frame again. Primitive Operations When an item is added to a stack, it is pushed onto the stack. When an item is removed, it is popped from the stack. Given a stack s, and an item i, performing the operation push(s,i) adds an item i to the top of stack s. push(s, H); push(s, I); push(s, J); Operation pop(s) removes the top element. That is, if i=pop(s), then the removed element is assigned to i. pop(s); 1

2 Because of the push operation which adds elements to a stack, a stack is sometimes called a pushdown list. Conceptually, there is no upper limit on the number of items that may be kept in a stack. If a stack contains a single item and the stack is popped, the resulting stack contains no items and is called the empty stack. Push operation is applicable to any stack. Pop operation cannot be applied to the empty stack. If so, underflow happens. A Boolean operation empty(s), returns TRUE if stack is empty. Otherwise FALSE, if stack is not empty Example To check the parentheses in any mathematical expression, are nested correctly, we need to ensure that, There are an equal number of right and left parentheses Every right parentheses is preceded by a matching left parentheses For instance, ((A+B) A+B( )A+B(-C (A+B))-(C+D Each left parentheses opens the scope and right parentheses closes the scope. The nesting depth at a particular point in an expression is the number of scopes that have been opened but not yet closed at that point. The parentheses count at a particular point in an expression is the number of left parentheses minus the number of right parentheses that have been encountered in scanning the expression from its left end up to that particular point. The two conditions that must hold if the parentheses in an expression form an admissible pattern are as follows: The parentheses count at the end of the expression is 0. 2

3 The parentheses count at each point in the expression is nonnegative. A scope ender must be of the same type as its scope opener. Thus, the following strings are illegal. (A+B], [(A++B], A-(B] The last scope to be opened must be the first to be closed. This is simulated by a stack in which the last element arriving is the first to leave. Representing stacks in C Before programming a problem solution that uses a stack, we must decide how to represent the stack in a programming language. It is an ordered collection of items. In C, we have ARRAY as an ordered collection of items. But a stack and an array are two different things. The number of elements in an array is fixed. A stack is a dynamic object whose size is constantly changing. So, an array can be declared large enough for the maximum size of the stack. A stack in C is declared as a structure containing two objects: An array to hold the elements of the stack. An integer to indicate the position of the current stack top within the array. #define STACKSIZE 100 struct stack int top; int items[stacksize]; ; The stack s may be declared by struct stack s; The stack items may be either int, float, char, etc. The empty stack contains no elements and can therefore be indicated by top= -1. To initialize a stack S to the empty state, we may initially execute s.top= -1. 3

4 To determine stack empty condition, if (s.top=-1) stack empty; else stack is not empty; The empty(s) may be considered as follows: int empty(struct stack *ps) if(ps->top== -1) return(true); else return(false); Aggregating the set of implementation-dependent trouble spots into small, easily identifiable units is an important method of making a program more understandable and modifiable. This concept is known as modularization, in which individual functions are isolated into low-level modules whose properties are easily verifiable. These low-level modules can then be used by more complex routines, which do not have to concern themselves with the details of the lowlevel modules but only with their function. The complex routines may themselves then be viewed as modules by still higher-level routines that use them independently of their internal details. Implementing pop operation If the stack is empty, print a warning message and halt execution. Remove the top element from the stack. Return this element to the calling program int pop(struct stack *ps) if(empty(ps)) 4

5 printf( %, stack underflow ); exit(1); return(ps->items[ps->top--]); Testing for exceptional conditions Within the context of a given problem, it may not be necessary to halt execution immediately upon the detection of underflow. Instead, it might be more desirable for the pop routine to signal the calling program that an underflow has occurred. void popandtest(struct stack *ps, int *px, int *pund) if(empty(ps)) *pund=true; return; *pund=false; *px=ps->items[ps->top--]; return; Implementing push operation void push (struct stack *ps, int x ) ps -> items [++(ps->top)] =x; return; Overflow may happen as stack implementation uses an array. So, 5

6 void push (struct stack *ps, int x) if (ps->top == STACKSIZE-1) printf ( overflow ); exit(1); else ps -> items [++(ps->top)] =x; return; Sometimes, it may not be necessary to halt execution immediately upon the detection of overflow. Instead, the calling program can take corrective action after receiving the overflow signal from push routine - pushandtest(). Example: Infix, postfix and prefix Pre, post and in refer to the relative position of the operator with respect to the two operands. In prefix notation, the operator precedes the two operands. In postfix notation, the operator follows the two operands. In infix notation, the operator is between the two operands. The evaluation of the expression requires knowledge of precedence of operators Highest to lowest Exponentiation ($) Multiplication/division Addition/subtraction The associatively for $ only is assumed to be from right to left Examples Consider the following infix expressions ((A+B)*C-(D-E))$(F+G) A-B/(C*D$E) 6

7 A$B*C-D+E/F/(G+H) Its corresponding postfix expressions are: AB+C*DE FG+$ ABCDE$*/- AB$C*D-EF/GH+/+ Its corresponding prefix expressions are: $-*+ABC-DE+FG -A/B*C$DE +-*$ABCD//EF+GH The precedence rules for converting an expression from infix to postfix are identical. Remember that, the prefix form of a complex expression is not the mirror image of the postfix form. Both postfix and prefix expressions requires no parentheses. Evaluating a postfix expression Let us now consider an example. Suppose that we are asked to evaluate the following postfix expression: / + * 2 $ 3 + Symb Opnd1 Opnd2 Value opndstk ,2 3 6,2, , , ,3, ,3,8,2 / ,3,4 7

8 ,7 * ,2 $ , Each time we read an operand, we push it onto a stack. When we reach an operator, its operands will be the top two elements on the stack. We can then pop these two elements, perform the indicated operation on them, and push the result on the stack so that it will be available for use as an operand of the next operator. The maximum size of the stack is the number of operands that appear in the input expression. But usually, the actual size of the stack needed is less than maximum, as operator pops the top two operands. Program to evaluate postfix expression Along with push, pop, empty operations, we have eval, isdigit and oper operations. eval the evaluation algorithm double eval(char expr[]) int c, position; double opnd1, opnd2, value; struct stack opndstk; opndstk.top=-1; for (position=0 ;( c=expr [position])!= \0 ; position++) if (isdigit) push (&opndstk, (double) (c- 0 )); else opnd2=pop (&opndstk); 8

9 opnd1=pop (&opndstk); value=oper(c, opnd1,opnd2); push (&opndstk. value); return(pop(&opndstk)); isdigit called by eval, to determine whether or not its argument is an operand int isdigit(char symb) return(symb>= 0 && symb<= 9 ); oper to implement the operation corresponding to an operator symbol double oper(int symb, double op1, double op2) switch (symb) case + : return (op1+op2); case - : return (op1-op2); case * : return (op1*op2); case / : return(op1/op2); case $ : return (pow (op1, op2); default: printf ( %s, illegal operation ); exit(1); Limitations of the program The program does nothing in terms of error detection and recovery. Depending on the specific type of error, the computer may take one of several actions. Suppose that at the final statement of the program, the stack opndstk is not empty. We get no 9

10 error messages and eval returns a numerical value for an expression that was probably incorrectly stated in the first place. Suppose that one of the calls to the pop routine raises the underflow conditions. Since we did not use the popandtest routine to pop elements from the stack, the program halts. Converting an expression from infix to postfix Consider the given parentheses free infix expression: A + B * C Symb Postfix string opstk 1 A A 2 + A + 3 B AB + 4 * AB + * 5 C ABC + * 6 ABC * + 7 ABC * + Consider the given parentheses infix expression: (A+B)*C Symb Postfix string Opstk 1 ( ( 2 A A ( 3 + A ( + 4 B AB ( + 5 ) AB+ 6 * AB+ * 7 C AB+C * 8 AB+C* 10

11 Program to convert an expression from infix to postfix Along with pop, push, empty, popandtest, we also make use of additional functions such as, isoperand, prcd, postfix. isoperand returns TRUE if its argument is an operand and FALSE otherwise prcd accepts two operator symbols as arguments and returns TRUE if the first has precedence over the second when it appears to the left of the second in an infix string and FALSE otherwise postfix prints the postfix string Examples exercises 1. Assume A=1, B=2, C=3 Evaluate the following postfix expressions AB+C-BA+C$- ABC+*CBA-+* 2. Transformation or conversion exercises 3. Convert the following infix expression to postfix ((A-(B+C))*D)$(E+F) ***** 11