Stacks and Queues - PowerPoint PPT Presentation

1 / 77
About This Presentation
Title:

Stacks and Queues

Description:

Chapter 18 Stacks and Queues 18.1 Introduction to the Stack ADT A stack is a data structure that stores and retrieves items in a last-in-first-out (LIFO) manner. – PowerPoint PPT presentation

Number of Views:602
Avg rating:3.0/5.0
Slides: 78
Provided by: tonyg5
Category:

less

Transcript and Presenter's Notes

Title: Stacks and Queues


1
Chapter 18
  • Stacks and Queues

2
18.1 Introduction to the Stack ADT
  • A stack is a data structure that stores and
    retrieves items in a last-in-first-out (LIFO)
    manner.

3
Applications of Stacks
  • Computer systems use stacks during a programs
    execution to store function return addresses,
    local variables, etc.
  • Some calculators use stacks for performing
    mathematical operations.

4
Static and Dynamic Stacks
  • Static Stacks
  • Fixed size
  • Can be implemented with an array
  • Dynamic Stacks
  • Grow in size as needed
  • Can be implemented with a linked list

5
Stack Operations
  • Push
  • causes a value to be stored in (pushed onto) the
    stack
  • Pop
  • retrieves and removes a value from the stack

6
The Push Operation
  • Suppose we have an empty integer stack that is
    capable of holding a maximum of three values.
    With that stack we execute the following push
    operations.
  • push(5)
  • push(10)
  • push(15)

7
The Push Operation
The state of the stack after each of the push
operations
8
The Pop Operation
  • Now, suppose we execute three consecutive pop
    operations on the same stack

9
Other Stack Operations
  • isFull A Boolean operation needed for static
    stacks. Returns true if the stack is full.
    Otherwise, returns false.
  • isEmpty A Boolean operation needed for all
    stacks. Returns true if the stack is empty.
    Otherwise, returns false.

10
The IntStack Class
  • Table 18-1 Member Variables

Member Variable Description   stackArray stackArr
ay A pointer to int. When the constructor is
executed, it uses stackArray to dynamically
allocate an array for storage.   stackSize An
integer that holds the size of the
stack.   top An integer that is used to mark
the top of the stack.
11
The IntStack Class
  • Table 18-2 Member Functions

Member Function Description   stackArray Construc
tor The class constructor accepts an integer
argument, which specifies the size of the
stack. An integer array of this size is
dynamically allocated, and assigned to
stackArray. Also, the variable top
is initialized to 1.push The push
function accepts an integer argument, which is
pushed onto the top of the stack.pop The
pop function uses an integer reference parameter.
The value at the top of the stack is removed,
and copied into the reference parameter.
12
The IntStack Class
  • Table 18-2 Member Functions (continued)

