1. CE 221 Data Structures and Algorithms Chapter 3: Lists, Stacks, and Queues - II Text: Read Weiss, §3.6 1Izmir University of Economics

2. The Stack ADT – Stack Model A stack (LIFO list) is a list with the restriction that inserts and deletes can be performed in only one position, namely the end of the list called the top. The two operations on a stack are push, pop (also top to examine the item at the top). While pop on an empty stack is generally considered an ADT error, running out of space when performing a push is an implementation error but not an ADT error. Izmir University of Economics2

3. 3 Since a stack is a list, any list implementation will do. Singly Linked List implementation of a stack: push by inserting at the front, pop by deleting the element at the front. Array implementation of stack: It is the more popular solution. It uses the InsertToBack and DeleteFromBack from the Vector implementation. Associated with each stack is Array and TopOfStack which is set to -1 for an empty stack. Implementation of Stacks #define Error(Str) FatalError(Str) #define FatalError(Str) fprintf(stderr, "%s\n", Str), exit(1) #define EmptyTOS ( -1 ) #define MinStackSize ( 5 ) typedef int ElementType; struct StackRecord { int Capacity; int TopOfStack; ElementType *Array; }; typedef struct StackRecord *Stack;

4. Array Implementation of Stacks - I Izmir University of Economics4 int IsEmpty( Stack S ){ return S->TopOfStack == EmptyTOS; } int IsFull( Stack S ){ return S->TopOfStack == S->Capacity - 1; } Stack CreateStack( int MaxElements ){ Stack S; if(MaxElements<MinStackSize) Error("Stack size is too small"); S = malloc( sizeof( struct StackRecord ) ); if(S == NULL) FatalError("Out of space!!!"); S->Array = malloc(sizeof(ElementType)*MaxElements); if(S->Array == NULL) FatalError("Out of space!!!"); S->Capacity = MaxElements; MakeEmpty(S); return S; }

5. Izmir University of Economics5 Array Implementation of Stacks - II void MakeEmpty(Stack S){ S->TopOfStack = EmptyTOS; } void DisposeStack(Stack S){ if( S != NULL ){ free( S->Array ); free( S ); } void Push(ElementType X, Stack S){ if( IsFull( S ) ) Error( "Full stack" ); else S->Array[ ++S->TopOfStack ] = X; } void Pop( Stack S ){ if( IsEmpty( S ) ) Error( "Empty stack" ); else S->TopOfStack--; } ElementType Top( Stack S ){ /* TopandPop is similar */ if( !IsEmpty( S ) ) return S->Array[ S->TopOfStack ]; Error( "Empty stack" ); return 0; /* Return value used to avoid warning */ }

6. Izmir University of Economics6 Stack Applications - Balancing Symbols Compilers check programs for syntax errors, but frequently a lack of one symbol (such as a missing brace or comment starter) will cause the compiler to spill out a hundred lines of diagnostics. Thus, every right brace, bracket, and parenthesis must correspond to their left counterparts. Example: The sequence [()] is legal, but [(]) is not. stack  Ø; while (!eof(file)){ read(char); if (isOpening(char)) push(char, stack); else if (isClosing(char)) if (isEmpty(stack) error(); else cchar = topAndPop(stack); if (!isMatching(char,cchar)) error(); } if (!isEmpty(stack)) error(); It is clearly linear and actually makes only one pass through the input. It is thus on-line and quite fast.

7. Stack Applications – Postfix Expressions Order of evaluation for arithmetic expressions depending on the precedence and associativity of operators has a huge impact on the result of the evaluation. Example: 4.99 + 5.99 + 6.99 * 1.06 = produces either 19.05, or 18.39. Most simple four-function calculators will give the first answer, but better calculators know that multiplication has higher precedence than addition. A scientific calculator generally comes with parentheses, so we can always get the right answer by parenthesizing, but with a simple calculator we need to remember intermediate results. Izmir University of Economics7

8. Postfix Notation (((a*b)+c)+(d*e)) fully parenthesized T 1 =a*b, T 1 =T 1 +c, T 2 =d*e, T 1 =T 1 +T 2 by using intermediate results a b * c + d e * + is the equivalent of using intermediate results. This notation is known as postfix or reverse Polish notation. Notice that when an expression is given in postfix notation, there is no need to know any precedence rules. Izmir University of Economics8

9. Postfix Expression Evaluation Izmir University of Economics9 6 5 2 3 + 8 * + 3 + * First four symbols are placed on the stack. + 8 * + 3 + *8 * + 3 + ** + 3 + *+ 3 + * 3 + *+ ** This algorithm depicted below is clearly O(N)

10. Infix to Postfix Conversion We can use stacks to convert an expression in standart form (otherwise known as infix) into postfix. Example: operators = {+, *, (, )}, usual precedence rules; a + b * c + (d * e + f) * g Answer = a b c * + d e * f + g * + Izmir University of Economics10

11. Infix to Postfix - Algorithm Izmir University of Economics11 stack  Ø; while (! eos(expr)){ read(char); if (isOperand(char)) output(char); else if (char == “)”) while ((!isEmpty(stack))&&((sc=topAndPop(stack))!= “(”)) output(sc); else while ( (!isEmpty(stack)) && (inStackPriority(top(stack))>=(outStackPriority(char)))) output(topAndPop(stack)); push(char, stack); } while (!isEmpty(stack)) output(topAndpop(stack)); inStackPriority(“(”)=very low outStackPriority(“(”)=very high

12. Infix to Postfix – Example I 12 * c + (d * e + f) * g + (d * e + f) * g (d * e + f) * g * e + f) * g a + b * c + (d * e + f) * g Izmir University of Economics

13. Infix to Postfix – Example II 13 + f) * g ) * g * g Izmir University of Economics

14. Function Calls The algorithm to check balanced symbols suggests a way to implement function calls. The problem here is that when a call is made to a new function, all the variables local to the calling routine need to be saved by the system. Furthermore, the current location in the routine must be saved so that the new function knows where to go after it is done. “(“ and “)” are exactly like function call and function return. Every PL implementing recursion has that mechanism. The information saved is called either an activation record or stack frame. There is always the possibility that you will run out of stack space by having too many simultaneously active functions. On many systems there is no checking for overflow. Izmir University of Economics14

15. Function Calls and Recursion The routine print_list printing out a linked list, is perfectly legal and actually correct. It properly handles the base case of an empty list, and the recursion is fine. Unfortunately, if the list contains 20,000 elements, there will be a stack of 20,000 activation records (and hence possibly a program crash). An example of an extremely bad use of recursion known as tail recursion (recursive call at the last line). It can be automatically eliminated by enclosing the body in a while loop and replacing the recursive call with one assignment per function argument. Izmir University of Economics15 void print_list( LIST L ) { if( L != NULL ) { print_element(L->element); print_list( L->next ); } void print_list( LIST L ){ while (1) { if( L != NULL ){ print_element(L->element); L = L->next; }

16. Homework Assignments 3.23, 3.24, 3.25.a, You are requested to study and solve the exercises. Note that these are for you to practice only. You are not to deliver the results to me. Izmir University of Economics16