Instructional Module: Republic of The Philippines Nueva Vizcaya State University Bayombong, Nueva Vizcaya

Republic of the Philippines
NUEVA VIZCAYA STATE UNIVERSITY

Bayombong, Nueva Vizcaya
INSTRUCTIONAL MODULE
IM No.:IM-IT ECC4-2NDSEM-2021-2022
COLLEGE OF ARTS AND SCIENCES

Bayombong Campus
DEGREE BSIT COURSE NO. IT ECC 4

PROGRAM
SPECIALIZATION Web Dev and Network COURSE Data Structure and Algorithm
Design and Management TITLE
YEAR LEVEL 1st Year TIME FRAME 5 WK 12-13 IM 06
hours NO. NO.
I. CHAPTER VI– Stack Data Structure using Java
II. LESSON TITLE

A. Anatomy of Stack
B. What is Stack?
C. Operation on stack
D. Implementation of Stack using Java
III. LESSON OVERVIEW

This lesson will give the students a short knowledge on how to develop a program using the stack data
structure, to be familiar with the different operation on stack and to illustrate the flow on how elements store
and retrieve in the data structure.
IV. DESIRED LEARNING OUTCOMES
At the end of the lesson, the student should be able to:
1. To declare a stack in Java program.

2. To simulate by tracing the elements and memory addresses stored in the memory.
4. To apply the concepts of stack in Java program.
V. LESSON CONTENT
CHAPTER IV: STACK DATA STRUCTURE
Introduction
The term “stack” is one of the magical and sometimes imposing terms used in computer programming that
seems to imply an abstract concept. Yet you actually know all about stacks because you use a stack when
playing cards, making pancakes, and storing laundry. A stack is the way you groups things together by placing
one thing on top of another and then removing things one at a time from the top of the stack. It is amazing that
something this simple is a critical component of nearly every program that is written.
Anatomy of a Stack
“In accordance with Section 185, Fair Use of Copyrighted Work of Republic Act 8293, the copyrighted works included in this material may be reproduced for educational
purposes only and not for commercial distribution,”
NVSU-FR-ICD-05-00 (081220) Page 1 of 19
When you hear the term “stack” used outside the context of computer programming, you might envision
a stack of dishes on your kitchen counter. This organization is structured in a particular way: the newest dish is
on top and the oldest is on the bottom of the stack.
Each dish in a stack is accessed using LIFO: last in, first out. The only way to access each dish is
from the top of the stack. If you want the third dish (the third oldest on the stack), then you must remove the
first two dishes from the top of the stack. This places the third dish at the top of the stack making it available to
be removed.
There’s no way to access a dish unless the dish is at the top of the stack. You might be thinking stacks
are inefficient, and you’d be correct if the objective was to randomly access things on the stack. There are
other data structures that are ideal for random access, which you’ll learn about throughout this book.
However, if the object is to access things in the order in which they were placed on the stack, such as
computer instructions, stacks are efficient. In these situations, using a stack makes a lot of sense.
NOTE:
Stacks and arrays are often bantered about in the same discussion, which can easily lead to confusion,
but they are really two separate things (see Figure 1). An array stores values in memory; a stack tracks
which array element is at the top of the stack. When a value is popped off the stack, the value remains
in memory because the value is still assigned to an array element. Popping it only changes the array
element that is at the top of the stack.
A. What is a Stack?
 a list in which insertion and deletion take place at the same end
o this end is called top
 stacks are known as LIFO (Last In, First Out) lists
o the last element inserted will be the first to be retrieved
 allows access to only the last item inserted
 an item is inserted or removed from the stack from one end called the “top” of the stack
Figure 6.1: A stack and an array are two different things: an array stores values in memory;
a stack tracks which of the array elements is at the top of the stack.
Inside a Stack
Programmers use arrays to store values that are referenced by a stack. As you’ll recall from
Chapter 6, an array consists of a series of array elements, each of which is similar in concept to a
variable. The stack contains the index of the array element that is at the top of the stack.
Figure 6.1 is the way some programmers envision an array used with a stack. This example
shows an array called stack with 8 array elements. The entire array contains values that are referenced
by the stack. Three array elements are assigned values, while the other array elements are empty and
can be used when new items are placed on the stack.
Mike is the first value placed on the stack. You know this because Mike is at the bottom of the
stack. Bob is the last item placed on the stack because Bob is the top item on the stack.
B. Operations of a Stack
1) Push. It refers to the adding an element to the top of the stack, means placing an item on a stack or
the direction that data is being added to the stack
Here’s what actually happens. The new value is assigned to the next available array element and the
index of that array element becomes the top of the stack, as shown in Figure 2. The program
increments the current index of the stack by 1. In this example, the index is incremented by 1, resulting
in index 3 being at the top of the stack, which is the index of the new values assigned to the array.
Figure 6.2: The new value is assigned to the next array element and
its index becomes the top of the stack.
 Stack overflow - if a push operation causes the stack pointer to increment beyond the maximum
