CSE143X Notes for Wednesday, 11/25/20

In computer science, two of the most fundamental ADTs are called stacks and queues. They are so simple that they almost seem not worth studying. They are like the programming equivalent of drawers and shelves. Drawers and shelves are very simple and, therefore, sort of boring, and yet we find uses for them everywhere we turn.

It is useful to study stacks and queues as a way to understand a minimal kind of data structure. We'll find, for example, that they are less powerful than the list structures we have been looking at. But we often find ourselves wanting to think in terms of the simplest possible solution to a problem, as in, "You could solve that with a stack."

Like lists, stacks and queues store an ordered sequence of values. A minimal set of operations for such a structure would require at least:

These three operations are the bare bones that you'd need for such a structure and in their purest form, stacks and queues have just these three operations. I have put together a version of these that also includes a size method that lets you ask for the number of elements in the structure.

Stacks and queues are similar in that they each store a sequence of values in a particular order. But stacks are what we call LIFO structures while queues are FIFO structures:

        stacks        queues

        L-ast         F-irst
        I-n           I-n
        F-irst        F-irst
        O-ut          O-ut
The analogy for stacks is to think of a cafeteria and how trays are stacked up. When you go to get a tray, you take the one on the top of the stack. You don't bother to try to get the one on the bottom, because you'd have to move a lot of trays to get to it. Similarly if someone brings clean trays to add to the stack, they are added on the top rather than on the bottom. The result is that stacks tend to reverse things. Each new value goes to the top of the stack, and when we take them back out, we draw from the top, so they come back out in reverse order.

The analogy for queues is to think about standing in line at the grocery store. As new people arrive, they are told to go to the back of the line. When the store is ready to help another customer, the person at the front of the line is helped. In fact, the British use the word "queue" the way we use the word "line" telling people to "queue up" or to "go to the back of the queue".

In the case of a stack, the adding operation is called "push" and the removing operation is called "pop". All operations occur at one end of the stack, at the top. We push values onto the top and we pop them off the top. There is also a method for testing whether the stack is empty and an operation for requesting the current size of the stack. So for a Stack<E>, the basic operations are:

        public void push(E value);
        public E pop();
        public boolean isEmpty();
        public int size();
Notice that we are using Java generics to define the Stack in terms of an unspecified element type E. That way we'll be able to have a Stack<String> or Stack<Integer> or a Stack of any other kind of element type we are interested in.

For queues, we have a corresponding set of operations but they have different names. The operations for a Queue<E> are:

        public void add(E value);
        public E remove();
        public boolean isEmpty();
        public int size();
The collections framework does the right thing in terms of Queue<E> by making it an interface. The implementation we will be using for actual objects is LinkedList<E>. The stack version is much older and was not done as well. In particular, Stack<E> is a class, not an interface.

I first showed this client code:

        import java.util.*;
        
        public class StackQueue1 {
            public static void main(String[] args) {
                Queue<String> q = new LinkedList<>();
                Stack<String> s = new Stack<>();
        
                String[] data = {"four", "score", "and", "seven", "years", "ago"};
                for (String str : data) {
                    s.push(str);
                    q.add(str);
                }
        
                System.out.println("stack = " + s);
                while (!s.isEmpty())
                    System.out.println(s.pop());
        
                System.out.println("queue = " + q);
                while (!q.isEmpty())
                    System.out.println(q.remove());
            }
        }
It produces the following output:

        stack = [four, score, and, seven, years, ago]
        ago
        years
        seven
        and
        score
        four
        queue = [four, score, and, seven, years, ago]
        four
        score
        and
        seven
        years
        ago
Notice that the output for the stack lists it starting with the value at the bottom of the stack. The value at the end of the list ("ago") is at the top of the stack and that's why it is the first value popped from the stack. As you would expect, the queue lists the values in order starting at the front of the queue ("four").

Then we looked at some typical operations on a stack and queue of integers. We looked at the following methods that can be used to transfer values from a queue to a stack or from a stack to a queue:

        public static void queueToStack(Queue<Integer> q, Stack<Integer> s) {
            while (!q.isEmpty()) {
                int n = q.remove();
	        s.push(n);
	    }
        }

        public static void stackToQueue(Stack<Integer> s, Queue<Integer> q) {
            while (!s.isEmpty()) {
                int n = s.pop();
	        q.add(n);
	    }
        }