Member Function Description   stackArray isFull
Returns true if the stack is full and false
otherwise. The stack is full when top is equal
to stackSize 1.isEmpty Returns true if the
stack is empty, and false otherwise. The
stack is empty when top is set to 1.
13
Contents of IntStack.h
ifndef INTSTACK_Hdefine INTSTACK_Hclass
IntStackprivate int stackArray int
stackSize int toppublic IntStack(int) voi
d push(int) void pop(int ) bool
isFull(void) bool isEmpty(void) endif
14
Contents of IntStack.cpp
include ltiostream.hgtinclude "intstack.h//
// Constructor
//IntStackIntStack(int
size) stackArray new intsize stackSize
size top -1
15
Contents of IntStack.cpp
//
// Member function push pushes the argument
onto // the stack.
//
void IntStackpush(int num) if
(isFull()) cout ltlt "The stack is
full.\n" else top stackArraytop
num
16
Contents of IntStack.cpp
//
// Member function pop pops the value at the
top // of the stack off, and copies it into
the variable // passed as an argument.
//
void IntStackpop(int
num) if (isEmpty()) cout ltlt "The stack
is empty.\n" else num
stackArraytop top--
17
Contents of IntStack.cpp
//
// Member function isFull returns true if the
stack // is full, or false otherwise.
//
bool IntStackisFull(void) bo
ol status if (top stackSize - 1) status
true else status false return status
18
Contents of IntStack.cpp
//
// Member funciton isEmpty returns true if
the stack // is empty, or false otherwise.
//
bool IntStackisEmpty(void)
bool status if (top -1) status
true else status false return status
19
Program 18-1
// This program demonstrates the IntStack
class.include ltiostream.hgtinclude
"intstack.hvoid main(void) IntStack
stack(5) int catchVar cout ltlt "Pushing
5\n" stack.push(5) cout ltlt "Pushing
10\n" stack.push(10) cout ltlt "Pushing
15\n" stack.push(15) cout ltlt "Pushing
20\n" stack.push(20) cout ltlt "Pushing
25\n" stack.push(25)
20
Program 18-1 (continued)
cout ltlt "Popping...\n" stack.pop(catchVar) co
ut ltlt catchVar ltlt endl stack.pop(catchVar) cou
t ltlt catchVar ltlt endl stack.pop(catchVar) cout
ltlt catchVar ltlt endl stack.pop(catchVar) cout
ltlt catchVar ltlt endl stack.pop(catchVar) cout
ltlt catchVar ltlt endl
21
Program 18-1 (continued)
Program OutputPushing 5Pushing 10Pushing
15Pushing 20Pushing 25Popping...252015105
22
About Program 18-1
  • In the program, the constructor is called with
    the argument 5. This sets up the member variables
    as shown in Figure 18-4. Since top is set to 1,
    the stack is empty

23
About Program 18-1
  • Figure 18-5 shows the state of the member
    variables after the push function is called the
    first time (with 5 as its argument). The top of
    the stack is now at element 0.

24
About Program 18-1
  • Figure 18-6 shows the state of the member
    variables after all five calls to the push
    function. Now the top of the stack is at element
    4, and the stack is full.

25
About Program 18-1
  • Notice that the pop function uses a reference
    parameter, num. The value that is popped off the
    stack is copied into num so it can be used later
    in the program. Figure 18-7 (on the next slide)
    depicts the state of the class members, and the
    num parameter, just after the first value is
    popped off the stack.

26
About Program 18-1
27
Implementing Other Stack Operations
  • The MathStack class (discussed on pages 1072
    1075) demonstrates functions for stack-based
    arithmetic.

28
18.2 Dynamic Stacks
  • A dynamic stack is built on a linked list instead
    of an array.
  • A linked list-based stack offers two advantages
    over an array-based stack.
  • No need to specify the starting size of the
    stack. A dynamic stack simply starts as an empty
    linked list, and then expands by one node each
    time a value is pushed.
  • A dynamic stack will never be full, as long as
    the system has enough free memory.

29
Contents of DynIntStack.h
class DynIntStackprivate struct
StackNode int value StackNode
next StackNode toppublic DynIntStack
(void) top NULL void push(int) void
pop(int ) bool isEmpty(void)
30
Contents of DynIntStack.cpp
include ltiostream.hgtinclude "dynintstack.h//
/
/ Member function push pushes the argument onto
// the stack.
//
void DynIntStackpush(int num) stackNode
newNode // Allocate a new node store
Num newNode new stackNode newNode-gtvalue
num
31
Contents of DynIntStack.cpp
// If there are no nodes in the list // make
newNode the first node if (isEmpty()) top
newNode newNode-gtnext NULL else //
Otherwise, insert NewNode before
top newNode-gtnext top top
newNode //
// Member function pop pops
the value at the top // of the stack off,
and copies it into the variable // passed as an
argument.
//

