Lab 9: Working with stacks and queues

The goal of this lab is to write several small programs that make use of stacks and/or queues.

You will be using Java's Stack class, Queue interface, and LinkedList class. (LinkedList implements Queue).

To set up, make a directory for this lab and copy files from the course directory.

cp -r /homes/tvandrun/Public/cs245/lab9/* .

1. Grouping consistency

You have probably noticed that a text editor like xemacs highlights text between grouping symbols-- () {} [] or < >-- if they match and are properly nested. In this exercise, you will write a program which takes a string from the command line and determines whether or not it is properly nested with respect to these four grouping symbol pairs. Open the file Exercise1.java.

For example, the line "( a ( {b & 6 } [ 1 t ^] ~ ) )" is properly nested; "( a ( {b & 6 ) [ 1 t ^] ~ ) }" is not. You may use the Java library Stack class. (One thing to note: it calls the "top" operation peek().) Since some of those grouping symbols have special meaning in the command line, you will have to include them in quotes when you run your program, for example

java Exercise1 "( a ( {b & 6 } [ 1 t ^] ~ ) )"

Your program may simply print "yes" or "no" to the screen. Hint: The Stack class is generic, and you'll probably want to use the Character wrapper type as its type parameter.

2. Conversion from infix to RPN

You learned about reverse Polish notation in the pre-lab reading. In this exercise you will write a program which takes a string (of numbers, parentheses, and arithmetic operators--no other characters, even spaces) from the command line assumed to be in infix form and, using a stack, converts it to RPN. Open the file Exercise2.java.

You may assume that the input is fully parenthesized, and that it does not contain any errors. For example,

java Exercise2 "((5*27)/(2+(3-8)))"

should print out

5 27 * 2 3 8 - + /

Note that your output, on the other hand, should contain spaces.

Hint. This is how you should organize your thoughts. Your program, like exercise 1, will primarily be a loop over the input string. Each character is one of four things: a digit, an operand, a left parenthesis, and a right parenthesis. Before doing anything, first figure out what should be done in each of these four scenarios.

3. Computing capital gains

When a person makes a profit on a purchase and eventual sale of a stock, he or she must pay taxes on the "capital gain", that is, the profit. (A capital loss can be used as a tax deduction.) However, sometimes a person purchases and sells shares of a stock over several transactions, and the capital gain depends on the interpretation of which shares were bought or sold. For example, suppose a person had the following transactions for stock of a certain company:

The total profit is (2437.50 + 10321.50) - (3000 + 3750 + 3200) = 5509. However, if a year ended after the third transaction (the first sale), then capital gains tax needed to be paid on the gain so far. But where did the 750 shares come from-- the original 1000 or the later 1500?

The standard way to compute capital gains is on a first-come-first-serve basis. Hence the 750 shares comes out of the original 1000 shares, and their original price (their basis) is 2250, and so the capital gain was 187.5. If this person then sold another 750 shares the next year without buying any more, then 250 of those shares would be the remaing shares from the original purchase, and the other 500 would come from the 1500 bought in the second purchase. If sold at $3.50 per share, this would be a capital gain of (750 * 3.50) - (250 * 3 + 500 * 2.5) = 2625 - 2000 = 625.

This will be implemented using the given classes Transaction and Transactor. Transaction is a simple value class--it even has public final instance variables instead of getters. It represents a transaction: a number of shares and a price per share. The class Transactor has a public static method nextTransaction() that returns the results of a transaction using a Transaction object.

You will write a program that repeatedly calls Transactor.nextTransaction() until there are no shares left. Open and complete the file Exercise3.java. (Note that in the example above I used dollars and cents (ie, $2437.50); Exercise3 uses only integer values, so you can interpret them as whole dollars or as cents, whatever.)

The Transactor class is written so that the first transaction is a purchase, and that after about 25 transactions it will sell all remaining shares.

Use an instance (or two) of java.util.LinkedList (as java.util.Queue) to compute capital gains (or loss).

4. (Time permitting) Implementing queues with an array

In class we have worked out how to implement a stack using an array. Tomorrow we plan to work out (in this order) a list implementation of stacks, a list implementation of queues, and an array implementation of queues.

I'm confident that with enough time you would be able to work out the list implementations of stacks and queues simply using what you already understand about lists. Using an array to implement a queue is a little harder.

See what progress you can make in ArrayQueue.java


Thomas VanDrunen
Last modified: Thu Oct 24 12:47:30 CDT 2013