1 Data Structures and Algorithms Stacks and Queues

Data Structures and Algorithms

Stacks and Queues

Guidelines for Selecting ADT Operations

• Completeness -- Every ADT must be complete. It must include enough operations, including ADT-constructors, to build every possible value of the domain.

• Testability -- The preconditions of all ADT operations must be testable. The ADT must provide enough test operations for the client to check all

preconditions of the ADT operations.

Types of ADT Operations to Include

• ADT-Constructors -- to build values of the type

• Test Operations -- to test some condition about an ADT value

• I/O Operations -- to input or output an ADT value

• Copy Operations -- to copy one ADT value to another ADT object

• Selector Operations (Access Functions) -- to retrieve a portion of an ADT value

• Destructor Operations -- to deallocate any dynamic data created by an ADT

Definition of ADT Stack

• A stack is a linear data structure with homogeneous components (elements), in which all insertions and deletions occur at one end, called the top of the stack.

• A stack is a LIFO “Last In, First Out” structure.

StackType ADT Operations

• StackType -- (Constructor) Creates an empty stack.

• IsEmpty -- Determines whether the stack is currently

empty.

• IsFull -- Determines whether the stack is currently full.

• Push (ItemType newItem) -- Adds newItem to the top of the stack.

• Pop -- Removes the item at the top of the stack.

• Top -- Returns a copy of item currently at top of stack.

ADT Stack Operations

Transformers – StackType – Push– Pop

Observers – IsEmpty

– IsFull– Top

change state

observe state

Vector Implementation of Stack

StackType class

StackType

IsEmpty

IsFull

Private data:

[MAX_ITEMS-1] . . .

items [ 0 ]

Stack of int items

[MAX_ITEMS-1] . . .

[ 3 ] 789

[ 2 ] -56

[ 1 ] 132

items [ 0 ] 5670

[MAX_ITEMS-1] . . .

[ 3 ] 3456.8

[ 2 ] -90.98

[ 1 ] 98.6

items [ 0 ] 167.87

Stack of float items

[MAX_ITEMS-1] . . .

[ 3 ] Bradley

[ 2 ] Asad

[ 1 ] Rodrigo

items [ 0 ] Max

Stack of string items

//----------------------------------------------------------

// SPECIFICATION FILE (bstack.h)

//----------------------------------------------------------

#include "bool.h"

#include "ItemType.h" // for MAX_ITEMS and

// class ItemType definition

class StackType {

public:

StackType( );

// Default constructor.

// POST: Stack is created and empty.

Boolean IsEmpty( ) const;

// PRE: Stack has been initialized.

// POST: FCTVAL == (stack is empty)

Boolean IsFull( ) const;

// POST: FCTVAL == (stack is full)

// SPECIFICATION FILE continued (bstack.h)

void Push( ItemType newItem );

// PRE: Stack has been initialized and is not full.

// Assigned (newItem).

// POST: newItem is at the top of the stack.

void Pop( );

// PRE: Stack has been initialized and is not empty.

// POST: Top element has been removed from stack.

ItemType Top( ) const;

// PRE: Stack has been initialized and is not empty.

// POST: FCTVAL == copy of item at top of stack.

private:

int top; // subscript of current top item

ItemType items[MAX_ITEMS]; // array of ItemType

char letter = ‘V’;StackType charStack;

charStack.Push(letter);

charStack.Push(‘C’);

charStack.Push(‘S’);

if ( !charStack.IsEmpty( )) {

letter = charStack.Top( );

charStack.Pop( );}

charStack.Push(‘K’);

Tracing Client Codeletter ‘V’

charStack.Pop( );}

Private data:

top -1

[MAX_ITEMS-1] . . .

items [ 0 ]

charStack.Pop( );}

Private data:

[MAX_ITEMS-1] . . .

items [ 0 ] ‘V’

charStack.Pop( );}

Private data:

[MAX_ITEMS-1] . . .

[ 1 ] ‘C’

items [ 0 ] ‘V’

charStack.Pop( );}

Private data:

[MAX_ITEMS-1] . . .

[ 2 ] ‘S’

[ 1 ] ‘C’

items [ 0 ] ‘V’

charStack.Pop( );}

Private data:

