Status

• Exam 1 to be returned Wed (75 * 6 = 450 pages of grading...)
• A04 and Quiz 05 due Wed
  • Hopefully you have the constructor and toString() method written by this point...

Discussion 02: Good Code

• Had 6 student submissions to look at. What makes one more readable or maintainable than others?
• Top-picks:

  	P1	P2	P3	P4	P5	P6
  Readable	9	3	0	0	2	32
  Maintainable	6	3	2	1	2	28

• Comments:
  • Readable because: modular design, descriptive variable names, /** javadoc */, //internal comments, good use of CONSTANTS, nicely indented, not so many blank lines (ie, coding standards!)
  • simple, concise, clever, elegant
  • but: "complicated, although shortest" (so beware "code golfing")
  • broke the problem down (abstraction); short main
• Preferences may vary somewhat, but consider what others will say about your code
  • Larry Wall's 3 programmer virtues
• What about efficiency and other factors?
  • If it's simple, clear, and modular, you can refactor it to make it more efficient
  • If the code is a mess, no one will want to touch it

Array-based stack implementation

• ADT: a data type defined in terms of behavior, with hidden implementation details
• From last time: an array-based Stack implementation.
• Big-Os:
  • push - usually O(1), but O(n) when array copy required
  • peek - O(1)
  • pop - O(1)
  • size - O(1)

Arrays as data structure

Primary advantage

• Fast! Random access: given an index, O(1) access to elements (get or set)

Disadvantages

• Limited space
  • (usually a disadvantage, but not always)
  • Can be overcome by copying over array into a new one, but this requires 1) O(n) operation and 2) ~double space during copy
• Wasted space: all those empty cells take up memory in heap
• Expensive to insert into middle of array; need to shift: O(n)

Concept: linked list data structure

• A linked chain of "nodes"
• Each node contains 1 data element and a reference to next node in the chain
  • a reference-based data structure
  • important to understand the reference part
• Keep a reference to first node (much like one reference to whole array)
• (Example)
• Overcomes all of array's disadvantages

Simplest possible node class

public class Node {
  public String data;
  public Node next;
}

Building a list

  String[] names = {"Alice", "Bob", "Carol", "Doug"};
  Node head = new Node();
  head.data = names[0];
  Node current = head;
  for (int i = 1; i < names.length; i++) {
    current.next = new Node();
    current = current.next;
    current.data = names[i];
    current.next = null;     //not really necessary
  }

  //at this point, head points to the start of the list
  for (Node n = head; n != null; n = n.next) {
    System.out.print(n.data + " ");
  }
  System.out.println();  

Exercise

//weird contrived example
Node one;
one = new Node();
Node two = new Node();
Node three = new Node();
one.next = two;
three.next = two;
one.data = "Albert";
three.data = one.data;
two.data = "Bianca";
three.data = "Calvin";
Node head = three; 

for (Node n = head; n != null; n = n.next) {
  System.out.println(n.data);
}

• Draw the node structure that results
• What will the code print?

Calvin 
Bianca

A real Node class (with encapulsation)

public class Node {

  private String data;
  private Node next;
    
  public Node(String data, Node next) {
    this.data = data;
    this.next = next;
  }
  
  public Node(String data) {
    this(data, null);
  }
  
  public String getData() {
    return data;
  }
  
  public void setData(String data) {
    this.data = data;
  }
  
  public Node getNext() {
    return next;
  }
  
  public void setNext(Node next) {
    this.next = next;
  }
}

Using revised Node class

  String[] names = {"Alice", "Bob", "Carol", "Doug"};
  Node head = new Node(names[0]);
  Node current = head;
  for (int i = 1; i < names.length; i++) {
    current.setNext(new Node(names[i]));
    current = current.getNext();
  }

  //at this point, head points to the start of the list
  for (Node n = head; n != null; n = n.getNext()) {
    System.out.print(n.getData() + " ");
  }
  System.out.println();

Although Node is encapsulated, resulting linked list structure is not.

Exercise

//another strange example
Node head = new Node("Albert");
Node sub = new Node("Bianca", head);
head = sub;
head = new Node("Calvin", head);
head = new Node("Dale");
head.setNext(sub);

for (Node n = head; n != null; n = n.getNext()) {
  System.out.println(n.getData());
}

• Draw the node structure that results
• What will the code print?

Dale
Bianca
Albert

Node-based stack implementation (1/6)

Instance variables:

  private Node top;

Node-based stack implementation (2/6)

Constructor:

  public Stack() {
    this.top = null;
  }

• Only need a Node when we have data to put in it
• (Could technically skip this constructor)

Node-based stack implementation (3/6)

  public void push(String item) {
    this.top = new Node(item, top);
  }  

• Woah! Tricky one liner. Don't we need some if statements here or something?
• Big-O?

Node-based stack implementation (4/6)

  public String peek() {
    if (this.top == null) {
      throw new IllegalStateException("Can't peek() into empty stack.");
    }
    return this.top.getData();
  }  

• Peek, which is conceptually simpler than push, actually needs more code.
• Big-O?

Node-based stack implementation (5/6)

  public String pop() {
    if (this.top == null) {
      throw new IllegalStateException("Can't pop() from empty stack.");
    }
    String data = this.top.getData();
    this.top = this.top.getNext();
    return data;
  }  

• Big-O?

Node-based stack implementation (6/6)

  public int size() {
    int size = 0;
    Node curr = this.top;
    while (curr != null) {
      size++;
      curr = curr.getNext();
    }
    return size;
  }  

• Why do I need curr?
• Big-O?
• Alternative approach?

