1. Chapter 5 ADTs Stack and Queue

2. 2 Goals Describe a stack and its operations at a logical level Demonstrate the effect of stack operations using a particular implementation of a stack Implement the Stack ADT, in both an array- based implementation and a linked implementation Describe the structure of a queue and its operations at a logical level

3. 3 Goals Demonstrate the effect of queue operations using a particular implementation of a queue Implement the Queue ADT, using both a an array-based implementation and a linked implementation Use inheritance to create a Counted Queue ADT

4. 4 Stacks of Coins and Bills

5. 5 Stacks of Boxes and Books TOP OF THE STACK

6. 6 Stacks What do these composite objects all have in common?

7. 7 Stacks Stack An abstract data type in which elements are added and removed from only one end (FIFO)

8. Stacks What operations would be appropriate for a stack? 8

9. Stacks Transformers –Push –Pop Observers –IsEmpty –IsFull –Top change state observe state 9 What about an iterator?

10. 10 Stacks For what type of problems would stacks be useful?

11. 11 Stacks class StackType { public: StackType(); bool IsEmpty() const; bool IsFull() const; void Push(ItemType item); void Pop(); ItemType Top() const; Logical Level

12. 12 Array-Based Implementation private: int top; ItemType items[MAX_ITEMS]; }; [0] [1] [2] …. [M..] stack.items.top Physical Level

13. 13 Array-Based Implementation Give a series of operations that could produce this situation

14. 14 Array-Based Implementation To what do we initialize top ? 0 or -1 Do we increment or store first? 0: store and increment -1: increment and store Which is better?

15. 15 Array-Based Implementation Before we code, we must consider error conditions Stack overflow The condition that results from trying to push an element on to a full stack Stack underflow The condition that results from trying to pop an empty stack

16. 16 Array-Based Implementation StackType::StackType() { top = -1; } bool StackType::IsEmpty() const { return ( top = -1); } bool StackType::IsFull() const { return ( top == MAX_ITEMS); } What does const mean?

17. 17 Array-Based Implementation void StackType::Push(ItemType newItem) { if (IsFull()) throw FullStack(); top++; items[top] = newItem; } What is FullStack() ?

18. 18 Array-Based Implementation void StackType::Pop() { if (IsEmpty()) throw EmptyStack(); top- -; } ItemType StackType::Top() const { if (IsEmpty()) throw EmptyStack(); return (items[top]); } What is EmptyStack ?

19. 19 Array-Based Implementation Which functions have to be changed if we dynamically allocate the array items ? Do we need to add any new functions?

20. 20 Linked Implementation The logical level (public part of the class declaration) stays the same; the implementation level (private part of the class declaration) changes private: NodeType* topPtr; } Can we “borrow” code from UnsortedType for Push and Pop ?

21. 21 Linked Implementation void StackType::Push(ItemType newItem) { if (IsFull()) throw FullStack(); else { NodeType* location; location = new NodeType; location->info = newItem; location>next = topPtr; topPtr = location; }

22. 22 Linked Implementation void StackType::Pop() { if (IsEmpty()) throw EmptyStack(); else { NodeType* tempPtr; tempPtr = topPtr; topPtr = topPtr->next; delete tempPtr; } Does this work for stacks of one item? More than one item?

23. 23 Linked Implementation More than one item

24. 24 Linked Implementation One item

25. 25 Linked Implementation What about the constructor, destructor, and observer functions? We can borrow all but Top from class UnsortedType ItemType StackType::Top() { if (IsEmpty()) throw EmptyStack else return topPtr->info; }

26. 26 Queues

27. 27 Queues

28. 28 Queues What do these composite objects all have in common?

29. 29 Queues Queue An abstract data type in which elements are added to the rear and removed from the front; a “first in, first out” (FIFO) structure

30. Queues What operations would be appropriate for a queue? 30

31. Queues Transformers –MakeEmpty –Enqueue –Dequeue Observers –IsEmpty –IsFull change state observe state 31 What about an iterator?

32. 32 Queues For what type of problems would stacks be useful?

33. 33 Queues class QueType { public: QueType(int max); QueType(); ~QueType(); bool IsEmpty() const; bool IsFull() const; void Enqueue(ItemType item); void Dequeue(ItemType& item); Logical Level

34. 34 Array-Based Implementation private: ItemType* items; // Dynamically allocated array int maxQue; // Whatever else we need } Implementation level

35. 35 Array-Based Implementation One data structure: An array with the front of the queue fixed in the first position Enqueue A, B, C, D Dequeue Move elements down What’s wrong with this design?

36. 36 Array-Based Implementation Another data structure: An array where the front floats What happens if we add X, Y, and Z ?

37. 37 Array-Based Implementation We can let the queue wrap around in the array; i.e. treat the array as a circular structure

38. 38 Array-Based Implementation Empty Queue Full Queue How can we tell the difference?

39. 39 Array-Based Implementation A third data structure:Front indicates the slot preceding the front item;it is reserved and not used Empty Queue Full Queue

40. 40 Array-Based Implementation private: int front; int rear; int maxQue; ItemType* items; } Complete implementation level To what do we initialize front and rear ?

41. 41 Array-Based Implementation QueType::QueType(int max) { maxQue = max + 1; front = maxQue - 1; rear = maxQue - 1; items = new ItemType[maxQue]; } bool QueType::IsEmpty( ) { return ( rear == front );} bool QueType::IsFull( ) { return ( (rear + 1) % maxQue == front )} Why is the array declared max + 1 ?

42. 42 Array-Based Implementation void QueType::Enqueue(ItemType new Item) { if (IsFul()) throw FullQueue(); else { rear = (rear + 1) % maxQue; items[rear] = newItem; }

43. 43 Array-Based Implementation void QueType::Dequeue(ItemType& item) { if (IsEmpty()) throw EmptyQueue(); else { front = (front + 1) % maxQue; item = items[front]; }

44. 44 Counted Queue A queue that has an additional function GetLength that returns the number of items in the queue What functions must be defined in class CountedQue?

45. 45 Counted Queue class CountedQueType : public QueType { public: CountedQueType(); void Enqueue(ItemType newItem); void Dequeue(ItemType& item); int GetLength( ) const; private: int length; };

46. 46 Counted Queue

47. 47 Counted Queue void CountedQueType::Enqueue(ItemType newItem) { try { QueType::Enqueue(newItem); length++; } catch(FullQueue) { throw FullQueue();} } Why must the call to Enqueue be embedded within a try/catch statement? What is this?

48. 48 Counted Queue Does the derived class have access to the base class’s private data members in C++?

49. 49 Linked Implementation Data structure for linked queue

50. 50 Linked Implementation Enqueue(newItem) Set newNode to the address of newly allocated node Set Info(newNode) to newItem Set Next(newNode) to NULL Set Next(rear) to newNode If queue is empty Set front to newNode else Set Next(rear) to newNode

51. 51 Linked Implementation Dequeue(item) Set tempPtr to front Set item to Info(front) Set front to Next(front) if queue is now empty Set rear to NULL Deallocate Node(tempPtr)

52. 52 Linked Implementation A circular linked queue uses only one external pointer: rear How do you access front?

53. 53 Storage Requirements What does this table tell you ?

54. 54 C++ Tips cerr Error output stream available in ; intended for error messages exit(n) A function that cleans up and terminates a program, available in