[MAX_ITEMS-1] . . .

[ 2 ] ‘S’

[ 1 ] ‘C’

items [ 0 ] ‘V’

charStack.Pop( );}

Tracing Client Codeletter ‘S’

Private data:

[MAX_ITEMS-1] . . .

[ 2 ] ‘S’

[ 1 ] ‘C’

items [ 0 ] ‘V’

charStack.Pop( );}

Private data:

[MAX_ITEMS-1] . . .

[ 2 ] ‘S’

[ 1 ] ‘C’

items [ 0 ] ‘V’

charStack.Pop( );}

letter ‘S’

Private data:

[MAX_ITEMS-1] . . .

[ 2 ] ‘K’

[ 1 ] ‘C’

items [ 0 ] ‘V’

End of Trace

//-------------------------------------------------------// IMPLEMENTATION FILE (bstack.cpp)//------------------------------------------------------// Private data members of class:// int top;// ItemType items[MAX_ITEMS];//-------------------------------------------------------#include “bool.h”#include “ItemType.h”

StackType::StackType( )

//------------------------------------------------// Default Constructor

//------------------------------------------------{

top = -1;}

// IMPLEMENTATION FILE continued (bstack.cpp)

//----------------------------------------------------------

Boolean StackType::IsEmpty( ) const

//---------------------------------------------------

// POST: FCTVAL == (stack is empty)

//---------------------------------------------------

return ( top == -1 );

Boolean StackType::IsFull( ) const

//---------------------------------------------------

// POST: FCTVAL == (stack is full)

//---------------------------------------------------

return ( top == MAX_ITEMS-1 );

//----------------------------------------------------------

void StackType::Push ( ItemType newItem )

//---------------------------------------------------

// PRE: Stack has been initialized and is not full.

//---------------------------------------------------

top++;

items[top] = newItem;

//----------------------------------------------------------

ItemType StackType::Top( ) const

//---------------------------------------------------

// PRE: Stack has been initialized && top >= 0.

// POST: FCTVAL == copy of item at top of stack.

//---------------------------------------------------

return items[top];

//----------------------------------------------------------

void StackType::Pop ( )

//---------------------------------------------------

// PRE: Stack has been initialized && top >= 0.

//---------------------------------------------------

top--;

Another Stack Implementation

• One advantage of an ADT is that the kind of implementation used can be changed.

• The array implementation of the stack has a weakness -- the maximum size of the stack is fixed at compile time.

• Instead we can dynamically allocate the space for each stack element as it is pushed onto the stack.

class StackType

StackType

IsFull

IsEmpty Private data:

topPtrcat dog

~StackType

char letter = ‘V’;

StackType< char > myStack;

myStack.Push(letter);

myStack.Push(‘C’);

myStack.Push(‘S’);

if ( !myStack.IsEmpty( ) ) {

letter = myStack.Top( ); myStack.Pop( );}myStack.Push(‘K’);

Private data:

topPtr NULL

Tracing Client Codeletter

‘V’

Private data:

topPtr

‘C’ ‘V’

‘V’

Private data:

topPtr

‘S’ ‘C’ ‘V’

‘V’

Private data:

topPtr

‘S’ ‘C’ ‘V’

Private data:

topPtr

Private data:

topPtr ‘S’ ‘C’ ‘V’

‘C’ ‘V’

‘S’

Private data:

topPtr

‘K’ ‘C’ ‘V’

‘S’

Private data:

topPtr

// SPECIFICATION OF STACK (ustack.h)

#include "bool.h"#include "ItemType.h" // for ItemType

