1 / 15

CS 201 Data Structures and Algorithms

CS 201 Data Structures and Algorithms. Chapter 3: Lists, Stacks, and Queues - II T ext : Read Weiss, § 3 . 6. The Stack ADT – Stack Model.

msippel
Download Presentation

CS 201 Data Structures and Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 201Data Structures and Algorithms Chapter 3: Lists, Stacks, and Queues - II Text: Read Weiss, §3.6 Izmir 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 Economics

  3. Implementation of Stacks • 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. #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; Izmir University of Economics

  4. Array Implementation of Stacks - I 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( structStackRecord ) ); 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; } Izmir University of Economics

  5. Array Implementation of Stacks - II 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--; } void MakeEmpty(Stack S){ S->TopOfStack = EmptyTOS; } void DisposeStack(Stack S){ if( S != NULL ){ free( S->Array ); free( S ); } } 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 */ } Izmir University of Economics

  6. Stack Applications - Balancing Symbols stack  Ø; while (!eof(file)){ read(char); if(isOpening(char)) push(char, stack); elseif(isClosing(char)) if(isEmpty(stack) error(); else cchar = topAndPop(stack); if(!isMatching(char,cchar)) error(); } if(!isEmpty(stack)) error(); • 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 mustcorrespond to their left counterparts. • Example: The sequence [()] is legal, but [(]) is not. It is clearly linear and actually makes only one pass through the input. It is thus on-line and quite fast. Izmir University of Economics

  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 Economics

  8. Postfix Notation • (((a*b)+c)+(d*e)) fully parenthesized • T1=a*b, T1=T1+c, T2=d*e, T1=T1+T2 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 Economics

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

  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 Economics

  11. Infix to Postfix - Algorithm 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(pop(stack)); inStackPriority(“(”)=very low outStackPriority(“(”)=very high Izmir University of Economics

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

  13. Infix to Postfix – Example II • + 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 orstack 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 Economics

  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. voidprint_list( LIST L ){ while (1) { if( L != NULL ){ print_element(L->element); L = L->next; } } } voidprint_list( LIST L ) { if( L != NULL ) { print_element(L->element); print_list( L->next ); } } Izmir University of Economics

More Related