Then I asked people how we could write a method that would find the sum of the values in a queue. It is a cumulative sum task, which involves initializing a sum variable to 0 outside the loop and then adding each value to the sum as we progress through the loop. Our first attempt looked like this:

        public static int sum(Queue<Integer> q) {
            int sum = 0;
            while (!q.isEmpty()) {
                int n = q.remove();
                sum += n;
            }
            return sum;
        }
When we called the method from main and printed the queue afterwards, we found that the queue is empty. As a side effect of calculating the sum, we destroyed the contents of the queue. This is generally not acceptable behavior.

Unfortunately, queues don't give us any peeking operations. We have no choice but to take things out of the queue. But we can restore the queue to its original form. How? Someone suggested using a second queue. That would work, but there is an easier way. Why not use the queue itself? As we remove values to be processed, we re-add them at the end of the list. Of course, then the queue never becomes empty. So instead of a while loop looking for an empty queue, we wrote a for loop using the size of the queue:

        public static int sum(Queue<Integer> q) {
            int sum = 0;
            for (int i = 0; i < q.size(); i++) {
                int n = q.remove();
                sum += n;
                q.add(n);
            }
            return sum;
        }
By printing the queue before and after a call on sum, we were able to verify that our new version preserved the queue.

I then said I wanted to consider a variation of the sum method for stacks:

        public static int sum(Stack<Integer> s) {
            ...
        }
This method can also be called sum because the two methods have different signatures. Remember that a signature of a method is its name plus its parameters. These are both called sum and they both have just a single parameter, but the parameter types are different, so this is okay. This is called overloading a method and it is a common technique in Java.

So how do we write the sum method for stacks? At first I simply substituted stack operations for queue operations:

        int sum = 0;
        for (int i = 0; i < s.size(); i++) {
            int n = s.pop();
            sum += n;
            s.push(n);
        }
        return sum;
Unfortunately, this code didn't work. We saw output like this when we tested it from main:

        stack = [42, 19, 78, 87, 14, 41, 57, 25, 96, 85]
        sum = 850
The sum of these numbers is not 850. We're getting that sum because the loop pops the value 85 off the stack 10 different times and then pushes it back onto the top of the stack. With a queue, values go in at one end and come out the other end. But with a stack, all the action is at one end of the structure (the top). So this approach isn't going to work.

In fact, you can't solve this in a simple way with just a stack. You'd need something extra like an auxiliary structure. I said to consider how we could solve it if we had a queue available as auxiliary storage. Then we can put things into the queue as we take them out of the stack and after we have computed the sum, we can transfer things from the queue back to the stack using our queueToStack method:

        int sum = 0;
        Queue<Integer> q = new LinkedList<>();
        for (int i = 0; i < s.size(); i++) {
            int n = s.pop();
            sum += n;
            q.add(n);
        }
	queueToStack(q, s);
        return sum;
This also didn't work. Here is a sample execution:

        initial stack = [32, 15, 54, 91, 47, 45, 88, 89, 13, 0]
        sum = 235
        after sum stack = [32, 15, 54, 91, 47, 0, 13, 89, 88, 45]
There are two problems here. Only half of the values were removed from the stack and those values now appear in reverse order. Why only half? We are using a for loop that compares a variable i against the size of the stack. The variable i is going up by one while the size is going down by one every time. The result is that halfway through the process, i is large enough relative to size to stop the loop. This is a case where we want a while loop instead of a for loop:

        int sum = 0;
        Queue<Integer> q = new LinkedList<>();
        while (!s.isEmpty()) {
            int n = s.pop();
            sum += n;
            q.add(n);
        }
	queueToStack(q, s);
        return sum;
Even this is not correct. It finds the right sum, but it ends up reversing the values in the stack. Some people said, "Then why don't you use a stack for auxiliary storage?" That would solve the problem, but one of the things we are testing is whether you can figure out how to solve a problem like this given a certain set of tools. In this case, you are given auxiliary storage in the form of a queue.