32
Contents of DynIntStack.cpp
void DynIntStackpop(int num) stackNode
temp if (isEmpty()) cout ltlt "The stack
is empty.\n" else // pop value off top of
stack num top-gtvalue temp
top-gtnext delete top top temp
33
Contents of DynIntStack.cpp
//
// Member funciton isEmpty returns true if
the stack // is empty, or false otherwise.
//
bool DynIntStackisEmpty(v
oid) bool status if (!top) status
true else status false return status
34
Program 18-3
// This program demonstrates the dynamic stack//
class DynIntClass.include ltiostream.hgtinclude
"dynintstack.hvoid main(void) DynIntStack
stack int catchVar cout ltlt "Pushing
5\n" stack.push(5) cout ltlt "Pushing
10\n" stack.push(10) cout ltlt "Pushing
15\n" stack.push(15)
35
Program 18-3 (continued)
cout ltlt "Popping...\n" stack.pop(catchVar) co
ut ltlt catchVar ltlt endl stack.pop(catchVar) cou
t ltlt catchVar ltlt endl stack.pop(catchVar) cout
ltlt catchVar ltlt endl cout ltlt "\nAttempting to
pop again... " stack.pop(catchVar) Program
Output Pushing 5Pushing 10Pushing
15Popping...15105 Attempting to pop
again... The stack is empty.
36
18.3 The STL stack Container
  • The STL stack container may be implemented as a
    vector, a list, or a deque (which you will learn
    about later in this chapter).
  • Because the stack container is used to adapt
    these other containers, it is often referred to
    as a container adapter.

37
18.3 The STL stack Container
  • Here are examples of how to declare a stack of
    ints, implemented as a vector, a list, and a
    deque.
  •  stacklt int, vectorltintgt gt iStack // Vector
    stackstacklt int, listltintgt gt iStack // List
    stack stacklt int gt iStack // Default deque
    stack

38
18.3 The STL stack Container
  • Table 18-3 (pages 1080-1081) lists and describes
    many of the stack containers member functions.

39
Program 18-4
// This program demonstrates the STL stack//
container adapter.include ltiostream.hgtinclude
ltvectorgtinclude ltstackgtusing namespace
stdvoid main(void) int x stacklt int,
vectorltintgt gt iStack for (x 2 x lt 8 x
2) cout ltlt "Pushing " ltlt x ltlt
endl iStack.push(x)
40
Program 18-4 (continued)
cout ltlt "The size of the stack is " cout ltlt
iStack.size() ltlt endl for (x 2 x lt 8 x
2) cout ltlt "Popping " ltlt iStack.top() ltlt
endl iStack.pop() Program
Output Pushing 2Pushing 4Pushing 6The size
of the stack is 3Popping 6Popping 4Popping 2
41
18.4 Introduction to the Queue ADT
  • Like a stack, a queue (pronounced "cue") is a
    data structure that holds a sequence of elements.
  • A queue, however, provides access to its elements
    in first-in, first-out (FIFO) order.
  • The elements in a queue are processed like
    customers standing in a grocery check-out line
    the first customer in line is the first one
    served.

42
Example Applications of Queues
  • In a multi-user system, a queue is used to hold
    print jobs submitted by users , while the printer
    services those jobs one at a time.
  • Communications software also uses queues to hold
    information received over networks and dial-up
    connections. Sometimes information is transmitted
    to a system faster than it can be processed, so
    it is placed in a queue when it is received.

43
Static and Dynamic Queues
  • Just as stacks are implemented as arrays or
    linked lists, so are queues.
  • Dynamic queues offer the same advantages over
    static queues that dynamic stacks offer over
    static stacks.

44
Queue Operations
  • Think of queues as having a front and a rear.
    This is illustrated in Figure 18-8.

45
Queue Operations
  • The two primary queue operations are enqueuing
    and dequeuing.
  • To enqueue means to insert an element at te rear
    of a queue.
  • To dequeue means to remove an element from the
    front of a queue.

46
Queue Operations
  • Suppose we have an empty static integer queue
    that is capable of holding a maximum of three
    values. With that queue we execute the following
    enqueue operations. 
  • Enqueue(3)
  • Enqueue(6)
  • Enqueue(9)

47
Queue Operations
  • Figure 18-9 illustrates the state of the queue
    after each of the enqueue operations.

48
Queue Operations
  • Now let's see how dequeue operations are
    performed. Figure 18-10 illustrates the state of
    the queue after each of three consecutive dequeue
    operations

49
Queue Operations
  • When the last deqeue operation is performed in
    the illustration, the queue is empty. An empty
    queue can be signified by setting both front and
    rear indices to 1.
  • Pages 1084-1085 discuss the inefficiency of this
    algorithm, and its solution implement the queue
    as a circular array.

