1 / 48

Stacks

Stacks. CS 302 – Data Structures Sections 5.1, 5.2, 6.1, 6.5. Warning. Although data structure concepts between this and last semesters will be the same, there might be implementation differences.

rmatney
Download Presentation

Stacks

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. Stacks CS 302 – Data Structures Sections 5.1, 5.2, 6.1, 6.5

  2. Warning • Although data structure concepts between this and last semesters will be the same, there might be implementation differences. • Your answers in questions in quizzes and exams should be based on this semester’s (CS302) implementations!

  3. Definitions class specification • ImageType.h • ImageType.cpp • Driver.cpp class implementation application (client code)

  4. Question • In object oriented programming, class implementation details are hidden from applications that use the class. • Why?

  5. TOP OF THE STACK TOP OF THE STACK What is a stack? • It is an ordered group of homogeneous items. • Items are added to and removed from the top of the stack LIFO property: Last In, First Out • The last item added would be the first to be removed

  6. Stack Implementations Array-based Linked-list-based

  7. Array-based Stacks template<class ItemType> class StackType { public: StackType(int); void MakeEmpty(); bool IsEmpty() const; bool IsFull() const; void Push(ItemType); void Pop(ItemType&); private: int top, maxStack; ItemType *items; }; dynamically allocated array

  8. Array-based Stacks (cont’d) template<class ItemType> StackType<ItemType>::StackType(int size) { top = -1; maxStack = size; items = new ItemType[max]; } template<class ItemType> StackType<ItemType>::~StackType() { delete [ ] items; } O(1) O(1)

  9. Array-based Stacks (cont’d) template<class ItemType> void StackType<ItemType>::MakeEmpty() { top = -1; } O(1)

  10. Array-based Stacks (cont.) template<class ItemType> bool StackType<ItemType>::IsEmpty() const { return (top == -1); } template<class ItemType> bool StackType<ItemType>::IsFull() const { return (top == maxStack-1); } O(1) O(1)

  11. Push (ItemType newItem) • Function: Adds newItem to the top of the stack. • Preconditions: Stack has been initialized and is not full. • Postconditions: newItem is at the top of the stack.

  12. Stack overflow • The condition resulting from trying to push an element onto a full stack. if(!stack.IsFull()) stack.Push(item);

  13. Array-based Stacks (cont.) template<class ItemType> void StackType<ItemType>::Push(ItemType newItem) { top++; items[top] = newItem; } O(1)

  14. Pop (ItemType& item) • Function: Removes topItem from stack and returns it in item. • Preconditions: Stack has been initialized and is not empty. • Postconditions: Top element has been removed from stack and itemis a copy of the removed element.

  15. Stack underflow • The condition resulting from trying to pop an empty stack. if(!stack.IsEmpty()) stack.Pop(item);

  16. Array-based Stacks (cont.) template<class ItemType> void StackType<ItemType>::Pop(ItemType& item) { item = items[top]; top--; } O(1)

  17. Templates • Templates allow the compiler to generate multiple versions of a class type by allowing parameterized types. • Compiler generates distinct class types and gives its own internal name to each of the types.

  18. Compiling Templates • Cannot anymore compile StackType.cpp separately from the application of the class (e.g., driver.cpp) • Compiler needs to know the data type of the stack to instantiate the class! • Where can the compiler find this information?

  19. Compiling Templates (cont’d) // Client code StackType<int> myStack; StackType<float> yourStack; StackType<StrType> anotherStack; myStack.Push(35); yourStack.Push(584.39);

  20. Compiling Templates (cont’d) • Must compile StackType.cpp and client code (e.g., driver.cpp) together! • Use “include” directive to include StackType.cpp at the end of StackType.h (2) “include” StackType.h in client’s code (3) Compile client code

  21. Linked-list-based Stacks • template<class ItemType> struct NodeType<ItemType> { ItemType info; NodeType<ItemType>* next; };

  22. Linked-list-based Stacks (cont’d) template<class ItemType> struct NodeType<ItemType>; template<class ItemType> class StackType { public: StackType(); ~StackType(); void MakeEmpty(); bool IsEmpty() const; bool IsFull() const; void Push(ItemType); void Pop(ItemType&); private: NodeType<ItemType>* topPtr; };

  23. Linked-list-based Stacks (cont’d) O(1) template<class ItemType> StackType<ItemType>::StackType() { topPtr = NULL; } template<class ItemType> void StackType<ItemType>::MakeEmpty() { NodeType<ItemType>* tempPtr; while(topPtr != NULL) { tempPtr = topPtr; topPtr = topPtr->next; deletetempPtr; } } O(N)

  24. Linked-list-based Stacks (cont’d) template<class ItemType> StackType<ItemType>::~StackType() { MakeEmpty(); } template<class ItemType> boolStackType<ItemType>::IsEmpty() const { return(topPtr == NULL); } O(N) O(1)

  25. Linked-list-based Stacks (cont’d) template<class ItemType> boolStackType<ItemType>::IsFull()const { NodeType<ItemType>* location; location = new NodeType<ItemType>; // test if(location == NULL) return true; else { delete location; return false; } } O(1)

  26. Push (ItemType newItem) • Function: Adds newItem to the top of the stack. • Preconditions: Stack has been initialized and is not full. • Postconditions: newItem is at the top of the stack.

  27. Pushing on a non-empty stack

  28. Pushing on a non-empty stack (cont.) • The order of changing the pointers is important!

  29. Special Case: pushing on an empty stack

  30. Function Push template <class ItemType> void StackType<ItemType>::Push(ItemType item) { NodeType<ItemType>* location; location = new NodeType<ItemType>; location->info = newItem; location->next = topPtr; topPtr = location; } O(1)

  31. Pop (ItemType& item) • Function: Removes topItem from stack and returns it in item. • Preconditions: Stack has been initialized and is not empty. • Postconditions: Top element has been removed from stack and itemis a copy of the removed element.

  32. Popping the top element

  33. Popping the top element(cont.) Need a temporary pointer !

  34. Special case: popping the last element on the stack tempPtr

  35. Function Pop template <class ItemType> void StackType<ItemType>::Pop(ItemType& item) { NodeType<ItemType>* tempPtr; item = topPtr->info; tempPtr = topPtr; topPtr = topPtr->next; deletetempPtr; } O(1)

  36. Comparing stack implementations

  37. Array-vs Linked-list-based Stack Implementations • Array-based implementation is simple but: • The size of the stack must be determined when a stack object is declared. • Space is wasted if we use less elements. • We cannot "enqueue" more elements than the array can hold. • Linked-list-based implementation alleviates these problems but time requirements might increase.

  38. Example using stacks: evaluate postfix expressions • Postfix notation is another way of writing arithmetic expressions. • In postfix notation, the operator is written after the two operands. infix: 2+5 postfix: 2 5 + • Why using postfix notation? Precedence rules and parentheses are not required!

  39. Example: postfix expressions(cont.) Expressions are evaluated from left to right.

  40. Postfix expressions:Algorithm using stacks (cont.)

  41. Exercise 15: Write the body for a client function that replaces each copy of an item in a stack with another item. Use the following specification. ReplaceItem(StackType& stack, ItemType oldItem, ItemType newItem) Function: Replaces all occurrences of oldItem with newItem. Precondition: stack has been initialized. Postconditions: Each occurrence of oldItem in stack has been replaced by newItem. Order of other elements remains unchanged. Warning: you may not assume any knowledge of how the stack is implemented!

  42. 1 3 5 2 3 1 3 5 1 Stack tempStack { ItemType item; StackType tempStack; while (!Stack.IsEmpty()) { Stack.Pop(item); if (item==oldItem) tempStack.Push(newItem); else tempStack.Push(item); } while (!tempStack.IsEmpty()) { tempStack.Pop(item); Stack.Push(item); } } Stack oldItem = 2 newItem = 5

  43. What are the time requirements using big-O? { ItemType item; StackType tempStack; while (!Stack.IsEmpty()) { Stack.Pop(item); if (item==oldItem) tempStack.Push(newItem); else tempStack.Push(item); } while (!tempStack.IsEmpty()) { tempStack.Pop(item); Stack.Push(item); } } O(N)

  44. Exercises 19, 20

  45. Exercises 19, 20

  46. Exercise 20 large small

  47. Exercise 20 (cont’d) etc.

  48. Exercise 20 (cont’d)

More Related