extent of the stack
2) Pop. It refers to the removing of an item from the stack.
Note:
It is important to understand that popping an item off the stack doesn’t copy the item. Once an
item is popped from the stack, the item is no longer available on the stack, although the value remains
in the array.
Here’s what really happens. Remember that the top of the stack contains an index of the array
element whose value is at the top of the stack. In Figure 2, index 3 is at the top of the stack, which
means New Value in array element 3 is at the top of the stack.
When you pop New Value from the stack, you decrement the index at the top of the stack. That
is, you make its index 2 instead of 3. This makes Bob the new value at the top of the stack. Notice that
New Value and array element 3 remain untouched in the array because popping a value from the stack
only alters the stack, not the underlying array.
Figure 6.3: All values move toward the top of the stack when the top item is popped off the
stack.
 Stack underflow - if a pop operation on the stack causes the stack pointer to move past the origin of
the stack
Additional Operations on Stack:
 Dup(licate)
 the top item is popped, and then pushed again (twice), so that an additional copy of the former
top item is now on top, with the original below it
 Peek
 the topmost item is inspected (or returned), but the stack pointer is not changed, and the stack
size does not change (meaning that the item remains on the stack)
 Swap or exchange
 the two topmost items on the stack exchange places
 Rotate
 the n topmost items are moved on the stack in a rotating fashion
For example, if n=3, items 1, 2, and 3 on the stack are moved to positions 2, 3, and 1 on the stack,
respectively. Many variants of this operation are possible, with the most common being called left
rotate and right rotate.
This visualization may be independent of the actual structure of the stack in memory. This means that a
right rotate will move the first element to the third position, the second to the first and the third to the
second. Here are two equivalent visualizations of this process:
0 apple banana 0
1 banana ===right rotate==> cucumber 1
2 cucumber apple 2
0 cucumber apple 0
1 banana ===left rotate==> cucumber 1
2 apple banana 2
Java Stack in
The stack is a linear data structure that is used to store the collection of objects. It is based on Last-In-First-
Out (LIFO). Java collection framework provides many interfaces and classes to store the collection of objects.
One of them is the Stack class that provides different operations such as push, pop, search, etc.
In this section, we will discuss the Java Stack class, its methods, and implement the stack data structure in
a Java program. But before moving to the Java Stack class have a quick view of how the stack works.
The stack data structure has the two most important operations that are push and pop. The push operation
inserts an element into the stack and pop operation removes an element from the top of the stack. Let's see
how they work on stack.
Let's push 20, 13, 89, 90, 11, 45, 18, respectively into the stack.OOPs Concepts in Java
Let's remove (pop) 18, 45, and 11 from the stack.
Empty Stack: If the stack has no element is known as an empty stack. When the stack is empty the value of
the top variable is -1.
When we push an element into the stack the top is increased by 1. In the following figure,
o Push 12, top=0

o Push 6, top=1
o Push 9, top=2
When we pop an element from the stack the value of top is decreased by 1. In the following figure, we have
popped 9.
The following table shows the different values of the top.
Java Stack Class
In Java, Stack is a class that falls under the Collection framework that extends the Vector class. It also
implements interfaces List, Collection, Iterable, Cloneable, Serializable. It represents the LIFO stack of
objects. Before using the Stack class, we must import the java.util package. The stack class arranged in the
Collections framework hierarchy, as shown below.
Stack Class Constructor
The Stack class contains only the default constructor that creates an empty stack.
public Stack()
Creating a Stack
If we want to create a stack, first, import the java.util package and create an object of the Stack class.
Stack stk = new Stack();
Or
Stack<type> stk = new Stack<>();
Where type denotes the type of stack like Integer, String, etc.
Methods of the Stack Class
We can perform push, pop, peek and search operation on the stack. The Java Stack class provides
mainly five methods to perform these operations. Along with this, it also provides all the methods of
the Java Vector class.
Method Modifier and Method Description

