Stacks

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)