Data Strcture and Algorithms - Destailed Analysis of Stacks

Stacks
CS 302 – Data Structures
Sections 5.1, 5.2, 6.1, 6.5

Warning
• Although data structure concepts between
this and last semesters will be the same,
there might be implementation differences.
• Your answers in questions in quizzes and
exams should be based on this semester’s
(CS302) implementations!

Definitions
• ImageType.h
• ImageType.cpp
• Driver.cpp
class specification
class implementation
application
(client code)

Question
• In object oriented programming, class
implementation details are hidden from
applications that use the class.
• Why?

What is a stack?
• It is an ordered group of homogeneous items.
• Items are added to and removed from the top of the stack
LIFO property: Last In, First Out
• The last item added would be the first to be removed
TOP OF THE STACK TOP OF THE STACK

Stack Implementations
Array-based
Linked-list-based

Array-based Stacks
template<class ItemType>
class StackType {
public:
StackType(int);
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Push(ItemType);
void Pop(ItemType&);
private:
int top, maxStack;
ItemType *items;
};
dynamically allocated array

Array-based Stacks (cont’d)
StackType<ItemType>::StackType(int size)
{
top = -1;
maxStack = size;
items = new ItemType[max];
}
StackType<ItemType>::~StackType()
{
delete [ ] items;
}
O(1)
O(1)

Array-based Stacks (cont’d)
void StackType<ItemType>::MakeEmpty()
{
top = -1;
} O(1)

Array-based Stacks (cont.)
bool StackType<ItemType>::IsEmpty() const
{
return (top == -1);
}
bool StackType<ItemType>::IsFull() const
{
return (top == maxStack-1);
}
O(1)
O(1)

Push (ItemType newItem)
• Function: Adds newItem to the top of
the stack.
• Preconditions: Stack has been
initialized and is not full.
• Postconditions: newItem is at the top
of the stack.

Stack overflow
• The condition resulting from trying to push
an element onto a full stack.
if(!stack.IsFull())
stack.Push(item);

void StackType<ItemType>::Push(ItemType newItem)
{
top++;
items[top] = newItem;
} O(1)

Pop (ItemType& item)
• Function: Removes topItem from stack and
returns it in item.
• Preconditions: Stack has been initialized
and is not empty.
• Postconditions: Top element has been
removed from stack and item is a copy of
the removed element.

Stack underflow
• The condition resulting from trying to pop
an empty stack.
if(!stack.IsEmpty())
stack.Pop(item);

void StackType<ItemType>::Pop(ItemType& item)
{
item = items[top];
top--;
}
O(1)

Templates
• Templates allow the compiler to generate multiple
versions of a class type by allowing parameterized
types.
• Compiler generates distinct class types and gives
its own internal name to each of the types.

Compiling Templates
• Cannot anymore compile StackType.cpp separately
from the application of the class (e.g., driver.cpp)
• Compiler needs to know the data type of the stack
to instantiate the class!
• Where can the compiler find this information?

Compiling Templates (cont’d)
// Client code
StackType<int> myStack;
StackType<float> yourStack;
StackType<StrType> anotherStack;
myStack.Push(35);
yourStack.Push(584.39);

Compiling Templates (cont’d)
• Must compile StackType.cpp and client code (e.g.,
driver.cpp) together!
(1) Use “include” directive to include StackType.cpp
StackType.cpp at the end
of StackType.h
StackType.h
(2) “include” StackType.h
StackType.h in client’s code
(3) Compile client code

Linked-list-based Stacks
struct NodeType<ItemType> {
ItemType info;
NodeType<ItemType>* next;
};

Linked-list-based Stacks (cont’d)
struct NodeType<ItemType>;
class StackType {
public:
StackType();
~StackType();
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Push(ItemType);
void Pop(ItemType&);
private:
NodeType<ItemType>* topPtr;
};

StackType<ItemType>::StackType()
StackType()
{
topPtr = NULL;
}
void StackType<ItemType>::MakeEmpty()
MakeEmpty()
{
NodeType<ItemType>* tempPtr;
while(topPtr != NULL) {
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
}
}
O(N)
O(1)