Sidenote: for vs while loop

  public int size() {
    int size = 0;
    Node curr = this.top;
    while (curr != null) {
      size++;
      curr = curr.getNext();
    }
    return size;
  }  

  public int size() {
    int size = 0;
    for (Node curr = this.top; curr != null; curr = curr.getNext()) {
      size++;
    }
    return size;
  }  

Is this clearer? Maybe, maybe not.

  public int size() {    
    int size;
    Node curr;
    for (size = 0, curr = this.top; curr != null; size++, curr = curr.getNext());
    return size;
  }  

Amusing to move all code out of the loop body, but this is not clearer.

Complete node-based stack implementation

Now with efficient size tracking, so all operations O(1)

public class Stack {

  private Node top;
  private int size;

  public Stack() {
    this.top = null;
    this.size = 0;
  }

  public void push(String item) {
    this.top = new Node(item, top);
    this.size++;
  }  

  public String peek() {
    if (this.top == null) {
      throw new IllegalStateException("Can't peek() into empty stack.");
    }
    return this.top.getData();
  }
  
  public String pop() {
    if (this.top == null) {
      throw new IllegalStateException("Can't pop() from empty stack.");
    }
    String data = this.top.getData();
    this.top = this.top.getNext();
    this.size--;
    return data;
  }  

  public int size() {
    return this.size;
  }  
}

Stack ADT

• Thanks to encapsulation, code that uses stack has no idea we just switched implementations
• Previous code still compiles and works as always

Problem

Nodes and Stack only work with String:

public class Node {

  private String data;
  private Node next;
  
  //...

• What if we want to have a stack of ints, doubles, ArrayLists, Files, etc.?
• Definitely don't want to write a separate Node and Stack class for each data type!
• Could write them for Object, then cast (we'll revisit this idea in a couple weeks)
  • Old way, though both troublesome and error-prone
• Best option: If we could specify the data type like a parameter... Generics!

Declare the type parameter

public class Node<E> {

• Convention is single capital letter: E - element, T - type, K - key, V - value, etc.
• Variables should start with lowercase, and classes should never be a single letter, so type parameters are obvious
• Here, node contains a single data element, so we use E
• E is part of Node now: whenever you refer to a Node object, you must give the type of its element too

Generic Node

• Use E in place of element's type
• Also need to change any Node to Node<E>

public class Node<E> {

  private E data;
  private Node<E> next;
    
  public Node(E data, Node<E> next) {
    this.data = data;
    this.next = next;
  }
  
  public Node(E data) {
    this(data, null);
  }
  
  public E getData() {
    return data;
  }
  
  public void setData(E data) {
    this.data = data;
  }
  
  public Node<E> getNext() {
    return next;
  }
  
  public void setNext(Node<E> next) {
    this.next = next;
  }
}

Using the generic Node class

Specify the element type of each Node ("String Node" vs "Integer Node").

  String[] names = {"Alice", "Bob", "Carol", "Doug"};
  Node<String> head = new Node<String>(names[0]);
  Node<String> current = head;
  for (int i = 1; i < names.length; i++) {
    current.setNext(new Node<String>(names[i]));
    current = current.getNext();
  }

  //at this point, head points to the start of the list
  for (Node<String> n = head; n != null; n = n.getNext()) {
    System.out.print(n.getData() + " ");
  }
  System.out.println();

Generic stack implementation

public class Stack<E> {

  private Node<E> top;
  private int size;

  public Stack() {
    this.top = null;
    this.size = 0;
  }

  public void push(E item) {
    this.top = new Node<E>(item, top);
    this.size++;
  }  

  public E peek() {
    if (this.top == null) {
      throw new IllegalStateException("Can't peek() into empty stack.");
    }
    return this.top.getData();
  }
  
  public E pop() {
    if (this.top == null) {
      throw new IllegalStateException("Can't pop() from empty stack.");
    }
    E data = this.top.getData();
    this.top = this.top.getNext();
    this.size--;
    return data;
  }  

  public int size() {
    return this.size;
  }  
}

And last week's code with generic stack...

  Stack<String> s = new Stack<String>();
  System.out.println(s.size());  //0
  s.push("Alice");
  s.push("Bob");
  s.push("Carol");
  System.out.println(s.size());  //3
  System.out.println(s.peek());  //Carol
  System.out.println(s.pop());   //Carol
  s.pop();
  System.out.println(s.peek());  //Alice
  System.out.println(s.size());  //1

But now can also do this:

  Stack<Integer> s = new Stack<Integer>();
  s.push(3);
  s.push(12);
  System.out.println(s.pop());

Cool! Stack will work with any type (object, not primitive, but can use wrapper classes).

More on generics

• Basic idea: Can specify the data type as a parameter (ie, type parameter)
• This is only the basics of generics; can get much more complicated (powerful)
• Can have a single method (not whole class) that uses generics
• Can specify bounds on generic type (must be subclass of this or superclass of that)
• Details of raw types (ie, a generic type used without the <generics> specified) and compiled details can get a bit hairy too
• Check out the Java Tutorial for more.

BTW: Good Java references

If you want to master the more advanced aspects of Java, I enjoyed:

• D. Flanagan's Java in a Nutshell (first 1/3; covers Java 5)
• J. Bloch's Effective Java (2nd ed)

• Can access digital versions of both for free through UH Library, but only 4 users at a time.
• Covers Java only (interfaces, inheritance, generics, etc); not other 211 material like ADTs, nodes, data structures, etc.

Summary

• Nodes (linked list) as data structure
• A node-based implementation of our Stack ADT
• Basics of writing classes with generics

For next time...

• Work on A04.
• Quiz 05.
• I will post A06a.