Lecture08 stacks and-queues_v3

1

Chapter 7

Stacks and Queues

2

Stack ADT

• Recall that ADT is abstract data type, a set of data and a set of operations that act upon the data.

• In a stack, the set of data is the stack of elements.

• Stack is known as a LIFO (last-in-first-out) data structure because the last data to enter the stack is the first to exit the stack.

3

Stack ADT Operations

• push: places an element onto the top of a stack.

• pop: removes an element from the top of the stack.

• peek: which retrieves (copies) a value from the top of the stack without removing it.

• an operation to determine whether or not the stack is empty.

• an operation to empty out a stack.

4

Push

17

5

11

3

• Push means place a new data element at the top of the stack

stack

5

Push (cont.)

17

5

11

3


stack

6

Push (cont.)

17

5

11

3


stack

7

Pop

17

5

11

3

• Pop means take a data element off the top of the stack

stack

8

Pop (cont.)

17

5

11

3


stack

9

Pop (cont.)

17

5

11

3


stack

10

Peek

17

5

11

3

3

• Peek means retrieve the top of the stack without removing it

stack

11

3 template <typename T>4 class Stack {5 public:6 Stack() { … }7 ~Stack( ) { … }8 void push( T& elementToPush ) { … }9 bool pop( T& poppedElement ) { … }10 bool peek( T& topElement ) { … }11 bool isEmpty( ) const { … }12 void makeEmpty( ) { … }13 private:14 T* elements; // dynamic array15 int size;16 int top;17 };

Array Stack Class Template

used as an index to the top of the stack

12

3 Stack () : top(-1), size(0)4 {5 elements = NULL;6 }7 8 ~Stack( )9 {10 makeEmpty( );11 }

Array Stack Constructor and Destructor

13

Array StackisEmpty and makeEmpty

65 bool isEmpty( ) const66 {67 return top == -1;68 }6970 void makeEmpty( )71 {72 size = 0;73 top = -1; 74 delete [] elements;75 }

14

Array Stack Pop

125 25 200 70

elements

0 1 2 3 top

An element can’t really be removed from an array, as one would think pop would achieve.

15

Array Stack Pop(cont.)

125 25 200 70

elements

0 1 2 3 top

The element 70 is at the top of the stack, and what really happens during a pop, is that 70 is returned to the client…

client

16


125 25 200 70

elements

0 1 2 3 top

and top is decremented…

client

17


125 25 200 70

elements

0 1 2 3 top

The element 70 is still in the array, but it is no longer accessible. The next push will overwrite it. Say, we would like to push 63…

client

18

Array Stack Push

125 25 200 70

elements

0 1 2 3 top

First, top is incremented…

19

Array Stack Push(cont.)

125 25 200 63

elements

0 1 2 3 top

Then, 63 is pushed into that position…

20

Is the Array Stack Full/Empty?• An array stack is full when

– top == size - 1• An array stack is empty when

– top == -1

21

Linked-List Stack

• Stacks can also be implemented with a linked list.

• The front node is the top of the stack.

22

Bo b Ali

Linked-List Stack(cont.)

top

To pop, we remove the node at the front of the linked list, and return the element to the client…

Ali top

23

Linked-List Stack(cont.)

top

To push Cat, we place the new element in a node and insert it at the front of the linked list…

Cat top Ali

Ali

24

Linked-List Stack Class Template

13 template <typename T>14 class Stack {15 public:16 Stack( ) { … }17 ~Stack( ) { … }18 void push( const T & element ) { … }19 bool pop( T & element ) { … }20 bool peek( T & element ) { … }21 bool isEmpty( ) const { … } 22 void makeEmpty( ) { … }23 private:24 Node<T> *top;25 };

25

8 Stack( ) : top(NULL) { }7 8 ~Stack( )9 {10 makeEmpty( );11 }

Linked-List Stack Constructor and Destructor

26

Linked-List Push

32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) {36 newNode->next = NULL;37 top = newNode;38 } 39 else {40 newNode->next = top;41 top = newNode;42 }43 }

newNode

27

Linked-List Push into Empty Stack

