Homework 10: User-defined classes - the Stack class (object)

Introduction

This homework is intended to reinforce the following concept:

user-defined classes

Overview:

You will first implement a Stack class that can store strings
Then you will use the Stack class to write a method (that tests if an input String array is a "Palindrome sentence")

Preparation

Make directory and copy files:

mkdir ~/cs170/hw10 cp ~cs170002/share/hw10/*.java ~/cs170/hw10 cd ~/cs170/hw10

Stack

We have learned about a stack in this lecture: click here

Formal definition of a stack:

A stack is a data organizing structure where users can add and remove data items.
The data items added to a stack and removed from a stack follows the Last In First Out principle:

Operations defined on a stack: push and pop

The computer science lingo for adding an item into a stack is called the push operation.
The computer science lingo for deleting an item from a stack is called the pop operation.
Remember that the order is Last In First Out and this ordering must be ensured by the push and pop operations.
We must organize the information stored by the push operation in such a way that the pop operation always remove the last item stored by the push operation !!!

Implementing a Stack object (mostly a matter of organizing how to store things)

We can implement a Stack object with an array and a stack top index variable that contains the index of the top of the stack
Example:
Result:
The variable top contains the value −1 to indicate that there is no items inside the array A
(the first element in the array has index 0 and the value -1 is smaller than 0.)

The push operation (insert an item into the stack)

An item is inserted in the (next) position top+1 and afterward, the variable top is incremented by 1.

Example: push("Hello");

Suppose we push an item (say the string "Hello") to the stack.
We will need to do the following to the variables:
Result after pushing the string "Hello":
Notice that the variable top now contains the index 0, and the next item will be stored in the array position 1 (= top+1).
If we perform another push operation now (say push("World"); that add "World" to the stack), the variables will be updated to the following:
You can see that the input "World" is added after the previous item "Hello" and the variable top is again increased by 1.
The next item will now be entered in array position 2 (= top+1).

The pop operation (remove an item into the stack)

An item is removed from the stack top position top and afterward, the variable top is decremented by 1.
The removed item must be returned to the user
(BTW, that's the whole point of organizing information - what use is it to put data into a stack and not return the information when it is needed ?)

Example: pop();

Suppose we pop an item from the stack.
(BTW, the method pop() does not need any parameters, because the item that is removed is always the item at the top of the stack)

We will need to do the following to the variables:

Store the item A[top] in a variable help (this is the item we need to return to the user)
Afterward, decrement the variable top by 1 (this has the effect of removing the item A[top] from the stack).
Now return the item in the variable help to the user.

Result after pop the string "Hello":
Notice that the variable top now contains the index 0, and the item "World" is effectively removed.

Part 1: implement a Stack object with a Stack class definition

Implement the Stack that can store String data items.
Use the provided file Stack.java to do Part 1 of the assignment.
In other words:

What do you need to do:

Define instance variables (inside the file Stack.java) to let you store String data items accord to the Stack semantics (= first in last out).
To get some ideas what variables you will need to store the information, we have gone through this above. It is summaried in this picture:
Define a constructor method inside the Stack class that let you create a Stack object using the following syntax:
In other words, the constructor method must create the array that is used to store the Strings with the size given by the parameter !!!
Define a push(String x) method inside the Stack class that let us to push (add) String data items to a Stack object using the following syntax:
In other words: the push() method must add the given String to the stack storage. It must do it in a way that the add/delete order is LIFO (I described the "how" above; so read it again if it is not clear).
Define a String pop() method inside the Stack class that let us to pop (remove) String data items from a Stack object using the following syntax:
In other words: the pop() method must remove and return the last String that was put into the stack storage. (This is because the pop() method must realise an add/delete order that is LIFO. I described the "how" above; so read it again if it is not clear).
The variable out will contains the item removed from the stack by the pop() operation.
Define a int size() method inside the Stack class that returns the number of items stored inside the Stack object using the following syntax:
In other words: the size() method must tell us how many items are in the stack.
Hint: you can use the location of the stack top to determine how many items are in the stack.
Define the String toString() method that let us print out the content of Stack object.
All values stored inside the stack object are returned as one String.

Test programs for Part 1

I suggest you implement the Stack class in the following piecemeal manner:

Define the instance variables
Write the push() method
Write the size() method
Write the toString() method
After this, you can use the TestStack1.java to test your Stack
Write the pop() method
After this, you can use the TestStack2.java and TestStack3.java to test your Stack

I have included 2 test programs to help you debug the Stack.java program in a piecemeal fashion.

The Java program TestStack1.java will test the push() operation (but the stack must also have the correct instance variables and toString() method for this program work correctly)
The correct output of TestStack1.java is:

The Java program TestStack2.java will test the push() and the pop() operations

The correct output of TestStack2.java is:

javac TestStack2.java java TestStack2 ======== correct output is: =========== 3 s.size() = 1 3 + 2 s.size() = 3 3 + 2 - 1 s.size() = 5 1 - 2 + 3

The Java program TestStack3.java is not a test program, but a "cool" application that uses a stack to evaluate a a Reverse Polish expression

The Reverse Polish notation of an arithmetic expression put the operands first and the operation last.
E.g.: 1 2 + means: add 1 and 2
E.g.: 2 3 4 + x means:

If your Stack.java is implemented correctly, you can execute the test program as follows:

>> javac RecPolish.java >> java RecPolish 1 2 + Next item = 1 Stack = 1 ---------------------------------------------- Next item = 2 Stack = 1 2 ---------------------------------------------- Next item = + Stack = 3.0 ---------------------------------------------- 3.0

Note:

The texts in brown color are the strings that were returned by the toString() method for the content of the String object

And:

>> java hw9 2 3 4 + x Next item = 2 Stack = 2 ---------------------------------------------- Next item = 3 Stack = 2 3 ---------------------------------------------- Next item = 4 Stack = 2 3 4 ---------------------------------------------- Next item = + Stack = 2 7.0 ---------------------------------------------- Next item = x Stack = 14.0 ---------------------------------------------- 14.0

If you like, you can examine the RevPolish.java code and see how a reverse polish expression is evaluated using your Stack object (it will be very educational).

Part 2: using the Stack class

In part 2 of this homework, you will write a method to check if a sequence of words stored in a String array is a "palindomic" sentence:

What is a "palindomic" sentence:

A "palindomic" sentence is a sentence where:

the first word in the sentence is equal to the last word in the sentence
the second word in the sentence is equal to the one before the last word in the sentence
and so on...

Examples:

ab bc de de bc ab ab bc de xyz de bc ab

Representing the words in a sentence:

The words of a sentence are stored in a String array

Example:

Sentence: ab bc de de bc ab Represented as follows: String[] x; x = new String[6]; x[0] = "ab"; x[1] = "bc"; x[2] = "de"; x[3] = "de"; x[4] = "bc"; x[5] = "ab";

Assignment

Write the method isPalinSentence(String[] s) that receives a String array representing the words in a sentence, and returns:
- true if the sentence is a "palindromic" sentence
- false otherwise
The method must use of a Stack to perform its task
(You did a previous homework where you used a loop to complete this assignment, but the point of this homework is to reinforce the concept of classes. So you don't get any credit if you do not use a Stack)
The algorithm is described below.

Use the file PalinSentence.java for part 2 of this homework.

Algorithm description: (assuming that the input is the sentence "ab bc de de bc ab")

1. Create a Stack with size equal to the half of the size of the input String array (in this example: 6/2 = 3) 2. Push the first half of the words in the String array onto the stack. You will have a stack with the following content: +--------+ | de | <---- top +--------+ | bc | +--------+ | ab | +--------+ 3. Now compare the second half of the sentence (highlighted in red): "ab bc de de bc ab" with the first half of the sentence that is stored in the stack - one word at a time: s.pop() ---> de matches 1st word in second half of sentence s.pop() ---> bc matches 2nd word in second half of sentence s.pop() ---> ab matches 3rd word in second half of sentence If you find one mismatch return false immediately If you match all words stored in the stack, the sentence is "palindromic" and you return true Note: make sure to skip the middle word in the matching process when the sentence has an odd number of words. Note: the number of words in the sentence is the length of the array (You should know how to get the length of an array) Note: the number of items in the stack is returned by the size() method in the Stack class.

Checking whether 2 strings are equal:

We may not have yet covered how to test whether 2 strings are equal which you will need to use to write isPalinSentence()
If s1 and s2 are 2 strings, then:
will return true is the strings s1 and s2 are equal, and will return false otherwise.

Example:

public class Demo { public static void main(String[] args) { String s1 = "abc", s2 = "def", s3 = "abc"; if ( s1.equals ( s2 ) ) System.out.println("equal"); else System.out.println("not equal"); if ( s1.equals ( s3 ) ) System.out.println("equal"); else System.out.println("not equal"); } }

Warning:

Turnin

Turn in your Stack.java and PalinSentence.java program files as follows:

cd ~/cs170/hw10 /home/cs170002/turnin-hw Stack.java hw10 /home/cs170002/turnin-hw PalinSentence.java hw10a