Type
empty() boolean The method checks the stack is empty or not.
push(E item) E The method pushes (insert) an element onto the top of the stack.
pop() E The method removes an element from the top of the stack and returns
the same element as the value of that function.
peek() E The method looks at the top element of the stack without removing it.
search(Object Int The method searches the specified object and returns the position of
o) the object.
Stack Class empty() Method
The empty() method of the Stack class check the stack is empty or not. If the stack is empty, it returns
true, else returns false. We can also use the isEmpty() method of the Vector class.
Syntax
public boolean empty()
Returns: The method returns true if the stack is empty, else returns false.
In the following example, we have created an instance of the Stack class. After that, we have invoked
the empty() method two times. The first time it returns true because we have not pushed any element
into the stack. After that, we have pushed elements into the stack. Again we have invoked the empty()
method that returns false because the stack is not empty.
StackEmptyMethodExample.java
1. import java.util.Stack;
2. public class StackEmptyMethodExample
3. {
4. public static void main(String[] args)
5. {
6. //creating an instance of Stack class
7. Stack<Integer> stk= new Stack<>();
8. // checking stack is empty or not
9. boolean result = stk.empty();
10. System.out.println("Is the stack empty? " + result);
11. // pushing elements into stack
12. stk.push(78);
13. stk.push(113);
14. stk.push(90);
15. stk.push(120);
16. //prints elements of the stack
17. System.out.println("Elements in Stack: " + stk);
18. result = stk.empty();
20. }
21. }
Output:
Is the stack empty? true

Elements in Stack: [78, 113, 90, 120]
Is the stack empty? false
Stack Class push() Method
The method inserts an item onto the top of the stack. It works the same as the
method addElement(item) method of the Vector class. It passes a parameter item to be pushed
into the stack.
Syntax
public E push(E item)
Parameter: An item to be pushed onto the top of the stack.
Returns: The method returns the argument that we have passed as a parameter.
Stack Class pop() Method
The method removes an object at the top of the stack and returns the same object. It
throws EmptyStackException if the stack is empty.
Syntax
1. public E pop()
Returns: It returns an object that is at the top of the stack.
Let's implement the stack in a Java program and perform push and pop operations.
StackPushPopExample.java
1. import java.util.*;
2. public class StackPushPopExample
3. {
4. public static void main(String args[])
5. {
6. //creating an object of Stack class
7. Stack <Integer> stk = new Stack<>();
8. System.out.println("stack: " + stk);
9. //pushing elements into the stack
10. pushelmnt(stk, 20);
17. //popping elements from the stack
18. popelmnt(stk);
19. popelmnt(stk);
20. //throws exception if the stack is empty
21. try
22. {
23. popelmnt(stk);
24. }
25. catch (EmptyStackException e)
26. {
27. System.out.println("empty stack");
28. }
29. }
30. //performing push operation
31. static void pushelmnt(Stack stk, int x)
32. {
33. //invoking push() method
34. stk.push(new Integer(x));
35. System.out.println("push -> " + x);
36. //prints modified stack
38. }
39. //performing pop operation
40. static void popelmnt(Stack stk)
41. {
42. System.out.print("pop -> ");
43. //invoking pop() method
44. Integer x = (Integer) stk.pop();
45. System.out.println(x);
46. //prints modified stack
48. }
49. }
Output:
stack: []
push -> 20
stack: [20]
push -> 13
stack: [20, 13]
push -> 89
stack: [20, 13, 89]
push -> 90
stack: [20, 13, 89, 90]
push -> 11
stack: [20, 13, 89, 90, 11]
push -> 45
stack: [20, 13, 89, 90, 11, 45]
push -> 18
stack: [20, 13, 89, 90, 11, 45, 18]
pop -> 18
stack: [20, 13, 89, 90, 11, 45]

pop -> 45
stack: [20, 13, 89, 90, 11]
pop -> 11
stack: [20, 13, 89, 90]
Stack Class peek() Method
It looks at the element that is at the top in the stack. It also throws EmptyStackException if the stack is empty.
Syntax
public E peek()
Returns: It returns the top elements of the stack.
Let's see an example of the peek() method.
StackPeekMethodExample.java
2. public class StackPeekMethodExample
3. {
5. {
6. Stack<String> stk= new Stack<>();
7. // pushing elements into Stack
8. stk.push("Apple");
9. stk.push("Grapes");
10. stk.push("Mango");
11. stk.push("Orange");
12. System.out.println("Stack: " + stk);
13. // Access element from the top of the stack
14. String fruits = stk.peek();
15. //prints stack
16. System.out.println("Element at top: " + fruits);
17. }
18. }
Output:
Stack: [Apple, Grapes, Mango, Orange]

