Stacks

A stack is a data structure that holds a sequence of elements and stores and retrieves items in a last-in first-out manner (LIFO).

This means that when a program retrieves an item from a stack, the last item inserted into the stack is the first one retrieved.

Similarly, the first item inserted is the last one retrieved (FILO).

Stack ADT

first plate in, last plate out

Last plate in, first plate out

2345

1

Stack of Plates

The stack is a common data structure for representing things that need to maintained in a particular order. For instance, when a function calls another function, which in turn calls a third function, it's important that the third function return back to the second function rather than the first.

Stack ADT

There are two kinds of stack data structure -

a) static, i.e. they have a fixed size, and are implemented as arrays.

b) dynamic, i.e. they grow in size as needed, and implemented as linked lists.

Static and Dynamic Stacks

A stack has two primary operations, called push and pop.

a) The push operation causes a value to be stored (pushed) onto the stack.

e.g. if we have an empty integer stack with maximum capacity of3 items, we can perform the following 3 push operations -

push(5);push(10);push(15);

push() and pop()

The pop operation retrieves (removes) an item from the stack.

If we execute 3 consecutive pop operations on the stack as shown above, we get the following results -

push() and pop()

Exceptions

Attempting the execution of an operation of an ADT may sometimes cause an error condition, called an exception. Exceptions are said to be “thrown” by an operation that cannot be executed.

In the Stack ADT, operation pop cannot be performed if the stack is empty

In the Stack ADT, operation push cannot be performed if the stack is full

Attempting the execution of pop on an empty stack, or a push on a full stack, throws an EmptyStackException

Stack Operations

Therefore, in order to simulate a stack functionality, the following operations need to be implemented.

– Main stack operations: push(object o): inserts element o pop(): removes and returns the last inserted element

– Auxiliary stack operations: top(): returns a reference to the last inserted element

without removing it size(): returns the number of elements stored isEmpty(): returns a Boolean value indicating whether no

elements are stored

Applications of Stacks

Direct applications– Page-visited history in a Web browser– Undo sequence in a text editor– Saving local variables when one function calls

another, and this one calls another, and so on.

Indirect applications– Auxiliary data structure for algorithms– Component of other data structures

C++ Run-time Stack

The C++ run-time system keeps track of the chain of active functions with a stack

When a function is called, the run-time system pushes on the stack a frame containing

– Local variables and return value– Program counter, keeping track of

the statement being executed When a function returns, its frame is

popped from the stack and control is passed to the method on top of the stack

main() {int i = 5;foo(i);}

foo(int j) {int k;k = j+1;bar(k);}

bar(int m) {…}

bar PC = 1 m = 6

foo PC = 3 j = 5 k = 6

main PC = 2 i = 5

Array-based Stack

A simple way of implementing the Stack ADT uses an array

We add elements from left to right

A variable keeps track of the index of the top element

S0 1 2 t

…

Algorithm size()return t + 1

Algorithm pop()if isEmpty() then

throw EmptyStackException else

t t 1return S[t + 1]

Array-based Stack (cont.)

The array storing the stack elements may become full

A push operation will then throw a FullStackException

– Limitation of the array-based implementation

– Not intrinsic to the Stack ADT

S0 1 2 t

…

Algorithm push(o)if t = S.length 1 then

throw FullStackException else

t t + 1S[t] o

Performance and Limitations

Performance– Let n be the number of elements in the stack– The space used is O(n)– Each operation runs in time O(1)

Limitations– The maximum size of the stack must be defined a priori ,

and cannot be changed– Trying to push a new element into a full stack causes an

implementation-specific exception

Writing a program that uses an STL stack

Using a Stack in a Program

Requirement– Reverse a phrase that is input by the user

Steps in the process of creating the program1. Write a test

2. Write an algorithm

3. Write the program

4. Test the program Run an automated test – one way to test your

program

1. Write a Test

Reverse "Go dog"

Reverse "Madam, I’m Adam"

2. Write an Algorithm

//ALGORITHM main()

// Get the string s1

// Reverse the string

// Print the reversed string

2. Write an Algorithm

//ALGORITHM main()

// Get the string s1

// Use a stack to reverse the string

// reverseString(s1)

// Print the reversed string

2. Write an Algorithm

ALGORITHM reverseString(s1)Input: a stringOutput: the string reversed

2. Write an Algorithm

ALGORITHM reverseString(s1)Input: a stringOutput: the string reversed

string s2stack stfor i = 0 to i = s1.length - 1

st.push(s1[i])while not st.empty()

s2 += st.top()st.pop()

return s2

Implementing a Data Structureas a Class

A Stack Example

Stack ADT

int size()Return the number of elements in the stack

bool isEmpty()Indicate whether the stack is empty

void push( Object element )Insert element at the top of the stack

Object top()Return the top element on the stack without removing it; an error occurs if the stack is empty.

Object pop()Remove and return the top element on the stack; an error occurs if the stack is empty

To begin…

Open a header file and name it “ArrayStack.h”

Write the keyword “class” followed by the name of the class

class ArrayStack {

};

Add the curly braces, and remember the semicolon

Step 1 – Declare Public Operations

Declare member functions for all the public operations that are called for by the ADT(See p. 157 for the stack ADT.)

class ArrayStack {

public:

int size();

bool isEmpty();

void push( const char& c );

char& top();

void pop();

};

Access specifier All member functions after “public:” are accessible by any client in your program wherever there is an object of this class.

Step 2 – Declare Data Members

Next, decide how to hold the data that the data structure will contain. For example, you could put it into either an array or a linked list.

class ArrayStack {

private:

int capacity;//Maximum capacity of the array

char *pMyArray;//Pointer to an array

public:

int size();

bool isEmpty();

void push(const char& c);

char& top();

void pop();

};

Access specifier

All members after “private:” are only accessible to the member functions of this class.

Information hiding

Data members are always “private” so that the object’s client cannot change the data by accessing it directly.

Data can be accessed only by using the “public” member functions.

Step 3 – Define the Operations

Now, decide how to implement the operations

class ArrayStack {private:

int topIndex; int capacity; //Maximum capacity of the array

char *pMyArray; //Pointer to an arraypublic:

int size();bool isEmpty();void push(const char& c);char& top() { return pMyArray[topIndex]; }void pop();

};

Step 4 – Add Exceptions etc.

Add robustness – use exceptions Avoid memory problems

– Implement a copy constructor– Implement operator=