32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) { // if stack is empty.36 newNode->next = NULL;37 top = newNode;38 } 39 else {40 newNode->next = top;41 top = newNode;42 }43 }

top

newNode

NULL

28

Linked-List Push into Empty Stack (cont.)

32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) { // if stack is empty.36 newNode->next = NULL;37 top = newNode;38 } 39 else {40 newNode->next = top;41 top = newNode;42 }43 }

top

newNode

29

Linked-List Push into Non-Empty Stack

32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) { // if stack is empty.36 newNode->next = NULL;37 top = newNode;38 } 39 else { // stack is not empty.40 newNode->next = top;41 top = newNode;42 }43 } newNode

top

30

Linked-List Push into Non-Empty Stack (cont.)

32 void push( const T& element ) {33 Node<T> *newNode = new Node<T>;34 newNode->info = element;35 if (top == NULL) { // if stack is empty.36 newNode->next = NULL;37 top = newNode;38 } 39 else { // stack is not empty.40 newNode->next = top;41 top = newNode;42 }43 }

newNode

top

31

Linked-List Peek

56 bool peek( T& element )57 {58 if ( top == NULL )59 return false;60 element = top->info;61 return true;62 }

32

Linked-List Pop

56 bool pop( T& element )57 {58 if ( top == NULL )59 return false;60 element = top->info;61 Node<T> *ptr = top;62 top = top->next;63 delete ptr;64 return true;65 }

33

Linked-List StackisEmpty and makeEmpty

65 bool isEmpty( ) const66 {67 return top == NULL;68 }6970 void makeEmpty( )71 {72 T temp;73 while ( pop( temp ) );74 }

34

The Queue ADT

• The queue is a data structure that is like a line of people– When people join the line, they go at the end– When people are served, they come off the

front of the line

• Queue is known as a FIFO (last-in, last-out) data structure because the last data to enter the queue is the last to exit from the queue.

35

Queue ADT Operations

• enqueue: add an element to the end of the line

• dequeue: take an element from the front of the line

• peek: retrieve (copy) the element at the front of the line without removing it

• an operation to determine whether or not the queue is empty

• an operation that will empty out the queue

36

Queue (cont.)

• In addition to a pointer at the beginning of the linked list (called front), a pointer to the end of the linked list (called back) is also maintained in the private section

• The back pointer makes it fast to add new elements to the end of the queue – you don’t have to use a loop to go all the way through the queue to find the last node

37

Linked-List Dequeue

front back

Bob Ali

38

Linked-List Dequeue(cont.)

front back

Ali

39

Linked-List Enqueue

front back

40

Linked-List Enqueue(cont.)

front back

41

Linked-List Queue Class Template13 template <typename T>14 class Queue {15 public:16 Queue( );17 ~Queue( );18 void enqueue( const T & element );19 bool dequeue( T & deqElement );20 bool peek( T & frontElement ); 21 bool isEmpty( ) const;22 void makeEmpty( );23 private:24 Node<T> *front;25 Node<T> *back;26 };

42

4 Queue( )5 {6 front = back = NULL;7 }8 9 ~Queue( )10 {11 makeEmpty( );12 }

Linked-List Queue Constructor and Destructor

43

Linked-List Queue Enqueue21 void enqueue( const T & element )22 {

23 Node<T> *newNode = new Node<T>;24 newNode->info = element;25 newNode->next = NULL;28 if (front == NULL) { // list is empty.29 front = back = newNode;30 }31 else { // list is not empty.32 back->next = newNode;33 back = newNode;34 }35 }

newNode

44

Linked-List Queue Enqueue (cont.)22 void enqueue( const T & element )23 {24 Node<T> *newNode = new Node<T>;25 newNode->info = element;26 newNode->next = NULL;

27 if (front == NULL) { // list is empty.28 front = newNode;29 back = front;30 }31 else { // list is not empty.32 back->next = newNode;33 back = newNode;34 }35 }

newNode

Case 1: The queue is initially empty.

front

back

45

Linked-List Queue Enqueue (cont.)22 void enqueue( const T & element )23 {24 Node<T> *newNode = new Node<T>;25 newNode->info = element;26 newNode->next = NULL;27 if (front == NULL) { // list is empty.28 front = newNode;29 back = front;30 }

31 else { // list is not empty.32 back->next = newNode;33 back = newNode;34 }35 }

newNode

Case 2: The queue has nodes.

front

back

46

Linked-List Queue Enqueue (cont.)22 void enqueue( const T & element )23 {24 Node<T> *newNode = new Node<T>;25 newNode->info = element;26 newNode->next = NULL;27 if (front == NULL) { // list is empty.28 front = newNode;29 back = front;30 }31 else { // list is not empty.32 back->next = newNode;

33 back = newNode;34 }35 }

newNode

Case 2: The queue has nodes.

front

back

47

Linked-List Queue Dequeue

41 bool dequeue( T & deqElement )42 {43 if ( front == NULL) 44 return false;

Dequeue continued…

Returns false if client tries to dequeue an empty queue.

48

Linked-List Queue Dequeue (cont.)

45 deqElement = front->info;46 Node<T> *ptr = front;47 front = front->next;48 delete ptr;49 return true;50 }

front backptr

deqElement:

passed in by reference

49



front backptr

deqElement:

50



front backptr

deqElement:

51

Linked-List Queue Peek

56 bool peek( T & frontElement )57 {58 if ( front == NULL)59 return false;60 frontElement = front->info;61 return true;62 }

52

Linked-List Queue isEmpty and makeEmpty

65 bool isEmpty( ) const66 {67 return front == NULL;68 }6970 void makeEmpty( )71 {72 T temp;73 while ( dequeue( temp ) );74 }

53

Array Queue

• Similar to the linked-list queue, there are 2 attributes called front and back, but they are indexes into an array instead of pointers.

• When enqueuing, the back index is incremented, and when dequeuing, the front index is incremented.

54

Array Queue Class Template3 template <typename T>4 class Queue {5 public:6 Queue( ) { … }7 ~Queue( ) { … }8 void enqueue( T element ) { … 9 bool dequeue( T & deqElement ) { … }10 bool peek( T & frontElement ) { … }11 bool isEmpty( ) const { … }12 void makeEmpty( ) { … }13 private:14 T *elements;15 int size16 int front;17 int back;18 };

55

Array Queue Enqueue / Dequeue

0 1 2 3 4 5 6 7

front back

DEQUEUEDEQUEUEENQUEUEENQUEUEDEQUEUEDEQUEUEENQUEUEDEQUEUEDEQUEUEENQUEUE

56

0 1 2 3 4 5 6 7

front back

Array Queue Enqueue / Dequeue (cont.)


57

0 1 2 3 4 5 6 7

front back



58

0 1 2 3 4 5 6 7

front back



59

0 1 2 3 4 5 6 7

front back



60

0 1 2 3 4 5 6 7

front back



61

0 1 2 3 4 5 6 7

front back



62

0 1 2 3 4 5 6 7

front back



63

0 1 2 3 4 5 6 7

front back



64

0 1 2 3 4 5 6 7

front back



65

0 1 2 3 4 5 6 7

front back

We have reached the end of array. How to enqueue? ?



66

0 1 2 3 4 5 6 7

front back


We could double the size of the array here.

But if we keep doing this, we may have a million elements in the array, but only a few at the end are used!


67

0 1 2 3 4 5 6 7

frontback

We handle this problem by having the back wrap around to the beginning of the array.

The front also wraps to the beginning when it reaches the end of the array



68

Is Array Queue Full/Empty?• An array queue is empty when

– front = -1• An array queue has one element when

– front = back• An array queue is full when

– back + 1 = front

69

A Full Array Queue

0 1 2 3 4 5 6 7

frontback

If the next operation is ENQUEUE, the array capacity will need to be doubled

Reference

• Childs, J. S. (2008). Stack and Queue. C++ Classes and Data Structures. Prentice Hall.

70

Lecture08 stacks and-queues_v3

Documents

Transcript of Lecture08 stacks and-queues_v3