struct NodeType {ItemType info;NodeType* next;

Dynamically Linked Stack

. info . next

‘A’ 6000

Pointer Dereferencing and Member Selection

. info . next

‘A’ 6000 ptr

. info . next

‘A’ 6000

. info . next

(*ptr).info

ptr->info

‘A’ 6000

// SPECIFICATION OF STACK continued (ustack.cpp)

class StackType {public:

StackType( ); // constructor// Default constructor.// POST: Stack is created and empty.

Boolean IsEmpty( ) const;// PRE: Stack has been initialized.// POST: FCTVAL == (stack is empty)

Boolean IsFull( ) const;// PRE: Stack has been initialized.// POST: FCTVAL == (stack is full)

StackType(const StackType& otherStk ); // Copy-constructor// POST: Created stack as deep copy of

otherStk

// SPECIFICATION OF STACK continued (ustack.cpp)

void Push( ItemType item );

// PRE: Stack initialized && Stack is not full.

void Pop( );

// PRE: Stack initialized && Stack is not empty.

ItemType Top( ) const;

// PRE: Stack initialized && Stack is not empty.

// POST: FCTVAL == copy of item currently at top.~StackType( ); // destructor

// POST: Memory allocated for nodes has been

// deallocated.

private:

NodeType char* topPtr ;

// DYNAMIC LINKED IMPLEMENTATION OF STACK (ustack.cpp)

// member function definitions for class StackType

StackType::StackType( ) // constructor{

topPtr = NULL;}

void StackType::IsEmpty( ) const// Returns true if there are no elements // on the stack; false otherwise

{return ( topPtr == NULL );

Using operator new

If memory is available in an area called the free store (or heap), operator new allocates the requested object, and returns a pointer to the memory allocated.

The dynamically allocated object exists until the delete operator destroys it.

Adding newItem to the stack

newItem = ‘B’;NodeType* location;location = new NodeType;location->info = newItem;location->next = topPtr;topPtr = location;

topPtr ‘X’ ‘C’ ‘L’

‘B’newItem

location

‘B’newItem

location

‘B’newItem

location ‘B’

‘B’newItem

location ‘B’

‘B’newItem

location ‘B’

void StackType::Push ( ItemType newItem )

// Adds newItem to the top of the stack.

NodeType* location;

location = new NodeType;

location->info = newItem;

location->next = topPtr;

topPtr = location;

Implementing Push

The object currently pointed to by the pointer is deallocated, and the pointer is considered unassigned. The memory is returned to the free store.

Using operator delete

Deleting item from the stack

NodeType* tempPtr;

item = topPtr->info;tempPtr = topPtr;topPtr = topPtr->next;delete tempPtr;

topPtr

‘B’ ‘X’ ‘C’ ‘L’

tempPtr

NodeType* tempPtr;

topPtr

‘B’ ‘X’ ‘C’ ‘L’

tempPtr

‘B’

NodeType* tempPtr;

topPtr

‘B’ ‘X’ ‘C’ ‘L’

tempPtr

‘B’

NodeType* tempPtr;

topPtr

‘B’ ‘X’ ‘C’ ‘L’

tempPtr

‘B’

NodeType* tempPtr;

topPtr

‘X’ ‘C’ ‘L’

tempPtr

‘B’

void StackType::Pop ( )

// Removes element at the top of the stack.

NodeType* tempPtr;

tempPtr = topPtr;

topPtr = topPtr->next;

delete tempPtr;

void StackType::Top ( ) const

// FCTVAL == copy of element at the top of stack.

return topPtr->info;

Boolean StackType::IsFull( ) const

// Returns true if there is no room for

// another NodeType node on the free store;

// false otherwise.

location = new NodeType<ItemType>;

if ( location == NULL )

return true;

delete location;

return false;

Why is a destructor needed?

When a local stack variable goes out of scope, the memory space for data member topPtr is deallocated. But the nodes that topPtr points to are not automatically deallocated.

A class destructor is used to deallocate the dynamic memory pointed to by the data member.

StackType::~StackType( ) // destructor

// Post: Stack is empty; all elements deallocated.

NodeType* tempPtr;;

while ( topPtr != NULL )

tempPtr = topPtr;

topPtr = topPtr->next;

delete tempPtr;

class StackType

StackType

IsFull

topPtr

~StackType

What happens . . .

• When a function is called that uses pass by value for a

class object like our dynamically linked stack?

StackType

MakeEmpty

IsFull

topPtr

~StackType

void MyFunction( StackType SomeStack ) // FUNCTION CODE

// Uses pass by value{

Passing a class object by value

Pass by value makes a shallow copy

StackType MyStack; // CLIENT CODE . . .

MyFunction( MyStack ); // function call

Private data:

topPtr 7000

MyStack SomeStack

shallow copy

Private data: 7000 6000

topPtr 7000

Shallow Copy vs. Deep Copy

• A shallow copy copies only the class data members, and does not make a copy of any pointed-to data.

• A deep copy copies not only the class data members, but also makes separately stored copies of any pointed-to data.

What’s the difference?

• A shallow copy shares the pointed to data with the original class object.

• A deep copy stores its own copy of the pointed to data at different locations than the data in the original class object.

Making a deep copy

topPtr 7000SomeStack

topPtr 5000

MyStack

deep copy

// FUNCTION CODE

void MyFunction( StackType SomeStack )

// Uses pass by value

SomeStack.Pop( ); .

WHAT HAPPENS IN THE SHALLOW COPY SCENARIO?

Suppose MyFunction Uses Pop

MyStack.topPtr is left dangling

StackType<int> MyStack; // CLIENT CODE . . .

MyFunction( MyStack );

Private data:

topPtr 6000

MyStack SomeStack

shallow copy

topPtr 7000

MyStack.topPtr is left dangling

Private data:

topPtr 6000

MyStack SomeStack

shallow copy

topPtr 7000

As a result . . .

• This default method used for pass by value is not the best way when a data member pointer points to dynamic data.

• Instead, you should write what is called a copy constructor, which makes a deep copy of the dynamic data in a different memory location.

More about copy constructors

• When there is a copy constructor provided for a class, the copy constructor is used to make copies for pass by value.

• You do not call the copy constructor.

• Like other constructors, it has no return type.

• Because the copy constructor properly defines pass by value for your class, it must use pass by reference in its definition.

Copy Constructor

• Copy constructor is a special member function of a class that is implicitly called in these 3 situations:

– passing object parameters by value,

– initializing an object variable in its declaration,

– returning an object as the return value of a function.

// DYNAMIC LINKED IMPLEMENTATION OF STACK

StackType( ); // Default constructor.// POST: Stack is created and empty.

StackType( const StackType& otherStk );// Copy constructor.// POST: this Stack is a deep copy of otherStk// Is implicitly called for pass by value.

~StackType( ); // Destructor.// POST: Memory for nodes has been deallocated.

private:NodeType* topPtr ;

CONSTRUCTOR

COPY CONSTRUCTOR

DESTRUCTOR

Classes with Data Member Pointers Need

// COPY CONSTRUCTORStackType::StackType( const StackType& otherStk ){ NodeType* fromPtr ; // traverses otherStk nodes

NodeType* toPtr ; // traverses this Stack nodesif (otherStk.topPtr == NULL )

topPtr = NULL ;else // allocate memory to copy first node{ topPtr = new NodeType;

topPtr->info = otherStk.topPtr->info ;fromPtr = otherStk.topPtr->next ;toPtr = topPtr ;while ( fromPtr != NULL ) // deep copy other

nodes{ toPtr->next = new NodeType;

toPtr = toPtr->next ;toPtr->info = fromPtr->info ;fromPtr = fromPtr->next ;

toPtr->next = NULL ;}

What about the assignment operator?

• The default method used for assignment of class objects makes a shallow copy.

• If your class has a data member pointer to dynamic data, you should write a member function to overload the assignment operator to make a deep copy of the dynamic data.

StackType( ); // Default constructor.

StackType( const StackType& otherStk );// Copy constructor.

void operator= ( StackType otherStk);// Overloads assignment operator.

~StackType( ); // Destructor.

private:NodeType* topPtr ;

void StackType::operator= ( StackType otherStk )

// Overloads assignment operator// to create a deep copy of otherStk.

Overloading the assignment operator

C++ Operator Overloading Guides

1 All operators except :: . sizeof ?: may be overloaded.

2 At least one operand must be a class instance.

3 You cannot change precedence, operator symbols, or number of operands.

4 Overloading ++ and -- requires prefix form use by default, unless special mechanism is used.

5 To overload these operators = ( ) [ ] member functions (not friend functions) must be used.

6 An operator can be given multiple meanings if the data types of operands differ for different meanings.

Using overloaded binary operator=

After defining member function operator=

myStack = yourStack;

Is translated by compiler into function call

myStack.operator=(yourStack);

Using overloaded binary operator+

When a Member Function was defined

myStack + yourStack

myStack.operator+(yourStack)

When a Friend Function was defined

myStack + yourStack

operator+(myStack, yourStack)

What is ADT Queue?

• A queue is a linear data structure with homogeneous components (elements), in which all insertions occur at the rear, and all deletions occur at the front.

• A queue is a FIFO “First In, First Out” structure.

Queue ADT Operations

• QueueType -- (Constructor) Creates an empty queue.

• IsEmpty -- Determines whether queue is currently empty.

• IsFull -- Determines whether queue is currently full.

• Enqueue (ItemType newItem) -- Adds newItem to the rear of queue.

• Dequeue -- Removes the item at the front of queue.

• Front -- Returns a copy of item at the front of queue.

ADT Queue Operations

Transformers – QueueType– Enqueue– Dequeue

Observers – IsEmpty

– IsFull– Front

change state

observe state

class QueueType

QueueType

~QueueType

Enqueue

Dequeue . . .

Private Data:

‘C’ ‘Z’ ‘T’

// SPECIFICATION OF QUEUE (uqueue.cpp)

#include "ItemType.h" // for ItemType

class QueueType {

public:

QueueType( ); // CONSTRUCTOR

~QueueType( ) ; // DESTRUCTORBoolean IsEmpty( ) const;

Boolean IsFull( ) const;

void Enqueue( ItemType item );

void Dequeue( );

ItemType Front( ) const;

QueueType( const QueueType& otherQue );

// COPY-CONSTRUCTOR

private:

NodeType* front;

NodeType* rear;

// DYNAMIC LINKED IMPLEMENTATION OF QUEUE (uqueue.cpp)

// member function definitions for class QueueType

QueueType::QueueType( ) // CONSTRUCTOR{

front = NULL;rear = NULL;

Boolean QueueType::IsEmpty( ) const{

return ( front == NULL )}

void QueueType::Enqueue( ItemType newItem )

// Adds newItem to the rear of the queue.

// Pre: Queue has been initialized.

// Queue is not full.

// Post: newItem is at rear of queue.

NodeType* ptr;

ptr = new NodeType;

ptr->info = newItem;

ptr->next = NULL;

if ( rear == NULL )

front = ptr;

rear->next = ptr;

rear = ptr;

void QueueType::Dequeue( )

// Removes element from from front of queue

// Pre: Queue has been initialized.

// Queue is not empty.

// Post: Front element has been removed from queue.

NodeType* tempPtr;

tempPtr = front;

front = front->next;

if ( front == NULL )

rear = NULL;

delete tempPtr;

1 Data Structures and Algorithms Stacks and Queues

Documents

ch20.Lists,Stacks,Queues and Priority Queuesstornar/courses/notes/cs150/ch20.Lists,Stacks,Queues... · Chapter 22 Lists, Stacks, Queues and Priority Queues 1. 2 22.1 Introduction

Chapter 4: Stacks and Queues. Objectives Looking ahead – in this chapter, we’ll consider Stacks Queues Priority Queues Stacks in the Standard Template

Stacks & Queues

Implementing Stacks & Queues

Stacks Queues Deques

Stacks & Queues - VNUvietanh/courses/cs3329/3_Stack-Queues.pdf · Stacks & Queues Acknowledgement: These slides are adapted from slides provided with Data Structures and Algorithms

STACKS AND QUEUES 1. Outline 2 Stacks Queues

1 Algorithms Queues, Stacks and Records stored in Linked Lists or Arrays

stackS & QUEUES

Lec10 Stacks&Queues

Stacks, Queues, Deques

Stacks and queues

Stacks, Queues & Recursion

Data Structures and Algorithms 3 · PDF file2 目录页 Ming Zhang “Data Structures and Algorithms” 》 Chapter 3 Stacks and Queues •Stacks •Applications of stacks – Implementation

Queues, Stacks, Graph Traversing - Computing Science · Graph Traversing: DFS ... Algorithms – Queues, Stacks, Graph Traversing 9-21 Doubly Linked Lists To run, say, ... A doubly

02 Stacks Queues

Stacks Queues Trees

Ch4.Stacks Queues

C-Stacks & Queues

91.102 - Computing II Abstract Data Types: Queues and Stacks. Implementation: Queues and Stacks. Applications of Queues and Stacks. The order in which