Element at the top of the stack: Orange
Stack Class search() Method
The method searches the object in the stack from the top. It parses a parameter that we want to search
for. It returns the 1-based location of the object in the stack. Thes topmost object of the stack is
considered at distance 1.
Suppose, o is an object in the stack that we want to search for. The method returns the distance from
the top of the stack of the occurrence nearest the top of the stack. It uses equals() method to search an
object in the stack.
Syntax
public int search(Object o)
Parameter: o is the desired object to be searched.
Returns: It returns the object location from the top of the stack. If it returns -1, it means that the object
is not on the stack.
Let's see an example of the search() method.
StackSearchMethodExample.java
2. public class StackSearchMethodExample
3. {
5. {
6. Stack<String> stk= new Stack<>();
7. //pushing elements into Stack
8. stk.push("Mac Book");
9. stk.push("HP");
10. stk.push("DELL");
11. stk.push("Asus");
12. System.out.println("Stack: " + stk);
13. // Search an element
14. int location = stk.search("HP");
15. System.out.println("Location of Dell: " + location);
16. }
17. }
Java Stack Operations
Size of the Stack
We can also find the size of the stack using the size() method of the Vector class. It returns the total number of
elements (size of the stack) in the stack.
Syntax
public int size()
Let's see an example of the size() method of the Vector class.
StackSizeExample.java
2. public class StackSizeExample
3. {
4. public static void main (String[] args)
5. {
6. Stack stk = new Stack();
7. stk.push(22);
8. stk.push(33);
9. stk.push(44);
10. stk.push(55);
11. stk.push(66);
12. // Checks the Stack is empty or not
13. boolean rslt=stk.empty();
14. System.out.println("Is the stack empty or not? " +rslt);
15. // Find the size of the Stack
16. int x=stk.size();
17. System.out.println("The stack size is: "+x);
18. }
19. }
Output:
Is the stack empty or not? false

The stack size is: 5
Iterate Elements
Iterate means to fetch the elements of the stack. We can fetch elements of the stack using three different
methods are as follows:
o Using iterator() Method

o Using forEach() Method
o Using listIterator() Method
Using the iterator() Method
It is the method of the Iterator interface. It returns an iterator over the elements in the stack. Before using the
iterator() method import the java.util.Iterator package.
Syntax
Iterator<T> iterator()
Let's perform an iteration over the stack.
StackIterationExample1.java
1. import java.util.Iterator;
3. public class StackIterationExample1
4. {
6. {
7. //creating an object of Stack class
8. Stack stk = new Stack();
9. //pushing elements into stack
10. stk.push("BMW");
11. stk.push("Audi");
12. stk.push("Ferrari");
13. stk.push("Bugatti");
14. stk.push("Jaguar");
15. //iteration over the stack
16. Iterator iterator = stk.iterator();
17. while(iterator.hasNext())
18. {
19. Object values = iterator.next();
20. System.out.println(values);
21. }
22. }
23. }
MW
Audi
Ferrari
Bugatti
Jaguar
Using the forEach() Method
Java provides a forEach() method to iterate over the elements. The method is defined in
the Iterable and Stream interface.
Syntax
default void forEach(Consumer<super T>action)
Let's iterate over the stack using the forEach() method.
1. import java.util.*;
3. {
5. {
8. //pushing elements into stack
9. stk.push(119);
10. stk.push(203);
11. stk.push(988);
12. System.out.println("Iteration over the stack using forEach() Method:");
13. //invoking forEach() method for iteration over the stack
14. stk.forEach(n ->
15. {
16. System.out.println(n);
17. });
18. }
19. }
Output:
Iteration over the stack using forEach() Method:

119
203
988
Using listIterator() Method
This method returns a list iterator over the elements in the mentioned list (in sequence), starting at the
specified position in the list. It iterates the stack from top to bottom.
Syntax
ListIterator listIterator(int index)
Parameter: The method parses a parameter named index.
Returns: This method returns a list iterator over the elements, in sequence.
Exception: It throws IndexOutOfBoundsException if the index is out of range.
Let's iterate over the stack using the listIterator() method.
1. import java.util.Iterator;
2. import java.util.ListIterator;
4.
6. {
8. {
10. stk.push(119);
11. stk.push(203);
12. stk.push(988);
13. ListIterator<Integer> ListIterator = stk.listIterator(stk.size());
14. System.out.println("Iteration over the Stack from top to bottom:");
15. while (ListIterator.hasPrevious())
16. {
17. Integer avg = ListIterator.previous();
18. System.out.println(avg);
19. }
20. }
21. }
Output:
Iteration over the Stack from top to bottom:

988
203
119
Sample
2. public class StackEmptyMethodExample
3. {
5. {
7. Stack<Integer> stk= new Stack<>();
8. // checking stack is empty or not
9. boolean result = stk.empty();
11. // pushing elements into stack or adding elements in the stack

12. stk.push(78);
13. stk.push(113);
14. stk.push(90);
15. stk.push(120);
16. // pop elements in the stack or deleting elements in the s tack
17. stk.pop();
18. stk.pop();
19. //prints elements of the stack or display elements in the stack
20. System.out.println("Elements in Stack: " + stk);
21. result = stk.empty();
23. }
24. }
Output:
Is the stack empty? true

Elements in Stack: [78, 113]
Is the stack empty? false
VI. LEARNING ACTIVITIES

Instruction: Simulate the given data using the stack operation by giving the exact/ accurate stack
content
Array_Number ={ 23, 25, 19, 28, 12, 14, 10, 7, 2, 19, 30, 3, 8, 4, }
Elements are derive from the array above
Instruction: push push push push pop pop push

(Left to right) Push pop pop push pop push push
Pop pop push pop pop pop pop
Answer here:
index elements
10
9
8
7
6
5
4
3
2
1
Write a program that will display the correct output base on the instruction given:
On-Line Resources:
1. http://www.tutorialspoint.com/java/java_data_structures.htm
2. http://en.wikipedia.org/wiki/Data_structure
3. http://freevideolectures.com/Course/2279/Data-Structures-And-Algorithms
4. http://courses.cs.vt.edu/csonline/DataStructures/Lessons/Introduction/index.html
5. http://www.tutorialspoint.com/java/java_data_structures.htm
6. http://www.cs.sunysb.edu/~skiena/214/lectures/
7. http://www.cs.utexas.edu/~novak/cs315contents.html
8. http://www.csd.uwo.ca/courses/CS2210b/

Instructional Module: Republic of The Philippines Nueva Vizcaya State University Bayombong, Nueva Vizcaya

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Instructional Module: Republic of The Philippines Nueva Vizcaya State University Bayombong, Nueva Vizcaya

Uploaded by

Copyright:

Available Formats

Republic of the Philippines

NUEVA VIZCAYA STATE UNIVERSITY

COLLEGE OF ARTS AND SCIENCES

DEGREE BSIT COURSE NO. IT ECC 4

I. CHAPTER VI– Stack Data Structure using Java

II. LESSON TITLE

III. LESSON OVERVIEW

IV. DESIRED LEARNING OUTCOMES

At the end of the lesson, the student should be able to:

1. To declare a stack in Java program.

CHAPTER IV: STACK DATA STRUCTURE

2) Pop. It refers to the removing of an item from the stack.

Additional Operations on Stack:

Let's remove (pop) 18, 45, and 11 from the stack.

o Push 12, top=0

The following table shows the different values of the top.

Java Stack Class

Stack Class Constructor

Stack stk = new Stack();

Stack<type> stk = new Stack<>();

Methods of the Stack Class

Method Modifier and Method Description

empty() boolean The method checks the stack is empty or not.

Stack Class empty() Method

public boolean empty()

Is the stack empty? true

Stack Class push() Method

public E push(E item)

Parameter: An item to be pushed onto the top of the stack.

Stack Class pop() Method

Returns: It returns an object that is at the top of the stack.

stack: [20, 13, 89, 90, 11, 45]

Stack Class peek() Method

Returns: It returns the top elements of the stack.

Let's see an example of the peek() method.

Stack: [Apple, Grapes, Mango, Orange]

Stack Class search() Method

public int search(Object o)

Parameter: o is the desired object to be searched.

Let's see an example of the search() method.

Java Stack Operations

Size of the Stack

public int size()

Let's see an example of the size() method of the Vector class.

Is the stack empty or not? false

o Using iterator() Method

Using the iterator() Method

Let's perform an iteration over the stack.

Using the forEach() Method

default void forEach(Consumer<super T>action)

Let's iterate over the stack using the forEach() method.

Iteration over the stack using forEach() Method:

Using listIterator() Method

ListIterator listIterator(int index)

Parameter: The method parses a parameter named index.

Exception: It throws IndexOutOfBoundsException if the index is out of range.

Let's iterate over the stack using the listIterator() method.

Iteration over the Stack from top to bottom:

11. // pushing elements into stack or adding elements in the stack

Is the stack empty? true

VI. LEARNING ACTIVITIES

Instruction: push push push push pop pop push

You might also like