The problem is that by transferring the data from the stack into the queue and then back into the stack, we have reversed the order. The fix is to do it again so that it goes back to the original. So we add two extra calls at the end of the method that move values from the stack back into the queue and then from the queue back into the stack:

        public static int sum(Stack<Integer> s) {
            int sum = 0;
            Queue<Integer> q = new LinkedList<>();
            while (!s.isEmpty()) {
                int n = s.pop();
                sum += n;
                q.add(n);
            }
	    queueToStack(q, s);
	    stackToQueue(s, q);
	    queueToStack(q, s);
            return sum;
        }
Then I turned to a new topic. I said that I wanted to explore how to design a set of classes for storing information about various shapes like rectangles, circles and squares. I started with these three classes:

        public class Circle {
            private double radius;
        
            public Circle(double radius) {
                this.radius = radius;
            }
        
            public double area() {
                return Math.PI * radius * radius;
            }
        
            public String toString() {
                return "circle of area " + area();
            }
        }

        public class Rectangle {
            private double length;
            private double width;
                
            public Rectangle(double length, double  width) {
                this.length = length;
                this.width = width;
            }
                
            public double area() {
                return length * width;
            }
                
            public String toString() {
                return "rectangle of area " + area();
            }
        }
        
        public class Square {
            private double length;
        
            public Square(double length) {
                this.length = length;
            }
        
            public double area() {
                return length * length;
            }
        
            public String toString() {
                return "square of area " + area();
            }
        }
If we were designing a complete system, we would probably have more than just an area and toString method for these, but this set of operations will be enough to explore the design issues involved. I showed the following client program that sets up an array of shapes and that attempts to sort them by calling the built-in Arrays.sort method:

        import java.util.*;

        public class ShapeTest {
            public static void main(String[] args) {
                Object[] data = {new Square(12), new Rectangle(15, 3.2),
                                 new Circle(8.4), new Circle(1.5), new Square(8.7),
                                 new Rectangle(7.2, 3.2), new Square(2.4),
                                 new Circle(3.7), new Circle(7.9)};
                for (Object s : data) {
                    System.out.println(s);
                }
                System.out.println();
                Arrays.sort(data);
                for (Object s : data) {
                    System.out.println(s);
                }
            }
        }
The array stores a combination of Circle, Square and Rectangle objects, which is why we had to declare it to be of type Object[]. The client code uses a foreach loop to print the shapes before and after the call on Arrays.sort:

       for (Object s : data) {
            System.out.println(s);
       }
When we executed this program, it properly printed the various shapes but then it reached an execution error when we called Arrays.sort. The error message reported was ClassCastException for the Square class. The problem is that we never had our shape classes implement the Comparable interface. So we opened up the Square class and tried to figure out how to make it implement Comparable.

First we had to change its header:

        public class Square implements Comparable<Square> {
            ...
        }
Then we had to think about how to write an appropriate compareTo method. It's a bit tricky because it involves the difference of two doubles. So we can't just say:

        public int compareTo(Square other) {
            return area() - other.area();
        }
We could cast to an int, but even that doesn't work:

        public int compareTo(Square other) {
            return (int) (area() - other.area());
        }
This returns an int, but it returns the wrong value when the difference is something like 0.5 or -0.3, both of which would be turned to 0 when you cast to int. Instead we need a 3-way comparison:

        public int compareTo(Square other) {
            double difference = area() - other.area();
            if (difference < 0) {
                return -1;
            } else if (difference == 0) {
                return 0;
            } else { // difference > 0
                return 1;
            }
        }
We tried compiling with this definition and we ran the client program again. It failed again, but this time it failed on a ClassCastException on Rectangle. That's because we only modified the Square class, not the Rectangle class. We discussed the possibility of copying the compareTo method to those other classes, but someone pointed out a problem with our definition. We have defined a compareTo method that allows a Square to compare itself to another Square, but we need one that allows a Square to compare itself to any shape, including a Circle or Rectangle.

Someone suggested that we could have a Shape interface that they all implement:

        public interface Shape {

        }