50
Contents of IntQueue.h
class IntQueueprivate int queueArray int
queueSize int front int rear int
numItemspublic IntQueue(int)
IntQueue(void) void enqueue(int) void
dequeue(int ) bool isEmpty(void) bool
isFull(void) void clear(void)
51
Contents of IntQueue.cpp
include ltiostream.hgtinclude "IntQueue.h//
// Constructor
// IntQueueIntQueue(
int s) queueArray new ints queueSize
s front 0 rear 0 numItems 0
52
Contents of IntQueue.cpp
//// Destructor
//IntQueueIntQ
ueue(void) delete queueArray
53
Contents of IntQueue.cpp
////
Function enqueue inserts the value in num // at
the rear of the queue.
//
void IntQueueenqueue(int num) if
(isFull()) cout ltlt "The queue is
full.\n" else // Calculate the new rear
position rear (rear 1) queueSize //
Insert new item queueArrayrear num //
Update item count numItems
54
Contents of IntQueue.cpp
////
Function dequeue removes the value at the //
front of the queue, and copies t into num.
//
void IntQueuedequeue(int num) if
(isEmpty()) cout ltlt "The queue is
empty.\n" else // Move front front
(front 1) queueSize // Retrieve the front
item num queueArrayfront // Update item
count numItems--
55
Contents of IntQueue.cpp
////
Function isEmpty returns true if the queue //
is empty, and false otherwise.
//
bool IntQueueisEmpty(void) bool
status if (numItems) status
false else status true return status
56
Contents of IntQueue.cpp
////
Function isFull returns true if the queue // is
full, and false otherwise.
//
bool IntQueueisFull(void) bool status if
(numItems lt queueSize) status
false else status true return status
57
Contents of IntQueue.cpp
////
Function clear resets the front and rear //
indices, and sets numItems to 0.
//v
oid IntQueueclear(void) front queueSize -
1 rear queueSize - 1 numItems 0
58
Program 18-5
// This program demonstrates the IntQeue
classinclude ltiostream.hgtinclude
"intqueue.hvoid main(void) IntQueue
iQueue(5) cout ltlt "Enqueuing 5
items...\n" // Enqueue 5 items. for (int x
0 x lt 5 x) iQueue.enqueue(x) // Attempt
to enqueue a 6th item. cout ltlt "Now attempting
to enqueue again...\n" iQueue.enqueue(5)
59
Program 18-5 (continued)
// Deqeue and retrieve all items in the
queue cout ltlt "The values in the queue
were\n" while (!iQueue.isEmpty()) int
value iQueue.dequeue(value) cout ltlt value
ltlt endl Program Output Enqueuing 5
items...Now attempting to enqueue again...The
queue is full.The values in the queue were0
60
18.5 Dynamic Queues
  • A dynamic queue starts as an empty linked list.
  • With the first enqueue operation, a node is
    added, which is pointed to by front and rear
    pointers.
  • As each new item is added to the queue, a new
    node is added to the rear of the list, and the
    rear pointer is updated to point to the new node.
  • As each item is dequeued, the node pointed to by
    the front pointer is deleted, and front is made
    to point to the next node in the list.

61
Dynamic Queues
  • Figure 18-14 shows the structure of a dynamic
    queue.

62
Contents of DynIntQueue.h
class DynIntQueueprivate struct
QueueNode int value QueueNode
next QueueNode front QueueNode
rear int numItems public DynIntQueue(void)
DynIntQueue(void) void enqueue(int)
void dequeue(int ) bool isEmpty(void)
void clear(void)
63
Contents of DynIntQueue.cpp
include ltiostream.hgtinclude "dynintqueue.h//
// Constructor
//DynIntQueueDynIntQ
ueue(void) front NULL rear
NULL numItems 0//
// Destructor //
DynIntQueueDynIntQueue(void) clear()

