Chapter 6

stack

1
 Learn about stacks
 Examine various stack operations
 Learn how to implement a stack as an array
 Learn how to implement a stack as a linked

list
 Discover stack applications
 Learn to use a stack to remove recursion

Data Structures Using Java 2

 Definition:
◦ list of homogeneous elements
◦ addition and deletion of elements occurs only at
one end, called the top of the stack
 Last In First Out (LIFO) data structure
 Used to implement method calls
 Used to convert recursive algorithms
(especially not tail recursive) into
nonrecursive algorithms

3
Data Structures Using Java 4
 Last In First Out (LIFO) data structure
◦ Top element of stack is last element to be added
to stack
◦ Elements added and removed from one end (top)
◦ Item added last are removed first

Data Structures Using Java 5

Data Structures Using Java 6
Data Structures Using Java 7
 initializeStack: Initializes the stack to an
empty state
 isEmptyStack: Checks whether the stack is
empty. If empty, it returns true; otherwise, it
returns false
 isFullStack: Checks whether the stack is full.
If full, it returns true; otherwise, it returns
false

Data Structures Using Java 8

 push:
◦ Add new element to the top of the stack
◦ The input consists of the stack and the new
element
◦ Prior to this operation, the stack must exist and
must not be full

Data Structures Using Java 9

 top: Returns the top element of the stack.
Prior to this operation, the stack must exist
and must not be empty
 pop: Removes the top element of the stack.

Prior to this operation, the stack must exist

and must not be empty

Data Structures Using Java 10

Data Structures Using Java 11
Data Structures Using Java 12
public void initializeStack()
{
for(int i = 0; i < stackTop; i++)
list[i] = null;
stackTop = 0;
}//end initializeStack

Data Structures Using Java

13
public boolean isEmptyStack()
{
return(stackTop == 0);
}//end isEmptyStack

public boolean isFullStack()

{
return(stackTop == maxStackSize);
}//end isFullStack

Data Structures Using Java

14
Data Structures Using Java
15
public void push(DataElement newItem) throws
StackOverflowException
{
if(isFullStack())
throw new StackOverflowException();
list[stackTop] = newItem.getCopy(); //add newItem at the
//top of the stack
stackTop++; //increment stackTop
}//end push

Data Structures Using Java 16

public DataElement top() throws StackUnderflowException
{
if(isEmptyStack())
throw new StackUnderflowException();
DataElement temp = list[stackTop - 1].getCopy();
return temp;
}//end top

Data Structures Using Java 17

public void pop() throws StackUnderflowException
{
if(isEmptyStack())
throw new StackUnderflowException();
stackTop--; //decrement stackTop
list[stackTop] = null;
}//end pop

Data Structures Using Java 18

Data Structures Using Java
19
private void copy(StackClass otherStack)
{
list = null;
System.gc();
maxStackSize = otherStack.maxStackSize;
stackTop = otherStack.stackTop;
list = new DataElement[maxStackSize];
//copy otherStack into this stack
for(int i = 0; i < stackTop; i++)
list[i] = otherStack.list[i].getCopy();
}//end copy
6

Data Structures Using Java 20

 //constructor with a parameter
public StackClass(int stackSize)
{
if(stackSize <= 0)
{
System.err.println(“The size of the array to implement “
+ “the stack must be positive.”);
System.err.println(“Creating an array of size 100.”);
maxStackSize = 100;
}
else
maxStackSize = stackSize; //set the stack size to
//the value specified by
//the parameter stackSize
stackTop = 0; //set stackTop to 0
list = new DataElement[maxStackSize]; //create the array
}//end constructor

Data Structures Using Java 21

 //default constructor
public StackClass()
{
maxStackSize = 100;
stackTop = 0; //set stackTop to 0
list = new DataElement[maxStackSize]; //create array
}//end default constructor

Data Structures Using Java 22

public StackClass(StackClass otherStack)
{
copy(otherStack);
}//end copy constructor

public void copyStack(StackClass otherStack)