We then modified our Square class header and the compareTo method:

        public class Square implements Comparable<Shape> {
            ...

            public int compareTo(Shape other) {
                double difference = area() - other.area();
                if (difference < 0) {
                    return -1;
                } else if (difference == 0) {
                    return 0;
                } else { // difference > 0
                    return 1;
                }
            }
        }
But this code didn't compile. We got a complaint that it couldn't find the method area(). This seemed odd, because each of the three classes has an area method. But remember from our discussion about inheritance that Java has a notion of a "role". The Shape role does not include an area method unless we specifically say that it does.
        public interface Shape {
            public double area();
        }
With this change, the Square class compiled properly. Then I said that we want to copy whatever pattern we use for the Square class in each of the other classes. But before we went to do that, I wanted to make sure that we had the right pattern. So again looked closely at the Square class:

        public class Square implements Comparable<Shape> {
            private double length;
        
            public Square(double length) {
                this.length = length;
            }
        
            public double area() {
                return length * length;
            }
        
            public String toString() {
                return "square of area " + area();
            }
        
            public int compareTo(Shape other) {
                double difference = area() - other.area();
                if (difference < 0) {
                    return -1;
                } else if (difference == 0) {
                    return 0;
                } else { // difference > 0
                    return 1;
                }
            }
        }
I said that we're missing a key ingredient. Someone mentioned that we never established the "is a" relationship to say that a Square is a Shape. So we had to modify the header to indicate that:

        public class Square implements Shape, Comparable<Shape> {
            ...
        }
We could have repeated this pattern in each of the other classes, but it seems somewhat redundant to always have to say that a class implements both Shape and Comparable<Shape>. And we don't want to have some Shape classes that fail to implement the Comparable interface. Java provides us a nice alternative. We can elevate this restriction to the Shape interface itself:
        public interface Shape extends Comparable<Shape> {
            public double area();
        }
It may seem odd that use the keyword "extends" rather than the keyword "implements." That's because in this case we have an interface extending another interface and in Java you specify that with the keyword "extends" rather than the keyword "implements."

This allowed us to simplify the Square class header:

        public class Square implements Shape {
            ...
        }
We then changed each of the different shape classes to say that they implement this interface:

        public class Circle implements Shape {
            ...
        }

        public class Rectangle implements Shape {
            ...
        }

        public class Square implements Shape {
            ...
        }
With this change, we were able to compile the Square class. We then copied the compareTo method to the other two classes and compiled them. This allowed the client program to run properly, producing this output:

        square of area 144.0
        rectangle of area 48.0
        circle of area 221.6707776372958
        circle of area 7.0685834705770345
        square of area 75.68999999999998
        rectangle of area 23.040000000000003
        square of area 5.76
        circle of area 43.00840342764427
        circle of area 196.066797510539
        
        square of area 5.76
        circle of area 7.0685834705770345
        rectangle of area 23.040000000000003
        circle of area 43.00840342764427
        rectangle of area 48.0
        square of area 75.68999999999998
        square of area 144.0
        circle of area 196.066797510539
        circle of area 221.6707776372958
The program correctly sorts the shapes into increasing area. In fact, given the new Shape interface we were able to rewrite the main program to replace "Object" with "Shape":

        Shape[] data = {new Square(12), new Rectangle(15, 3.2),
                        new Circle(8.4), new Circle(1.5), new Square(8.7),
                        new Rectangle(7.2, 3.2), new Square(2.4),
                        new Circle(3.7), new Circle(7.9)};
        for (Shape s : data) {
            System.out.println(s);
        }
        System.out.println();
        Arrays.sort(data);
        for (Shape s : data) {
            System.out.println(s);
        }
But this still wasn't very satisfying because we have three copies of the compareTo method, one in each of the different shape classes. This kind of redundancy is a bad idea. When we first talked about inheritance, we talked about the idea of having a 20-page employee manual that is shared across all types of employees. We want something like that here.

Someone suggested that we change the Shape interface to a class and move the method there:

        public class Shape implements Comparable<Shape> {
            public double area();

            public int compareTo(Shape other) {
                double difference = area() - other.area();
                if (difference < 0) {
                    return -1;
                } else if (difference == 0) {
                    return 0;
                } else { // difference > 0
                    return 1;
                }
            }
        }
