stacks2

College of Computing & Information Technology
King Abdulaziz University
CPCS-204 – Data Structures I
Stacks:
Implementation in
JAVA

Stacks: Implementation in JAVA page 2
© Dr. Jonathan (Yahya) Cazalas
Stacks – An Overview
 Stacks:
 Stacks are an Abstract Data Type
 Meaning, they are a data type that we must build
 (well, in JAVA, we do have a stack class…more on that later)
 We must define them and their behaviors
 So what is a stack?
 A data structure that stores information in the form of a
stack.
 Consists of a variable number of homogeneous elements
 i.e. elements of the same type

 Stacks:
 Access Policy:
 The access policy for a stack is simple: the first element
to be removed from the stack is the last element that was
placed onto the stack
 The main idea is that the last item placed on to the stack is the
first item removed from the stack
 Known as the “Last in, First out” access policy
 LIFO for short
 The classical example of a stack is cafeteria trays.
 New, clean trays are added to the top of the stack.
 and trays are also taken from the top
 So the last tray in is the first tray taken out

 Stacks:
 Basic Operations:
 PUSH:
 This PUSHes an item on top of the stack
 POP:
 This POPs off the top item in the stack and returns it
 Other important tidbit:
 The end of the stack,
 where PUSHes and POPs occur,
 is usually referred to as the TOP of the stack

 Stacks:
 Other useful operations:
 isEmpty:
 Typically implemented as a boolean function
 Returns TRUE if no items are in the stack
 isFull:
 Returns TRUE if no more items can be added to the stack
 In theory, a stack should NEVER become full
 Actual implementations do have limits on the number of
elements a stack can store
 top (also called “peek”):
 Simply returns the value at the top of the stack without actually
popping the stack.

Stacks: Implementation in JAVA
 Implementation of Stacks in JAVA:
 As discussed on the previous lecture, there are
two obvious ways to implement stacks:
1) Using arrays
2) Using linked lists
 We will go over both…

 Array:
 We will implement the stack as an array!
 What does this mean?
 This means that when you examine the code for the stack, in
fact, it is simply using an array!
 So then how is the array a stack? What makes it a stack?
 The BEHAVIOR!
 We said that an Abstract Data Type is defined based on
its behaviors (the operations it can perform).
 So we will restrict the behavior of the array.
 We will make the array behave like (act like) a stack!

 Array:
 So we will restrict the behavior of the array.
 We will make the array behave like (act like) a stack!
 Example:
 With an array, you can insert anywhere or delete anywhere
 Insert at the beginning, middle, or end…anywhere!
 However:
 Since we are making this array behave like (act like) a stack:
 We will ONLY allow insertion at the “top”
 PUSH
 We will ONLY allow deletion at the “top”
 POP
 So now, our array has basically transformed into a stack!

 Array Implementation of Stacks:
 What components will we need to store?
1) The array storing the elements
 The actual stack of values
 What else?
2) An index to the top of the stack
 We assume the bottom of the stack is index 0
 Meaning, the 1st element will be stored in index 0
 and we move up from there
3) The max size of the stack (maxSize)
 Of course, we could just use the array.length feature of
JAVA to give us the size of the array (which is maxSize)

 Here is our class, StackArray:
 maxSize clearly represents the max number of items in
the stack
 If the stack becomes full, at that point, the top item will
be stored at index ‘maxSize-1’
public class StackArray {
private int[] stack;
private int top;
private int maxSize;
// Constructor and Methods here
}

 Here is the constructor:
 So we set maxSize from the parameter size
 We then make the new array, stack
 Finally, we set top equal to -1
 Why?
class StackArray {
...
public StackArray(int size) {
maxSize = size;
stack = new int[maxSize];
top = -1;
}

 When the stack has one element, what is saved in top?
 top is the index to the “top element”
 So if there is only one element, that element is at index zero!
 So top will have the value, 0, referring to the first cell
class StackArray {
...
maxSize = size;
top = -1;
}

 So when top is zero, that means we have ONE element
 How do we show that the stack is empty???
 We set top equal to -1
 This means that nothing is in the stack.
class StackArray {
...
maxSize = size;
top = -1;
}

 Here are the methods we will need to control our
stack behavior:
 public boolean isEmpty()
 public boolean isFull()
 public void push(int j)
 public int pop()
 public int top()

 isEmpty:
 The isEmpty function simply checks if the stack has no
elements
 Based on what you know thus far, how would you
determine if the stack is empty?
 If the top currently equals -1!
 Here’s the code:
public boolean isEmpty() {
return (top == -1);
}

 isFull:
 The isFull function checks to see if the stack is full
 How would we do this?
 Remember, maxSize is the max # of items in the stack
 Item 1 goes at index 0
 If the stack is full, the top item will be at index ‘maxSize-1’
public boolean isFull() {
return (top == maxSize-1)
}

 push:
 Remember, we can only push if the stack is not full
 Meaning, if there is room to push
 So if the stack is full
 We print an error message.
 Or throw an Exception, showing the push could not be done
 If there is room
 We increment top to point to the next space in the stack
 Then we simply copy the value into this new top position

 push:
 To push an element, increment top to point to the next
space in the stack
 Then we simply copy the value into this new top position
public void push(int value) {
if (isFull())
System.out.println(“Cannot PUSH; stack is full.”);
else
stack[++top] = value;
}

 pop:
 Remember, we can only pop if the stack is not empty
 Meaning, there is at least one element to pop
 So if the stack is empty
 We print an error message
 Or throw an exception showing that we cannot pop
 If the stack has at least one element:
 We return the value at position top
 At the same time, we decrement top
 This makes the top “pointer” refer to the next item down in
the stack