{
if(this != otherStack) //avoid self-copy
copy(otherStack);
}//end copyStack

Data Structures Using Java 23

Input The program reads an input file consisting of each
student’s GPA, followed by the student’s name. Sample
data is:

3.8 Lisa
3.6 John
3.9 Susan
3.7 Kathy
3.4 Jason
3.9 David
3.4 Jack
Data Structures Using Java 24
1. Declare the variables
2. Create a DecimalFormat object to output a
decimal number to two decimal places
3. Open the input file
4. If the input file does not exist, exit the
program
5. Read the next input line

Data Structures Using Java 25

6. while (not end of file)
{
6.a. Tokenize the input line
6.b. Get the next GPA
6.c. Get the next name
6.d. if (GPA > highestGPA)
{
6.d.i initialize stack
6.d.ii push(stack, student name)
6.d.iii highestGPA = GPA
}
6.e. else
if(GPA is equal to highestGPA)
push(stack, student name)
6.f Read the next input line
}

Data Structures Using Java 26

7. Output the highest GPA.
8. Output the names of the students having the
highest GPA.

Data Structures Using Java 27

Input File (Ch6_HighestGPAData.txt)
3.4 Holt
3.2 Bolt
2.5 Colt
3.4 Tom
3.8 Ron
3.8 Mickey
3.6 Pluto
3.5 Donald
3.8 Cindy
3.7 Dome
3.9 Andy
3.8 Fox
3.9 Minnie
2.7 Goofy
3.9 Doc
3.4 Danny

Data Structures Using Java 28

Output

Highest GPA = 3.90

The students holding the highest GPA are:
Doc
Minnie
Andy

Data Structures Using Java 29

Empty linked stack Nonempty linked stack

Data Structures Using Java 30

public LinkedStackClass()
{
stackTop = null;
}

Data Structures Using Java 31

public void initializeStack()
{
stackTop = null;
}//end initializeStack

public boolean isEmptyStack()

{
return(stackTop == null);
}
public boolean isFullStack()
{
return false;
}

Data Structures Using Java

32
Stack before the push Stack and newNode
operation

Data Structures Using Java 33

Stack after the statement Stack after the statement
newNode.link = stackTop; stackTop = newNode;
executes executes

Data Structures Using Java 34

public DataElement top() throws
StackUnderflowException
{
if(stackTop == null)
throw new StackUnderflowException();

return stackTop.info.getCopy();
}//end top

Data Structures Using Java 35

 Stack after the statement
stackTop = stackTop.link; executes

Stack before the pop operation Stack after popping the top element

Data Structures Using Java

36
 Prefix/Polish Notation
 Suffix/Postfix/Reverse Polish Notation

Data Structures Using Java 37

Data Structures Using Java 38
Stack after pushing 6 Stack after retrieving the top two elements
and popping twice

Stack after pushing 3 Stack after pushing the result of op1 +

op2, which is 9
Data Structures Using Java
39
 Stack after pushing 2 Stack after pushing the result of op1 *
op2, which is 18

Stack after retrieving the top two elements Stack after popping the element
and popping twice
Data Structures Using Java
40
Get the next expression
while more data to process
{
a. initialize the stack
b. process the expression
c. output the result
d. get the next expression
}

Data Structures Using Java 41

current = first; //Line 1
while(current != NULL) //Line 2
{
stack.push(current); //Line 3
current = current.link; //Line 4
}

Data Structures Using Java

42
Data Structures Using Java 43
Data Structures Using Java 44
 Java provides a class to implement a stack in
a program
 The name of the Java class defining a stack is
Stack
 The class Stack is contained in the package
java.util
 Table 6-3 lists the members of the class
Stack

Data Structures Using Java 45

Data Structures Using Java 46
 Stack Data Structure
 Last In First Out (LIFO)
 Stacks Implemented as Arrays
 Stacks Implemented as Linked Lists
 Postfix Expression Calculator
 Nonrecursive Algorithm to Print Linked List
 Java class Stack

Data Structures Using Java 47