Unfortunately, this didn't compile. It produced the following error message:

        Error: missing method body, or declare abstract
The problem is with the area method. Currently we just have a semicolon rather than a body defining what it should do. But the definitions of the area methods are in the various shape classes (Circle, Square, Rectangle). Someone suggested deleting it from the class, but then it didn't compile because the compareTo method calls area. So we have to define it here in some way.

We considered the possibility of giving it a "dummy" definition just to make it compile:

        public double area() {
            return 42.42;
        }
We just made up a number for it to return. This allowed us to compile the Shape class, but it's not a good idea. It means that someone might extend the Shape class and inherit this strange version of the area method. It's better to leave the shape method unspecified, the way it was with the interface.

Someone pointed out that the original error message seemed to be giving us a suggestion. It said that we could declare it to be "abstract". The keyword "abstract" is a modifier that can be applied to methods and classes like the keywords "public" and "static", so we just added this extra modifier to the method header:

        public class Shape implements Comparable<Shape> {
            public abstract double area();

            public int compareTo(Shape other) {
                ...
            }
        }
That also didn't work. The compiler pointed at the class header and said, "Shape is not abstract and does not override abstract method area() in Shape." In other words, the compiler is saying that if you are going to have an abstract method called area in the Shape class, then the class itself has to be declared abstract:

        public abstract class Shape implements Comparable<Shape> {
            public abstract double area();

            public int compareTo(Shape other) {
                ...
            }
        }
After this change the class finally compiled. We then had to change the individual shape classes to say that they extend this class rather than implementing an interface called Shape.

At last we had arrived at the name of the topic for the lecture: abstract classes. We've seen two extremes in Java. A "normal" class (often called a concrete class) is one where every method has a definition. An interface is like a purely abstract class where every method is abstract. In other words, in an interface we list only method headers (methods that need to be filled in). An abstract class sits somewhere in the middle, typically having some methods that are filled in and some methods that are abstract. You can think of this as a spectrum from concrete to purely abstract, with abstract classes in the middle:

concrete <---+-----------------------+------------------------+----> abstract
             |                       |                        |
      concrete class          abstract class              interface
Because the Shape class is an abstract class, it can't be directly instantiated, as in:

        Shape s = new Shape();  // illegal
You aren't allowed to create instances of an abstract class. But that doesn't mean you can't have variables of type Shape, as in:

        Shape s = new Rectangle(20, 30);  // legal
I mentioned that this is similar to the way that we use the word "Employee". We know that everyone who works for a company is in some sense an employee, but you wouldn't find someone who is just an employee. If you ask someone, "What do you do?" they won't answer, "I'm an employee." If they did, you'd say, "I know, but what do you do?" The word "employee" is like an abstract class. It is a useful concept in creating our hierarchies and it's useful to talk about people as employees, but there aren't any people who are actually just plain employees.

In the last few minutes of class I pointed out that there was still some redundancy between these three classes. They each have a toString method that is very similar, as in the Circle class version:

       public String toString() {
           return "circle of area " + area();
       }
The only difference between the three versions is the name of the shape. We talked about how to move this up into the Shape class. To do so, we need a new field to keep track of the name of the shape:

        public String toString() {
            return name + " of area " + area();
        }
We modified the Shape class to have this as a field that is set by a call on a Shape class constructor:

        public abstract class Shape implements Comparable<Shape> {
            private String name;
        
            public Shape(String name) {
                this.name = name;
            }

            ...        
        }
This required us to include calls on the "super" constructor in each of our Shape classes, as in this version for Circle:

        public Circle(double radius) {
            super("circle");
            this.radius = radius;
        }
I briefly mentioned one last detail. You can include the access modifier "final" to a method or class to prevent it from being overridden through inheritance. The final version of the Shape class makes both the compareTo and toString methods final, which means that subclasses can't override this shared behavior of shape objects. This can be useful to prevent malicious or careless errors. For example, you wouldn't want to have most of your shape objects comparing themselves in one way while some others are comparing in some other way. You also wouldn't want to let a shape subclass modify the toString method because then it could masquerade as something other than what it is.


Stuart Reges
Last modified: Wed Nov 25 10:57:51 PST 2020