64
Contents of DynIntQueue.cpp
////
Function enqueue inserts the value in num // at
the rear of the queue.
//
void DynIntQueueenqueue(int num) QueueNode
newNode newNode new QueueNode newNode-gtval
ue num newNode-gtnext NULL if
(isEmpty()) front newNode rear
newNode else rear-gtnext
newNode rear newNode numItems
65
Contents of DynIntQueue.cpp
///
/ Function dequeue removes the value at the
// front of the queue, and copies it into num.
//
void DynIntQueuedequeue(int
num) QueueNode temp if (isEmpty()) cout
ltlt "The queue is empty.\n" else num
front-gtvalue temp front-gtnext delete
front front temp numItems--
66
Contents of DynIntQueue.cpp
////
Function isEmpty returns true if the queue //
is empty, and false otherwise.
//
bool DynIntQueueisEmpty(void) bool
status if (numItems) status
false else status true return status
67
Contents of DynIntQueue.cpp
////
Function clear dequeues all the elements // in
the queue.
//
void DynIntQueueclear(void) int value //
Dummy variable for dequeue while(!isEmpty()) d
equeue(value)
68
Program 18-6
// This program demonstrates the DynIntQeue
classinclude ltiostream.hgtinclude
"dynintqueue.hvoid main(void) DynIntQueue
iQueue cout ltlt "Enqueuing 5 items...\n" //
Enqueue 5 items. for (int x 0 x lt 5
x) iQueue.enqueue(x) // Deqeue and
retrieve all items in the queue cout ltlt "The
values in the queue were\n" while
(!iQueue.isEmpty()) int value iQueue.deque
ue(value) cout ltlt value ltlt endl
69
Program 18-6 (continued)
Program Ouput Enqueuing 5 items...The values in
the queue were01234
70
The STL deque and queue Containers
  • A deque (pronounced "deck" or "deek") is a
    double-ended queue. It similar to a vector, but
    allows efficient access to values at both the
    front and the rear.
  • The queue ADT is like the the stack ADT it is
    actually a container adapter.

71
The deque Container
  • Programs that use the deque ADT must include the
    deque header file.
  • The push_back, pop_front, and front member
    functions are described in Table 18-4 (page 1094).

72
Program 18-7
// This program demonstrates the STL deque//
container.include ltiostream.hgtinclude
ltdequegtusing namespace stdvoid
main(void) int x dequeltintgt iDeque cout
ltlt "I will now enqueue items...\n" for (x 2
x lt 8 x 2) cout ltlt "Pushing " ltlt x ltlt
endl iDeque.push_back(x) cout ltlt "I will
now dequeue items...\n" for (x 2 x lt 8 x
2) cout ltlt "Popping " ltlt iDeque.front() ltlt
endl iDeque.pop_front()
73
Program 18-7 (continued)
Program Output   I will now enqueue
items... Pushing 2 Pushing 4 Pushing 6 I will now
dequeue items... Popping 2 Popping 4 Popping 6  
74
The queue Container Adapter
  • The queue container adapter can be built upon
    vectors, lists, or deques.
  • By default, it uses deque as its base.

75
The queue Container Adapter
  • The queue insertion and removal operations are
    the same as those supported by the stack ADT
    push, pop, and top.
  • The queue version of push always inserts an
    element at the rear of the queue.
  • The queue version of pop always removes an
    element from the structure's front.
  • The top function returns the value of the element
    at the front of the queue.

76
Program 18-8
// This program demonstrates the STL queue//
container adapter.include ltiostream.hgtinclude
ltqueuegtusing namespace stdvoid
main(void) int x queueltintgt iQueue cout
ltlt "I will now enqueue items...\n" for (x 2
x lt 8 x 2) cout ltlt "Pushing " ltlt x ltlt
endl iQueue.push(x) cout ltlt "I will now
dequeue items...\n" for (x 2 x lt 8 x
2) cout ltlt "Popping " ltlt iQueue.front() ltlt
endl iQueue.pop()
77
Program 18-8 (continued)
Program Output I will now enqueue
items... Pushing 2 Pushing 4 Pushing 6 I will now
dequeue items... Popping 2 Popping 4 Popping 6
Write a Comment
User Comments (0)
About PowerShow.com