bool StackType<ItemType>::IsEmpty()
IsEmpty() const
{
return(topPtr == NULL);
}
StackType<ItemType>::~StackType()
StackType()
{
MakeEmpty();
}
O(1)
O(N)

bool StackType<ItemType>::IsFull()
IsFull() const
{
NodeType<ItemType>* location;
location = new NodeType<ItemType>; // test
if(location == NULL)
return true;
else {
delete location;
return false;
}
}
O(1)

Pushing on a non-empty stack
(cont.)
• The order of changing the pointers is
important!

Special Case: pushing on an
empty stack

Function Push
template <class ItemType>
void StackType<ItemType>::Push
Push(ItemType
item)
{
NodeType<ItemType>* location;
location = new NodeType<ItemType>;
location->info = newItem;
location->next = topPtr;
topPtr = location;
}
O(1)

Popping the top
element
(cont.)
Need a
temporary
pointer !

Special case: popping the last
element on the stack
tempPtr

Function Pop
template <class ItemType>
void StackType<ItemType>::Pop
Pop(ItemType& item)
{
NodeType<ItemType>* tempPtr;
item = topPtr->info;
tempPtr = topPtr;
topPtr = topPtr->next;
delete tempPtr;
}
O(1)

Comparing stack implementations
Big-O Comparison of Stack Operations
Operation Array
Implementation
Linked
Implementation
Constructor O(1) O(1)
MakeEmpty O(1) O(N)
IsFull O(1) O(1)
IsEmpty O(1) O(1)
Push O(1) O(1)
Pop O(1) O(1)
Destructor O(1) O(N)

Array-vs Linked-list-based
Stack Implementations
• Array-based implementation is simple but:
– The size of the stack must be determined when
a stack object is declared.
– Space is wasted if we use less elements.
– We cannot "enqueue" more elements than the
array can hold.
• Linked-list-based implementation alleviates
these problems but time requirements might
increase.

Example using stacks:
evaluate postfix expressions
• Postfix notation is another way of writing arithmetic
expressions.
• In postfix notation, the operator is written after the two
operands.
infix: 2+5 postfix: 2 5 +
• Why using postfix notation?
Precedence rules and parentheses are not required!

Example: postfix expressions
(cont.)
Expressions are evaluated from left to right.

Postfix expressions:
Algorithm using stacks (cont.)

Exercise 15: Write the body for a client function that
replaces each copy of an item in a stack with another item.
Use the following specification.
ReplaceItem(StackType& stack, ItemType oldItem,
ItemType newItem)
Function: Replaces all occurrences of oldItem with
newItem.
Precondition: stack has been initialized.
Postconditions: Each occurrence of oldItem in stack has
been replaced by newItem. Order of other elements remains
unchanged.
Warning: you may not assume any knowledge of how the
stack is implemented!

{
ItemType item;
StackType tempStack;
while (!Stack.IsEmpty()) {
Stack.Pop(item);
if (item==oldItem)
tempStack.Push(newItem);
else
tempStack.Push(item);
}
while (!tempStack.IsEmpty()) {
tempStack.Pop(item);
Stack.Push(item);
}
}
1
2
3
3
5
1
1
5
3
Stack
Stack
tempStack
oldItem = 2
newItem = 5

{
ItemType item;
StackType tempStack;
while (!Stack.IsEmpty()) {
Stack.Pop(item);
if (item==oldItem)
tempStack.Push(newItem);
else
tempStack.Push(item);
}
while (!tempStack.IsEmpty()) {
tempStack.Pop(item);
Stack.Push(item);
}
}
O(N)
What are the time
requirements using big-O?

Data Strcture and Algorithms - Destailed Analysis of Stacks

Recommended

More Related Content

Similar to Data Strcture and Algorithms - Destailed Analysis of Stacks (20)

Recently uploaded (20)

Data Strcture and Algorithms - Destailed Analysis of Stacks