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 ImageType.h ImageType.cpp Driver.cpp class specification class implementation application (client code)

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

5. 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 TOP OF THE STACK

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

7. Array-based Stacks template 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 StackType ::StackType(int size) { top = -1; maxStack = size; items = new ItemType[max]; } template StackType ::~StackType() { delete [ ] items; } O(1)

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

10. Array-based Stacks (cont.) template bool StackType ::IsEmpty() const { return (top == -1); } template bool StackType ::IsFull() const { return (top == maxStack-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 void StackType ::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 item is 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 void StackType ::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 myStack; StackType yourStack; StackType 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! StackType.cpp StackType.h (1)Use “include” directive to include StackType.cpp at the end of StackType.h StackType.h (2) “include” StackType.h in client’s code (3) Compile client code

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

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

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

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

25. Linked-list-based Stacks (cont’d) template IsFull() bool StackType ::IsFull() const { NodeType * location; location = new NodeType ; // 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 Push void StackType ::Push(ItemType item) { NodeType * location; location = new NodeType ; 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 item is 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 Pop void StackType ::Pop(ItemType& item) { NodeType * tempPtr; item = topPtr->info; tempPtr = topPtr; topPtr = topPtr->next; delete tempPtr; } O(1)

36. Comparing stack implementations Big-O Comparison of Stack Operations OperationArray Implementation Linked Implementation ConstructorO(1) MakeEmptyO(1)O(N) IsFullO(1) IsEmptyO(1) PushO(1) PopO(1) DestructorO(1)O(N)

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. { 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); } 1 2 3 3 5 1 1 5 3 Stack tempStack oldItem = 2 newItem = 5

43. { 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) What are the time requirements using big-O?

44. Exercises 19, 20

46. Exercise 20 small large

47. Exercise 20 (cont’d) etc.

48. Exercise 20 (cont’d)