stack in java data structure - muhammed .ppt

STACKS - JAVA
MUHAMMED SSSS PTUK

WHAT IS A STACK IN JAVAIN
JAVA?
• It is an ordered group of homogeneous items of
elements.
• Elements are added to and removed from the top
of the Stack in java(the most recently added
items are at the top of the stack).
• The last element to be added is the first to be
removed (LIFO: Last In, First Out).

STACK IN JAVASPECIFICATION
• Definitions: (provided by the user)
• MAX_ITEMS: Max number of items that might be
on the stack
• ItemType: Data type of the items on the stack
• Operations
• MakeEmpty
• Boolean IsEmpty
• Boolean IsFull
• Push (ItemType newItem)
• Pop (ItemType& item)

PUSH (ITEMTYPE NEWITEM)
•Function: Adds newItem to the
top of the stack.
•Preconditions: Stack in javahas
been initialized and is not full.
•Postconditions: newItem is at the
top of the stack.

POP (ITEMTYPE& ITEM)
• Function: Removes topItem from Stack in
javaand returns it in item.
• Preconditions: Stack in javahas been initialized
and is not empty.
• Postconditions: Top element has been
removed from Stack in javaand item is a copy
of the removed element.

stack in java data structure - muhammed .ppt

STACK IN JAVAIMPLEMENTATION
#include "ItemType.h"
// Must be provided by the user of the class
// Contains definitions for MAX_ITEMS and ItemType
class StackType {
public:
StackType();
void MakeEmpty();
bool IsEmpty() const;
bool IsFull() const;
void Push(ItemType);
void Pop(ItemType&);
private:
int top;
ItemType items[MAX_ITEMS];
};

(CONT.)
StackType::StackType()
{
top = -1;
}
void StackType::MakeEmpty()
{
top = -1;
}
bool StackType::IsEmpty() const
{
return (top == -1);
}

(CONT.)
bool StackType::IsFull() const
{
return (top == MAX_ITEMS-1);
}
void StackType::Push(ItemType newItem)
{
top++;
items[top] = newItem;
}
void StackType::Pop(ItemType& item)
{
item = items[top];
top--;
}

Stack in javaoverflow
• The condition resulting from trying to push an
element onto a full stack.
if(!stack.IsFull())
stack.Push(item);
Stack in javaunderflow
• The condition resulting from trying to pop an
empty stack.
if(!stack.IsEmpty())
stack.Pop(item);

IMPLEMENTING STACKS USING
TEMPLATES
• Templates allow the compiler to generate
multiple versions of a class type or a function by
allowing parameterized types.
• It is similar to passing a parameter to a function
(we pass a data type to a class !!)

TEMPLATES
template<class ItemType>
class StackType {
public:
StackType();
void MakeEmpty();
private:
int top;
ItemType items[MAX_ITEMS];
};
(cont.)

EXAMPLE USING TEMPLATES
// Client code
StackType<int> myStack;
StackType<float> yourStack;
StackType<StrType> anotherStack;
myStack.Push(35);
yourStack.Push(584.39);
The compiler generates distinct class types and
gives its own internal name to each of the types.

FUNCTION TEMPLATES
• The definitions of the member functions
must be rewritten as function templates.
StackType<ItemType>::StackType()
{
top = -1;
}
void StackType<ItemType>::MakeEmpty()
{
top = -1;
}

FUNCTION TEMPLATES (CONT.)
bool StackType<ItemType>::IsEmpty() const
{
return (top == -1);
}
bool StackType<ItemType>::IsFull() const
{
return (top == MAX_ITEMS-1);
}
void StackType<ItemType>::Push(ItemType newItem)
{
top++;
items[top] = newItem;
}

FUNCTION TEMPLATES (CONT.)
void StackType<ItemType>::Pop(ItemType& item)
{
item = items[top];
top--;
}

COMMENTS USING TEMPLATES
• The template<class T> designation must
precede the class method name in the source
code for each template class method.
• The word class is required by the syntax of the
language and does not mean that the actual
parameter must be the name of a class.
• Passing a parameter to a template has an effect
at compile time.

DYNAMIC ARRAY ALLOCATION
class StackType {
public:
StackType(int);
~StackType();
void MakeEmpty();
private:
int top;
int maxStack;
ItemType *items;
};

DYNAMIC ARRAY ALLOCATION
(CONT.)
StackType<ItemType>::StackType(int max)
{
maxStack in java= max;
top = -1;
items = new ItemType[max];
}
StackType<ItemType>::~StackType()
{
delete [ ] items;
}

EXAMPLE: 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 +
• Expressions are evaluated from left to right.
• Precedence rules and parentheses are never
needed!!

EXAMPLE: POSTFIX EXPRESSIONS
(CONT.)

POSTFIX EXPRESSIONS:
ALGORITHM USING STACKS
(CONT.)

POSTFIX EXPRESSIONS:
ALGORITHM USING STACKS
WHILE more input items exist
Get an item
IF item is an operand
stack.Push(item)
ELSE
stack.Pop(operand2)
stack.Pop(operand1)
Compute result
stack.Push(result)
stack.Pop(result)

Write the body for a function that replaces each
copy of an item in a Stack in javawith another
item. Use the following specification. (this
function is a client program).
ReplaceItem(StackType& stack, ItemType oldItem,
ItemType newItem)
Function: Replaces all occurrences of oldItem
with newItem.
Precondition: Stack in javahas been initialized.
Postconditions: Each occurrence of oldItem in
Stack in javahas been replaced by newItem.
(You may use any of the member functions of the
StackType, but you may not assume any
knowledge of how the Stack in javais
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

EXERCISES
• 1, 3-7, 14, 12, 15, 18, 19

stack in java data structure - muhammed .ppt

Recommended

More Related Content

Similar to stack in java data structure - muhammed .ppt (20)

More from ssusere3b1a2 (14)

Recently uploaded (20)

stack in java data structure - muhammed .ppt