 pop:
 To pop an element, we simply return the top item in the
stack and then decrement top
public int pop() {
if (isEmpty())
System.out.println(“Cannot POP; stack is empty.”);
else
return stack[top--];
}

 top (or peek):
 The top method is very similar to pop
 Remember, we can only check for the top of the stack if
the stack is not empty
 Meaning, there is at least one element in the stack
 So if the stack is empty
 We print an error message
 If the stack has at least one element:
 We simply return the topmost element
 But we do NOT decrement

 top:
 Simply returns the top item in the stack
public int top() {
if (isEmpty())
System.out.println(“Cannot TOP; stack is empty.”);
else
return stack[top];
}

 The code shown here is only small pieces of the
code.
 Code is on Blackboard:
 You can also view a FULLY-FUNCITONAL Array
Implementation of a Stack on Blackboard.

Brief Interlude: HUGE Fail

 Linked-list:
 We can also implement the stack as a linked-list!
 Advantage of no fixed size and dynamic memory
 What does this mean?
 This means that when you examine the code for the stack, in
fact, it is simply using a modified version of the linked-list code!
 So then how is the linked-list a stack?
 The BEHAVIOR!
 We will restrict the behavior of the linked-list.
 We will make the linked-list behave like (act like) a stack!

 Linked-list:
 We will restrict the behavior of the linked-list.
 We will make the linked-list behave like (act like) a stack!
 Example:
 With a linked-list, you can insert anywhere or delete anywhere
 Insert at the beginning, middle, or end…anywhere!
 However:
 Since we are making this linked-list behave like a stack:
 We will ONLY allow insertion at the “top”
 PUSH
 We will ONLY allow deletion at the “top”
 POP
 So now, our linked-list has basically transformed into a stack!

 Linked Lists Implementation of Stacks:
 We essentially use a standard linked list
 But we limit the functionality of a linked list
 Thus creating the behavior required of a stack
 Step 1:
 Choose the location of top!
 Where should we choose top to be? What is best?
 Top could be the “front” of the list OR the “end” of the list
 Which is better?
 If we choose top to be the end, we must traverse to the
end for every PUSH and every POP…a lot of traversing!
 BEST choice: we let top be the front of our list.

 So top will refer to the front of our list.
 Therefore:
 A push is simply inserting into the front of the linked
list!
 This is the easiest type of insertion
 It only requires changing two references!
 A pop would be deleting the front node
 Again, the easiest type of deletion
 Only requiring changing two references!
 So, in fact, a linked-list version of a stack is EASIER to
code than a regular stack!

 So each node will be an element of the stack
 Each node has a data value
 Each node also has a next
 We simply push (insert at front)
 And pop (delete the front node)

 So we will create two classes (like Linked-Lists)
 StackNode.java (this is like the LLnode class)
 StackLL.java (this is like the LinkedList class)
 We use most of the SAME methods as used for
the Linked List class
 However, we RESTRICT the functionality
 Now, we cannot insert anywhere in the list
 We can only insert at the top (head)
 Now, we cannot delete from anywhere in the list
 We can only delete from the top (head)

 Code for StackNode.java
public class StackNode {
private int data;
private StackNode next;
// CONSTRUCTORS
public StackNode() {
data = 0;
next = null;
}
public StackNode(int data) {
this.data = data;
next = null;
}
public StackNode(int data, StackNode next) {
this.data = data;
this.next = next;
}

...
// ACCESSORS
public int getData() {
return data;
}
public StackNode getNext() {
return next;
}
// MUTATORS
public void setData(int data) {
this.data = data;
}
public void setNext(StackNode next) {
this.next = next;
}
}

 Code for StackLL.java (similar to LinkedList.java)
public class StackLL {
// top: reference variable to the top
// of the stack (same as "head" of linked list)
private StackNode top;
// CONSTRUCTOR
public StackLL() {
top = null;
}
// MANY methods go here to control the stack
// POP, PUSH, TOP and more...

 isEmpty() method:
 How would you check if the stack is empty?
 Check if top is equal to null
 Similar to if head == null
//
// boolean | isEmpty()
//
public boolean isEmpty() {
return top == null;
}

 push() method:
// void | push(int)
public void push(int data) {
top = push(top, data);
}
// StackNode | push(StackNode, int)
private StackNode push(StackNode top, int data) {
// Make a new StackNode with "data" as the data value
// and set the "next" of this new node to the same address as top
// * This is the same as addToFront() method for Linked Lists.
top = new StackNode(data, top);
// Now, return the newly updated top.
return top;
}

 pop() method:
// StackNode | pop()
public StackNode pop() {
// Save a reference to the current top node
// because we will change where top points to
StackNode temp = top;
// Now, invoke the pop method with top as a parameter.
// This method will return a new top node.
top = pop(top);
// Finally, return temp, which is the previous top node
// that we just "popped" off the list.
return temp;
}

 pop() method:
//
// StackNode | pop(StackNode)
//
private StackNode pop(StackNode top) {
// Set top equal to the next node.
// This will make top point to the 2nd node instead
// of the first node.
top = top.getNext();
// return the address/reference of the new top node
return top;
}

 top() method:
//
// int | top()
//
public int top() {
// Invoke the top method with top as a parameter
int topValue = top(top);
// return topValue
return topValue;
}
//
// int | top(StackNode)
//
private int top(StackNode top) {
// Return the data value of the top node.
// You can see that we do NOT pop. We are only returning the data value.
return top.getData();
}

 The code shown here is only small pieces of the
code.
 Code is on Blackboard:
 You can also view a FULLY-FUNCITONAL Linked-list
Implementation of a Stack on Blackboard.

Poll: Exit Question

WASN’T
THAT
SPLENDID!

Daily Demotivator

stacks2

More Related Content

What's hot

Similar to stacks2

More from Mohamed Elsayed

Recently uploaded

stacks2