Download presentation

Presentation is loading. Please wait.

Published byHenry Dewhirst Modified about 1 year ago

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

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google