Chapter 0 Administrivia

Required

  mailx -s "the subject goes here" gottlieb@nyu.edu
  words go here and go in the msg.
  The next line causes a file to be placed in the msg (not attached
  simply copied in)
  ~r filename
  .

  Dear faculty,

  The vast majority of our students comply with the
  department's academic integrity policies; see

  www.cs.nyu.edu/web/Academic/Undergrad/academic_integrity.html
  www.cs.nyu.edu/web/Academic/Graduate/academic_integrity.html

  Unfortunately, every semester we discover incidents in
  which students copy programming assignments from those of
  other students, making minor modifications so that the
  submitted programs are extremely similar but not identical.

  To help in identifying inappropriate similarities, we
  suggest that you and your TAs consider using Moss, a
  system that automatically determines similarities between
  programs in several languages, including C, C++, and Java.
  For more information about Moss, see:

  http://theory.stanford.edu/~aiken/moss/

  Feel free to tell your students in advance that you will be
  using this software or any other system.  And please emphasize,
  preferably in class, the importance of academic integrity.

  Rosemary Amico
  Assistant Director, Computer Science
  Courant Institute of Mathematical Sciences

public class Max {
  public int max(int n, int[]a) {
    // assumes n > 0
    int ans = a[0];
    for (int i=0; i<n; i++)
      if (a[i] > ans)
    ans = a[i];
    return ans;
  }
}

class TopLevel1 {
  public    int   pubField;
  private   int   pvtField;
  protected int   proField;
            int   defField;
  public    class PubNestedClass {}
  private   class PriNestedClass {}
  protected class ProNestedClass {}
            class DefNestedClass {}
}
public class TopLevel2 {
  public    static void main (String[] arg) {}
  private   static void pvtMethod() {}
  protected static void proMethod() {}
            static void defMethod() {}
}

// one package statement
// import statements
public class NameOfClass {
  // private fields and
  // public methods
}

public class ReferenceVsValueSemantics {
  public static void main (String[] args) {
    int a1 = 1;   C c1 = new C(1);
    int a2 = 1;   C c2 = new C(1);
    a1 = a2;      c1 = c2;
    a1 = 5;       c1.setX(5);
    System.out.println(a2 + " " + c2.getX());
  }
}

public class C {
  private int x;
  C (int x) { this.x = x; }
  public int  getX()      { return x; }
  public void setX(int x) { this.x = x; }
}

javac ReferenceVsValueSemantics.java C.java
java  ReferenceVsValueSemantics

  public class D extends B {
    ...
  }

  package packageName;

  import packageName.ClassName;
  import packageName.*

import java.util.Scanner;
public class Test {
  public static void main(String[] arg) {
    int x;
    Scanner getInput = new Scanner(System.in);
    x = getInput.nextInt();
  }

public class Test {
  public static void main(String[] arg) {
    int x;
    java.util.Scanner getInput =
             new java.util.Scanner(System.in);
    x = getInput.nextInt();
  }
}

  javac packageName/ClassName.java

  javac packageName/*.java

  javac first/second/*.java

  javac first/second/third*.java

  java packageName/ClassName

  java testPackage/Test

  java bigPackage/M

  java first/second/third/M

  public class Test {
    public static void main (String[] args) {
      C c = new C();
      c.x = 1;
    }
  }

  public class C {
    public int x;
  }

import ch02.stringLogs.LLStringNode;
public class DemoCLASSPATH {
  public static void main (String[] args) {
    LLStringNode lLSN =
       new LLStringNode("Thank you CLASSPATH");
    System.out.println(lLSN.getInfo());
  }
}

  export CLASSPATH=/a/dale-datastructures/bookFiles:.

public class ReferenceVsValueSemantics {
  public static void main (String[] args) {
    int a1 = 1;   C c1 = new C(1);
    int a2 = 1;   C c2 = new C(1);
    a1 = a2;      c1 = c2;
    a1 = 5;       c1.setX(5);
    System.out.println(a2 + " " + c2.getX());
  }
}

public class C {
  private int x;
  C (int X) { this.x = x; }
  public int  getX()      { return x; }
  public void setX(int x) { this.x = x; }
}

javac ReferenceVsValueSemantics.java C.java
java  ReferenceVsValueSemantics

  // Same class C as above
  public class Example {
    public static void main (String[] args) {
      C c1 = new C(1);
      C c2 = new C(2);
      C c3 = c1;
      for (int i=0; i<1000; i++) {
        c3 = c2;
        c3 = c1;
      }
    }
  }

public class DemoCBV {
  public static void main (String[] args) {
    int x = 1;
    CBV cBV = new CBV(1);
    System.out.printf("x=%d  cBV.x=%d\n", x, cBV.x);
    setXToTen(x, cBV);
    System.out.printf("x=%d  cBV.x=%d\n", x, cBV.x);
  }
  public static void setXToTen(int x, CBV cBV) {
    x = 10;   cBV.x = 10;
  } 
}
public class CBV {
  public int x;
  public CBV (int x) {
    this.x = x;
  }    
}

  cBV = new CBV(7);
  CBV[] arrCBV = new CBV[5];
  arrCBV[0] = cBV;
  arrCBV[2] = new CBV(4);

  int[][] M;
  M = new int [2][3];

  int [][] R;
  R = new int [2][];
  R[0] = new int [3];
  R[1] = new int [1];

import java.math.BigInteger;
public class DemoBigInteger {
  public static void main (String[] args) {
    System.out.println(
      new BigInteger("5").multiply(
         new BigInteger("2").pow(1000)));
  }
}

  53575430359313366047421252453000090528070240585276680372187519418517552556246806
  12465991894078479290637973364587765734125935726428461570217992288787349287401967
  28388741211549271053730253118557093897709107652323749179097063369938377958277197
  30385314572855982388432710838302149158263121934186028340346880  

  1    2    4    8   16   32   64  128

  0    0    1    0    0    1    1   0

 .3   .3²  .3⁴  .3⁸  .3¹⁶ .3³² .3⁶⁴

           .3²     ×     .3³² × .3⁶⁴

  public class Quadrilateral extends GeometricObject {
    ...
    public Quadrilateral (Point p1, Point p2,
                          Point p3, Point P4)
    public double area() {...}
  }

  package squaring;
  public interface SquaringInterface {
    int getSquare();
  }

  package squaring;
  public class SimpleSquaring implements SquaringInterface {
    private int x;
    public SimpleSquaring(int x)  { this.x = x; }
    public int getSquare()        { return x*x; }
  }

  package squaring;
  public class FancySquaring implements SquaringInterface {
    private int x;
    public FancySquaring(int x)  { this.x = x; }
    public int getSquare() {
      int y = x + 55;
      return (x+y)*(x-y)+(y*y);
    }
  }

  import squaring.*;
  public class DemoSquaring {
    public static void main(String[] args) {
      SquaringInterface x1 = new SimpleSquaring(5);
      SquaringInterface x2 = new FancySquaring(6);
      System.out.printf("(x1.x)*(x1.x)=%d (x2.x)(x2.x)=%d\n",
                        x1.getSquare(), x2.getSquare());
    }
  }

  javac squaring/*.java

  javac DemoSquaring.java
  java  DemoSquaring

  import ch02.stringLogs.*
  public class DemoStringLogs {
  }

  export CLASSPATH=/a/dale-dataStructures/bookFiles:.

  StringLog(String name);

  StringLog(String name, int maxEntries);

  import ch02.stringLogs.*;
  public class DemoStringLogs {
    public static void main (String[] args) {
      StringLogInterface demo1;
      demo1 = new ArrayStringLog ("Demo #1");
      demo1.insert("entry 1");
      demo1.insert("entry 1"); // ??
      System.out.println ("The contains() " +
        "method is case " +
        (demo1.contains("Entry 1") ? "in" : "")
        + "sensitive.");
      System.out.println(demo1);
    }
  }

  The contains() method is case insensitive.
  Log: Demo #1

  1. entry 1
  2. entry 1

  package ch02.stringLogs;
  public class ArrayStringLog
         implements StringLogInterface {
    ...
  }

 private String[] log;
 private int lastIndex = -1;
 private String name;

  public ArrayStringLog(String name, 
                        int maxSize) {
    this.name = name;
    log = new String[maxSize];
  }

  public ArrayStringLog(String name) {
    super(name, 100); // 100 arbitrary
  }

  public void insert (String s) {
    log[++lastIndex] = s;
  }

  public void clear() {
    for(int i=0; i<=lastIndex; i++)
      log(i) = null;
    lastIndex = -1;
  }

  public boolean isFull() {
    return lastIndex == log.length-1;
  }

  public String size() {
    return lastIndex+1;
  }

  public String getName() {
    return name;
  }

  public boolean contains (String str) {
    for (int i=0; i<=lastIndex; i++)
      if (str.equalsIgnoreCase(log(i))
        return true;
    return false;
  }

  public String toString() {
    String ans = "Log: " + name + "\n\n";
    for (int i=0; i<=lastIndex; i++)
      ans = ans + (i+1) + ". " + log[i] + "\n";
    return ans;
  }

  public class LLStringNode {
    private String info;
    private LLStringNode link;
  }

  public LLStringNode(String info) {
    this.info = info;
    link = null;
  }

  node = new LLStringNode("test");

  node1 = LLStringNode("test1");
  node2 = LLStringNode("test2");
  node3 = LLStringNode("test3");
  node3.setLink(node2);
  node2.setLink(node1);

  public static void traverse(LLStringNode node) {
    while (node != null) {
      visit(node.getInfo());
      node = node.getLink();
    }
  }

  package ch02.stringLogs;
  public class LinkedStringLog
         implements StringLogInterface { ... }

  private LLStringNode log;
  private String name;

  public LinkedStringLog(String name) {
    this.name = name;
    log = null;
  }

  LinkedStringLog lsl =
       new LinkedStringLog("StrLog1");

  lst.insert ("Node1");
  lst.insert ("Node2");

  public void insert(String element) {
    LLStringNode node = new LLStringNOde(element);
    node.setLink(log);
    log = node;
  }

  public void clear() {
    log = null;
  }

  public boolean isFull() {
    return false;
  }

  public String getName() {
    return name;
  }

  public int size() {
    int count = 0;
    LLStringNode node = log;
    while (node != null) {
      count ++;
      node = node.getLink();
    }
    return count;
  }

  public String toString() {
    String ans = "Log: " + name + "\n\n";
    int count = 0;
    for (LLStringNode node=log; node!=null; node=node.getLink())
      ans = ans + (++count) + ". " + node.getInfo() + "\n";
    return ans;
  }

  public boolean contains(String str) {
    for (LLStringNode node=log; node!=null; node=node.getLink())
      if (str.equalsIgnoreCase(node.getInfo()))
        return true;
    return false;
  }

  export CLASSPATH=/a/dale-dataStructures/bookFiles:.
  javac codeQuality/DemoCodeQuality.java
  java codeQuality/DemoCodeQuality

  22 3 + 8 * 2 3 4 * - -
  ((22 + 3) * 8) - (2 - 3 * 4))

  public class T {
    ...
  }
  public class S extends T {
    ...
  }
  public class Main {
    public static void main(String[] args) {
      T t;
      S s;
      ...
      t = s;
    }
  }

  ArrayObjectLog integerLog =
                 new ArrayObjectLog("Perfect?");
  Integer i1=5, i2;
  ...
  integerLog.insert(i1);         // always works
  i2 = integerLog.retrieve();   // compile error
  i2 = (Integer)integerLog.retrieve();  // risky
  Object o = integerLog.retrieve();
  if (o instanceof Integer)
    i2 = (Integer)o;                    // safe
  else
    // What goes here?
    // Answer:  A runtime error msg
    // or a Java exception (see below).

  y1 = tan(5.1) + 5.1³ + cos(5.1²)
  y2 = tan(5.3) + 5.3³ + cos(5.3²)
  y3 = tan(8.1) + 8.1³ + cos(8.1²)
  y4 = tan(9.2) + 9.2³ + cos(9.2²)

  f(x) = tan(x) + x³ + cos(x²)
  y1 = f(5.1)
  y2 = f(5.3)
  y3 = f(8.1)
  y4 = f(9.2)

  public class ArrayLog<T> {
    private T[] log;
    private int lastIndex = -1;
    private String name;
    ...
  }

  public interface LogInterface<T> {
    void insert(T element);
    boolean isFull();
    int size();
    boolean contains(T element);
    void clear();
    String getName();
    String toString();
  }

  public class ArrayLog<T extends Comparable<T>> { ... }

double s12 = p1.distTo(p2);
if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) ||
    s12!=p4.distTo(p1)) {
  System.out.println("Error: Rhombus with unequal sides");
  System.exit(0);       // an exception would be better
}
sidelength = s12;

double s12 = p1.distTo(p2);
try {
  if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) ||
      s12!=p4.distTo(p1))
    throw new Exception("Rhombus with unequal side");
  sidelength = s12;
}
catch (Exception ex) {
  System.out.println("Error: Rhombus with unequal sides");
  System.exit(0);
}

 public Rhombus (Point p, double sideLength, double theta) {
   super (p,
          new Point(p.x+sideLength*Math.cos(theta),
                    p.y+sideLength*Math.sin(theta)),
          new Point(p.x+sideLength*(Math.cos(theta)+1.),
                    p.y+sideLength*Math.sin(theta)),
          new Point(p.x+sideLength, p.y));
   this.sideLength = sideLength;
 }

 double s12 = p1.distTo(p2);
 if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1))
   throw new Exception ("Rhombus with unequal sides.");
 sideLength = s12;

 try {
   rhom1 = new Rhombus(origin,origin,p2,p3);
 }
 catch (Exception ex) {
   System.out.printf("rhom1 error: %s  Use unit square.\n",
                     ex.getMessage());
   rhom1 = new Rhombus (origin, 1.0, Math.PI/2.0);
 }

  throw new Exception ("Rhombus with unequal sides.");

  public class GeometryException extends Exception {
    public GeometryException() { super(); }
    public GeometryException(String msg) { super(msg); }
  }

  throw new GeometryException
        ("Rhombus with unequal sides.");  

  public Rhombus (Point p1, Point p2, Point p3, Point p4) throws Exception {
    super(p1, p2, p3, p4);  // ignore this; not relevant to exceptions
    double s12 = p1.distTo(p2);
    if (s12!=p2.distTo(p3) || s12!=p3.distTo(p4) || s12!=p4.distTo(p1))
      throw new Exception ("Rhombus with unequal sides.");
    sideLength = s12;
  }

  package ch03.stacks;
  public class StackUnderFlowException
         extends RuntimeException {
    public StackUnderFlowException() {
      super();
    }
    public StackUnderFlowException(String msg) {
      super(msg);
    }
  }

  public class SUE extends RTE {
    public SUE() { super(); }
    public SUE(String msg) { super(msg); }
  }

  import ch03.stacks.*;
  public class DemoStacks {
    public static void main(String[] args) {
      ArrayStack<Integer> stack =
        new ArrayStack<Integer>();
      Integer x = stack.top();
    }   
  }

  import ch03.stacks.*;
  public class DemoStacks {
    public static void main(String[] args) {
      ArrayStack<Integer> stack =
        new ArrayStack<Integer>();
      stack.push(new Integer(3));
      Integer x = stack.top();
    } 
  }

  public class SOE extends RTE {
    public SOE() { super(); }
    public SOE(String msg) { super(msg); }
  }

  package ch03.stacks;
  public interface StackInterface<T> {
    void pop() throws StackUnderflowException;
    T    top() throws StackUnderflowException;
    boolean isEmpty();
  }

  package ch03.stacks;
  public interface BoundedStackInterface<T>
      extends StackInterface<T> {
    void push(T element)
      throws StackOverflowException;
    boolean isFull();
  }

  package ch03.stacks;
  public interface UnboundedStackInterface<T>
      extends StackInterface<T> {
    void push(T element);
  }

import ch03.stacks.*;
import java.util.Scanner;
public class ReverseIntegers {
  public static void main(String[] args) {
    Scanner getInput = new Scanner(System.in);
    int n = getInput.nextInt(), revInt;
    BoundedStackInterface<Integer> stack =
      new ArrayStack<Integer>(n);
    for (int i=0; i<n; i++)
      stack.push(new Integer(getInput.nextInt()));
    for (int i=0; i<n; i++) {
      revInt = stack.top();  stack.pop();
      System.out.println(revInt);
    }
  } 
}

  package ch03.stacks;
  public class ArrayStack<T>
      implements BoundedStackInterface<T> {
    private final int DEFSIZE = 100;
    private T[] stack;
    private int topIndex = -1;
    public ArrayStack(int size) {
      stack = (T[]) new Object[size];
    }
    public ArrayStack() { this(DEFSIZE); }

  public boolean isEmpty() { return topIndex == -1; }
  public boolean isFull()  { return topIndex == stack.length-1; }

  public void push(T element) {
  if (isFull())
    throw new StackOverflowException("helpful msg");
  else
    stack[++topIndex] = element;
  }

  public void pop() {
  if (isEmpty())
    throw new StackUnderflowException("helpful msg");
  else
    stack[topIndex--] = null;
  }

  public T top() {
  if (isEmpty())
    throw new StackUnderflowException("helpful msg");
  else
    return stack[topIndex];
  }

  new Balanced("([{", ")]}")
  new Balanced("]x*,", "[y3.")

  For each input char
    if open,    push
    if close,   pop and compare
    if neither, ignore
  When finished, stack must be empty

  stack.push(new Integer(i1));

  stack.push(i1);

  package support;
  public class LLNode<T> {
    private LLNode<T> link = null;
    private T info;
    public LLNode (T info) { this.info = info; }
    public T getInfo() { return info; }
    public LLNode<T> getLink() { return link; }
    public void setInfo(T info) { this.info = info; }
    public void setLink(LLNode<T> link) { this.link = link; }
  }

  UnboundedStackInterface<Integer> stack = 
            new LinkedStack<Integer> ();
  stack.push(new Integer(10));
  stack.push(20);    // autoboxed

  package ch03.stacks;
  import support.LLNode;
  public class LinkedStack<T> implements
      UnboundedStackInterface<T> {
    private LLNode<T> top = null;
    ...
  }

  public void push (T info) {
    LLNode<T> node = new LLNode<T>(info);
    node.setLink(top);
    top = node;
  }

  public void pop() throws StackUnderflowException {
    if (isEmpty())
      throw new StackUnderflowException("helpful msg");
    else
      top = top.getLink();
  }

  public T top() {
    if isEmpty()
      throw new StackUnderflowException("helpful msg");
    else
      return top.getInfo();
  }

  public boolean isEmpty() { return top==null; }

  import ch03.stacks.*;
  import java.util.Scanner;
  public class PostfixEval {
    public static double postfixEval(String expr) {
      ...
    }
  }

  export CLASSPATH="/a/dale-dataStructures/bookFiles/:."
  javac DemoPostfixEval.java
  java DemoPostfixEval

  export CLASSPATH="/a/dale-dataStructures/bookFiles/:."
  javac postfixEval/DemoPostfixEval.java
  java postfixEval/DemoPostfixEval

  1. f(n) = 1 + f(n-1)

  2. f(n) = 1 + f(n-1)  for n > 0
          = 0           for n ≤ 0    (base case)

  3. f(n) = 1 + f(n-1)  for n > 0
     f(0) = 0
     f(n) = 1 + f(n+1)  for n < 0

  4. f(n) = 1 + g(n)
     g(n) = 1 + f(n-1)  for n > 0
     g(0) = 0
     g(n) = 1 + f(n+1)  for n < 0

  5. f(n) = n * f(n-1)  for n > 0
     f(n) = 1           for n ≤ 0

  6. f(n) = f(n-1) + f(n-2)  for n > 0
     f(n) = 0                for n ≤ 0

  7. f(n) = f(n-1) + f(n-2)  for n > 0
     f(n) = 1                for n ≤ 0

  public class Hanoi1 {
  public static void main (String[] args) {
    hanoi(4, 'F', 'T', 'S');
  }
  public static void hanoi(int n, char from,
                        char to, char spare) {
    if (n>0) {
      hanoi(n-1, from, spare, to);
      System.out.println(n + ":" + from + to);
      hanoi(n-1, spare, to, from);
    }
  }
}

  for each successor
     the successor is reachable
     recurse at this successor

  for each successor
    if the successor is not listed
      list it
      recurse at this successor

  1 3
  2 4
  1 5

  4

  public class LLStringNode {
      private String info;
      private LLStringNode link = null;

      public LLStringNode(String info) { this.info = info; }

      public String getInfo() { return info; }
      public void setInfo(String info) { this.info = info; }
      public LLStringNode getLink() { return link; }
      public void setLink(LLStringNode link) { this.link = link; }
  }

public class DemoReversePrint {
    public static void main (String[] args) {
        LLStringNode node1 = new LLStringNode("node # 1");
        LLStringNode node2 = new LLStringNode("node # 2");
        LLStringNode node3 = new LLStringNode("node # 3");
        LLStringNode node4 = new LLStringNode("node # 4");

        node1.setLink(node2);
        node2.setLink(node3);
        node3.setLink(node4);

        System.out.println("Printing in original order");
        printFor(node1);
        System.out.println("Printing in reverse order");
        printRev(node1);
        System.out.println("Printing forward recursively");
        printForRec(node1);
    }
    public static void printFor(LLStringNode node) {
        while (node != null) {
            System.out.println("  " + node.getInfo() );
            node = node.getLink();
        }
    }
    public static void printRev(LLStringNode node) {
        if (node.getLink() != null)
            printRev(node.getLink());
        System.out.println ("  " + node.getInfo() );
    }
    public static void printForRec(LLStringNode node) {
        System.out.println ("  " + node.getInfo() );
        if (node.getLink() != null)
            printForRec(node.getLink());
    }
}

  while (node != null)
    push info on stack
    node = node.getLink()
  While (!stack.empty())
    print stack.top()
    stack.pop()

  n = getInput.nextInt();
  double[] x = new double[n];

  int gcd (int a, int b) {       int gcd (int a, int b) {
                               start:
    if (a == b) return a;          if (a == b) return a;
    if (a > b)                     if (a > b) {
        return gcd(a-b,b);              a = a-b; goto start; }
    return gcd(a,b-a); }           b = b-a; goto start; }

  package ch05.queues;
  public interface QueueInterface<T> {
    T dequeue() throws QueueUnderflowException;
    boolean isEmpty();
  }

  package ch05.queues;
  public interface BoundedQueueInterface<T> {
    void enqueue(T element) throws QueueOverflowException;
    boolean isFull();
  }  

  package ch05.queues;
  public interface BoundedQueueInterface<T> {
    void enqueue(T element);

import ch05.queues.*;
import java.util.Scanner;
public class DemoBoundedQueue {
  public static void main (String[] args) {
    Scanner getInput = new Scanner(System.in);
    String str;
    BoundedQueueInterface<Integer> queue =
      new ArrayBndQueue<Integer>(3);
    while (!(str=getInput.next()).equals("done"))
      if (str.equals("enqueue"))
        queue.enqueue(getInput.nextInt());
      else if (str.equals("dequeue"))
        System.out.println(queue.dequeue());
      else
    System.out.println("Illegal");
  }
}

  class SomethingOrOtherQueue<T>

  public class Palindrome {
    public static boolean isPalindrome(String str) { ... }
  }

main()
  loop N times
    flip a coin
    if heads
       produce()
    else
       consume()

produce()
  if queue is not full
    generate an item
    enqueue the item

consume()
  if queue is not empty
    dequeue an item
    print the item

  UnboundedQueueInterface<Integer> queue = LinkedUnBndQueue<Integer>();
  queue.enqueue(new Integer(10));
  queue.enqueue(20);   // Uses autoboxing

  public void enqueue(T data) {
    LLNode<T> newNode = new LLNode<T>(data);
    if (isEmpty())
      front = newNode;
    else
      rear.setLink(newNode);
    rear = newNode;
  }

  public T dequeue() {
    if (isEmpty())
      throw new QueueUnderflowException("Helpful msg");
    T ans = front.getInfo();
    front = front.getLink();
    if (front == null)
      rear = null;
    return ans;
  }

  package ch05.queues;
  import support.LLNode;
  public class LinkedUnbndQueue<T>
         implements UnboundedQueueInterface<T> {
    private LLNode<T> front=null, rear=null;
    public boolean isEmpty()    { return front == null; }
    public void enqueue(T data) { // shown above }
    public T dequeue()          { // shown above }
  }

  An array-based unbounded queue requires 71216 milliseconds
  to enqueue and dequeue 1000000 elements 1000 times.
  A linked-based unbounded queue requires 31643 milliseconds
  to enqueue and dequeue 1000000 elements 1000 times.

  public boolean equals (Circle circle) {
    return this.radius == circle.radius;
  }

  public boolean equals (Object circle) {
    if (circle instanceof Circle)
      return this.radius == ((Circle) circle).radius;
    return false;
  }

  list.reset()
  for (int i=0; i<list.size(); i++) {
    element = list.getNext();
    // play with element
  }

  import ch06.lists.*;
  public class ListExamples {
    public static void main (String[] args) {
      ListInterface<String> list1 = 
        new ArrayUnsortedList<String>(3);
      list1.add("Wirth");
      list1.add("Dykstra");
      list1.add("DePasquale");
      list1.add("Dahl");
      list1.add("Nygaard");
      list1.remove("DePasquale");
      System.out.print("Unsorted ");
      System.out.println(list1);

      ListInterface<String> list2 =
        new ArraySortedList<String>(3);
      list2.add("Wirth");
      list2.add("Dykstra");
      list2.add("DePasquale");
      list2.add("Dahl");
      list2.add("Nygaard");
      list2.remove("DePasquale");
      System.out.print("Sorted ");
      System.out.println(list2);

      IndexedListInterface<String> list3 = 
        new ArrayIndexedList<String>(3);
      list3.add("Wirth");
      list3.add("Dykstra");
      list3.add("DePasquale");
      list3.add("Dahl");
      list3.add("Nygaard");
      list3.remove("DePasquale");
      System.out.print("Indexed ");
      System.out.println(list3);
    }
  }

Unsorted List:     Sorted List:       Indexed List:
  Wirth          Dahl         [0] Wirth    
  Dykstra        Dykstra          [1] Dykstra  
  Nygaard        Nygaard          [2] Nygaard  
  Dahl           Wirth        [3] Dahl

  package ch06.lists;
  public ArrayUnsortedList<T> implements ListInterface<T> {
    protect final int DEFCAP = 100;
    protected T[] list;
    protected int numElements = 0;
    protected int location;
    protected int currentPos;

    public ArrayUnsortedList() { list = (T[]) new Object[DEFCAP]; }
    public ArrayUnsortedList(int origCap) {
      list = (T[]) new Object[origCap];
    }

  protected void enlarge() {
    T[] larger = (T[]) new Object[2*list.length];
    for (int i=0; i<numElements; i++)
      larger[i] = list[i];
    list = larger;
  }

  protected boolean find(T target); {
    for (location=0; location<numElements; location++)
      if (list[location].equals(target))
        return true;
    return false;
  }

  public void add(T element) {
    if (numElements == list.length)
      enlarge();
    list[numElements++] = element;

  public boolean remove(T element) {
    if (!find(element))
      return false;
    list[location] = list[--numElements];
    list[numElements] = null;
    return true;
  }

  public int size() { return numElements; }

  public boolean contains(T element) {
    return find(element);
  }

  public T get(T element) {
    if (find(element))
      return list[location]
    return null;
  }

  public String toString() {
    String str = "List:\n";
    for (int i=0; i<numElements; i++)
      str = str + " " + list[i] + "\n";
    return str;
  }

  public void reset() { currentPos = 0; }

  public T getNext() {
    T next = list[currentPos++];
    if (++currentPos == numElements)
      currentPos = 0;
    return next;
  }

  public class ArraySortedList<T>
         implements ListInterface<T>

  public class ArraySortedList<T implements Comparable>
         implements ListInterface<T>

  public class ArraySortedList<T extends Comparable>
         implements ListInterface<T>

  public class C implements Comparable<C>

  public class String implements Comparable<String>

  public class C implements Comparable<D>

  public class ArraySortedList<T extends Comparable<T>>
         implements ListInterface<T>

    ArraySortedList<T extends Comparable<? super T>> implements ListInterface<T>

  public class ArraySortedList<T>
         implements ListInterface<T>

  public class ArraySortedList<T extends Comparable<T>>
         implements ListInterface<T>

  if (((Comparable)listElement).compareTo(element) < 0)  // list element < add element

  if (listElement.compareTo(element) < 0)  // list element < add element

  public class ArraySortedList<T extends Comparable<T>>
    extends ArrayUnsortedList<T> implements ListInterface<T> {
    ArraySortedList()            { super(); }
    ArraySortedList(int origCap) { super(origCap); }

    public void add(T element) {
      int location;
      if (numElements == list.length)
        enlarge();
      for (location=0; location<numElements; location++)
        if ((list[location]).compareTo(element) >= 0)
          break;
      for (int index=numElements; index>location; index--)
        list[index] = list[index-1];
      list[location] = element;
      numElements++;
    }

    public boolean remove(T element) {
      boolean found = find(element);
      if (found) {
        for (int i=location; i<=numElements-2; i++)
          list[i] = list[i+1];
        list[--numElements] = null;
      return found;
    }
  }

  package ch06.lists;
  public class ArrayIndexedList<T> extends ArrayUnsortedList<T>
         implements IndexedListInterface<T> {
    public ArrayIndexList()            { super();      }
    public ArrayIndexList(int origCap) {super(origCap); }

    public void add(int index, T element) {
      if ((index<0) || (index>numElements))
         throw new IndexOutOfBounds Exception("Helpful message.");
      if (numElements == list.length)
        enlarge();
      for (int i=numElements; i>index; i--)
        list[i] = list[i-1];
      list[index] = element;
      numElements++
    }

  public T set(int index, T element) {
    if ((index<0) || (index>numElements))
       throw new IndexOutOfBounds Exception("Helpful message.");
    T hold = list[index];
    list[index] = element;
    return hold;
  }

  public int indexOf(T element) {
    if (find(element))
      return location;
    return -1;
  }

  public T remove (int index) {
    if ((index<0) || (index>numElements))
       throw new IndexOutOfBounds Exception("Helpful message.");
    T hold = list[index];
    for (int i=index; i<(numElements-1); i++)
      list[i] = list[i-1];
    list[numElements--] = null;
    return hold;

  public String toString() {
    String str = :List:\n";
    for (int i=0; i<numElements; i++)
      str = str + "[" + i "] " + list[i] + "\n";
    return str;

For *MIDTERM* grades, I do not give + or -.
I certainly do give + and - for final grades.

1.  Normal case:  Midterm exam and labs 1 and 2:
    * Lab average Lavg = (L1+L2)/2
    * Overall average Avg = (2*midExam + Lavg)/3
    * A=90-100  B=80-89  C=70-79  D=60-69  F=0-59

2.  No midterm exam
    * Grade is UE (unable to evaluate)

3.  Midterm exam but only 1 or 0 labs
    * Avg = midExam - 10 (hoping that late labs will appear;
                          for final grades missing labs count as 0!)
    * Same letter grade ranges as case 1
    * Exception.  Missing labs do not lower D to F (I don't fail anyone
      who passes all exams)

  protected boolean find(T target)

  protected boolean find(T target) {
    return find1(target, 0, numElements-1);
  }

  private boolean find1(T target, int lo, int hi) {
    if (lo > hi)
      return false;
    int location = (lo + hi) / 2;
    if (list[location].compareTo(target) == 0)
      return true;
    if (list[location].compareTo(target) < 0)
      return find1(target, location+1, hi);
    return find1(target, lo, location-1);
  }

  protected boolean find(T target) {
    int lo=0,  hi=numElements-1;
    while (lo <= hi) {
      location = (lo + hi) / 2;
      if (list[location].compareTo(target) == 0)
        return true;
      if (list[location].compartTo(tartet))
        lo=location+1;
      else
        hi=location-1;
    }
    return false;
  }

  package ch06.lists;
  import support.LLNode;
  public class RefUnsortedList<T> implements ListInterface<T> {
    protected int numElements = 0;
    protected LLNode<T> currentPos = null;
    protected LLNode<T> location;
    protected LLNode<T> previous;
    protected LLNode<T> list = null;

  public void add(T element) {
    LLNode<T> newNode = new LLNode<T>(element);
    newNode.setLink(list); // new  becomes first
    list = newNode;
    numElements++;
  }

  public int size() { return numElements; }

  public boolean contains(T element) {
    return find(element);
  }

  protected boolean find(T target) {
    location = list;
    while (location != null)
      if (location.getInfo().equals(target))
        return true
      previous = location;
      location = location.getLink();
    return false;
  }  

  public boolean remove(T element) {
    boolean found = find(element);
    if (found) {
      if (location = list) // first element
        list = location.getLink();  
      else
        previous.setlink(location.getLink());
      numElements--;
    }
    return found;
  }

  public T get(T element) {
    if find(element)
      return location.getInfo();
    else
      return null;
  }

  public void reset() { currentPos = list; }

  public T getNext() {
    T next = currentPos.getInfo();
    if (currentPos.getLink() == null)
      currentPos = list;
    else
      currentPos = currentPos.getLink();
    return next;
  }
} // end of class RefUnsortedList<T>

  public class RefSortedList<T extends Comparable<T>>
         extends RefUnsortedList<T>
         implements ListInterface<T> {

  public void add(T element) {
    LLNode<T> prevLoc  = null;
    LLNode<T> location = list;
    while (location!=null &&
           location.getInfo().compareTo(element)<0) {
      prevLoc = location;
      location = location.getLink();
    }
    LLNode<T> newNode = new LLNoDE<T>(element);
    if (prevLoc == null) {   // add at front of list
      newNode.setLink(list);
      list = newNode;
    } else {                 // add elsewhere
      newNode.setLink(location);
      prevLoc.setLink(newNode);
    }
    numElements++;
  }
} // end of class RefSortedList<T>

  while unvisited nodes remain
    pick an unvisited node
    visit that node

  inorderTraversal(Node N)
    if (N has a left child)
      preorderTraversal(left child)
    visit(N)
    if (N has a right child)
      preorderTraversal(right child)

  preorderTraversal(Node N)
    visit(N)
    if (N has a left child)
      preorderTraversal(left child)
    if (N has a right child)
      preorderTraversal(right child)

  postorderTraversal(Node N)
    if (N has a left child)
      preorderTraversal(left child)
    if (N has a right child)
      preorderTraversal(right child)
    visit(N)

  inorderTraversal(Node N)
    if (N is not null)
      preorderTraversal(left child)
      visit(N)
      preorderTraversal(right child)

  preorderTraversal(Node N)
    if (N is not null)
      visit(N)
      preorderTraversal(left child)
      preorderTraversal(right child)

  postorderTraversal(Node N)
    if (N is not null)
      preorderTraversal(left child)
      preorderTraversal(right child)
      visit(N)

  public static final int INORDER   = 1;
  public static final int PREORDER  = 2;
  public static final int POSTORDER = 3;

  package support;
  public class BSTNode<T extends Comparable<T>> {
    private T info;
    private BSTNode<T> left  = null;
    private BSTNode<T> right = null;

    BSTNode(T info) { this.info = info; }

    public T getInfo()          { return info; }
    public void setInfo(T info) { this.info = info; }

    public BSTNode<T> getLeft()          { return left; }
    public void setLeft(BSTNode<T> link) { left = link; }

    public BSTNode<T> getRight()          { return right; }
    public void setRight(BSTNode<T> link) { right = link; }
  }

  package ch08.trees;
  import ch03.stacks.*;   // used for iterative size()
  import cho4.queues.*    // used for traversals
  import support.BSTNode;

  public class BinarySearchTree<T extends Comparable<T>> {
    private BSTNode<T root = null;
    private found;        // used by remove()
    private LinkUnbndQueue<T> BSTQueue;
    private LinkUnbndQueue<T>  preOrderQueue;
    private LinkUnbndQueue<T> postOrderQueue;

    public boolean isEmpty() { return root == null; }
    public int size() { return recSize(root); }
    // rest later
  } // end of BinarySearchTree<T>

  private int recSize(BSTNode<T> tree) {
    if (tree == null)
      return 0;
    return recSize(tree.getLeft())  +
           recSize(tree.getRight()) +
           1;
  }

  public boolean contains(T element) {
    recContains(element, root);
  }

  private boolean recContains(T element, BSTNode<T> tree) {
    if (tree == null)
      return false;
    if (element.compareTo(tree.getInfo()) == 0)
      return true;
    if (element.compareTo(tree.getInfo()) < 0)
      return recContains(element, root.getLeft());
    return recContains(element, root.getRight());
  }

  public T get(T element) { return recGet(element, root); }

  public T recGet(T element, BSTNode<T> tree) {
    if (tree == null)
      return null;
    if (element.compareTo(tree.getInfo()) == 0)
      return tree.getInfo();
    if (element.compareTo(tree.getInfo()) < 0)
      return recGet(element, root.getLeft());
    return recGet(element, root.getRight());
  }

  public void add(T element) { root = recAdd(element, root); }

  private BSTNode<T> recAdd(T element, BSTNode<T> tree) {
    if (tree == null) // insert new node here
      tree = new BSTNode<T>(element);
    else if (element.compareTo(tree.getInfo()) < 0)
      tree.setLeft(recAdd(element, tree.getLeft()));
    else
      tree.setRight(recAdd(element, tree.getRight()));
    return tree;
  }

  public boolean remove (T element) {
    root = recRemove(element, root);
    return found;
  }

  private BSTNode<T> recRemove(T element, BSTNode<T> tree) {
    if (tree == null) { // element not in tree
      found = false;
      return tree;
    }
    if (element.compareTo(tree.getInfo()) == 0) {
      found = true;  // found the element
      return removeNode(tree);
    }
    if (element.compareTo(tree.getInfo()) < 0)
      tree.setLeft(recRemove(element, tree.getLeft()))
    else
      tree.setRight(recRemove(element, tree.getRight()))
    return tree;
  }

  private BSTNode<T> removeNode (BSTNode<T> tree) {
    if (tree.getLeft() == null)
      return tree.getRight();
    if (tree.getRight() == null)
      return tree.getLeft();
    T data = getPredecessorInfo(tree);
    tree.setInfo(data);
    tree.setLeft(recRemove(data, tree.getLeft()));
    return tree;
  }

  private T getPredcessorInfo(BSTNode<T> tree) {
    tree = getLeft(tree);
    while (tree.getRight() != null)
      tree = tree.getRight();
    return tree.getInfo();
  }

  public int reset(int orderType) {
    BSTQueue = new LinkedUnbndQueue<T>;
    if (orderType == INORDER)
      inOrder(root);
    else if (orderType == PREORDER)
      preOrder(root);
    else if (orderType == POSTORDER)
      postOrder(root);
    return size();
  }

  public T getNext() { return BSTQueue.dequeue(); }

  private void inOrder(BSTNode<T> tree) {
    if (tree != null) {
      inOrder(tree.getLeft());
      BSTqueue.enqueue(tree.getInfo();
      inOrder(tree.getRight());
    }
  }

  private void preOrder(BSTNode<T> tree) {
    if (tree != null) {
      BSTqueue.enqueue(tree.getInfo();
      preOrder(tree.getLeft());
      preOrder(tree.getRight());
    }
  }

  private void inOrder(BSTNode<T> tree) {
    if (tree != null) {
      postOrder(tree.getLeft());
      postOrder(tree.getRight());
      BSTqueue.enqueue(tree.getInfo();
    }
  }

  balance()
    n = tree.reset(INORDER);
    for (int i=0; i<n; i++)
      array[i] = tree.getNext()
    tree = new BinarySearchTree()
    tree.insertTree(0, n-1)

  insertTree(lo, hi)
    if (hi == lo)
      tree.add(array[lo])
    if (hi == lo+1)
      tree.add(array[lo]
      tree.add(array[hi]
    mid = (lo+hi)/2
    tree.insertTree(lo, mid-1)
    tree.insertTree(mid+1, hi)

  package priorityQueues;
  class PriQOverflowException extends RuntimeException {
    public PriQOverflowException() { super(); }
    public PriQOverflowException(String message) {
      super(message);
    }
  }

  package priorityQueues;
  class PriQUnderflowException extends RuntimeException {
    public PriQUnderflowException() { super(); }
    public PriQUnderflowException(String message) {
      super(message);
    }
  }

package priorityQueues;
public class Heap<T extends Comparable<T>>
       implements PriQueueInterface<T> {
  private T[] elements;
  private int lastIndex = -1;
  private int maxIndex;

  public Heap(int maxSize) {
    elements = new T[maxSize];
    maxIndex = maxSize - 1;
  }

  public boolean isEmpty() { return lastIndex == -1; }
  public boolean isFull()  { return lastIndex == maxIndex; }

  public void enqueue (T element)
         throws PriQOverflowException {
    if (lastIndex == maxIndex)
      throw new PriQOverflowException("helpful message");
    lastIndex++;
    reheapUp(element);
  }

  private void reheapUp(T element) {
    int hole = lastIndex; 
    while ((hole>0) &&
           (element.compareTo(elements[parent(hole)])>0)) {
      elements[hole] = elements[parent(hole)];
      hole = parent(hole);
    }
    elements[hole] = element;    
  }

  private int parent(int index) { return (index-1)/2; }

  public T dequeue() throws PriQUnderflowException{
    if (lastIndex == -1)
      throw new PriQUnderflowException("Helpful msg");
    T ans    = elements[0];
    T toMove = elements[lastIndex--];
    if (lastIndex != -1)
      reheapDown(toMove);
    return ans;
  }

  private void reheapDown(T element) {
    int hole = 0;
    int newhole = newHole(hole, element);
    while (newhole != hole) {
      elements[hole] = elements[newhole];
      hole = newhole;
      newhole = newHole(hole, element);
    }
    elements[hole] = element;
  }

  private int newHole(int hole, T element) {
    int left  = 2 * hole + 1;
    int right = 2 * hole + 2;
    if (left > lastIndex)    // no children
      return hole;
    if (left == lastIndex)   // one child
      return element.compareTo(elements[left])<0? left: hole;
    if (elements[left].compareTo(elements[right]) <  0)
      return element.compareTo(elements[right])<0? right: hole;
    return element.compareTo(elements[left])<0? left: hole;
  }

  // for testing only
  public String toString() {
    String theHeap = new String("The heap is\n");
    for (int i=0; i<=lastIndex; i++)
      theHeap += i + ".  " + elements[i] + "\n";
    return theHeap;
  }
}

public class TestSortingMethod {
  private static final int SIZE = 50;
  private static final int DIGITS = 3;  // change printf %4d
  private static final int MAX_VALUE = (int)Math.pow(10,DIGITS)-1;
  private static final int NUM_PER_LINE = 10;
  private static int[] values = new int[SIZE];
  private static int numSwaps = 0;

  private static void initValues() {
    for (int i=0; i<SIZE; i++)
      values[i] = (int)((MAX_VALUE+1)*Math.random());
  }

  private static boolean isSorted() {
    for (int i=0; i<SIZE-1; i++)
      if (values[i] > values[i+1])
    return false;
    return true;
  }

  private static void swap (int i, int j) {
    int t = values[i];
    values[i] = values[j];
    values[j] = t;
    numSwaps++;
  }

  private static void printValues() {
    System.out.println("The value array is:");
    for (int i=0; i<SIZE; i++)
      if ((i+1) % NUM_PER_LINE == 0)
    System.out.printf("%4d\n", values[i]);
      else
    System.out.printf("%4d"  , values[i]);
    System.out.println();
  }

  public static void main(String[] args) {
    initValues();
    printValues();
    System.out.printf("The array %s initially sorted.",
              isSorted() ? "is" : "is not");
    sortValues();
    printValues();
    System.out.printf("After performing %d swaps,\n", numSwaps);
    System.out.printf("the array is %s sorted.",
                      isSorted() ? "now" : "still not");
  }

  private static void sortValues() {
    // call sort program here
  }
}

The values array is:
 513 190 527 324 930 948 504 228  37 891
 153 277 552 893 738 926 193 408 525 324
 178 389 738 784 728 812 783 558 530 703
 843  38  53 999 326  34 777 496 915 364
 929 576 937 572  43 439 569 245 740  53

The array is not initialy sorted.

The values array is:
 513 190 527 324 930 948 504 228  37 891
 153 277 552 893 738 926 193 408 525 324
 178 389 738 784 728 812 783 558 530 703
 843  38  53 999 326  34 777 496 915 364
 929 576 937 572  43 439 569 245 740  53

After performing 0 swaps,
the array is still not sorted.

  private static void selectionSort() {
    for (int i=0; i<SIZE-1; i++)
      swap(i, minIndex(i, SIZE-1));
  }
  private static int minIndex(int startIndex, int endIndex) {
    int ans = startIndex;
    for (int i=startIndex+1; i<=endIndex; i++)
      if (values[i] < values[ans])
    ans = i;
    return ans;
  }

  private static void bubbleSort() {
    boolean sorted = false;
    while (!sorted) {
      sorted = true;
      for (int i=0; i<SIZE-1; i++)
        if (values[i] > values[i+1]) {
          swap(i, i+1);
          sorted=false;
        }
    } 
  }

  private static void insertionSort() {
    for (int i=1; i<SIZE; i++) {
      int j = i;
      while (j>0 && values[j-1]>values[j]) {
        swap(j, j-1);
        j--;
      }
    }
  }

  private static void mergeSort(int first, int last) {
    if (first < last) {
      int middle = (first+last) / 2;
      mergeSort(first, middle);
      mergeSort(middle+1, last);
      merge(first, middle, last);
    }
  }
  private static void merge(int leftFirst, int leftLast, int rightLast) {
    int leftIndex = leftFirst;
    int rightIndex = leftLast+1;
    int[] tempArray = new int[rightLast-leftFirst+1];
    int tempIndex = 0;
    while (leftIndex<=leftLast  &&  rightIndex<=rightLast)
      if (values[leftIndex] < values[rightIndex])
	tempArray[tempIndex++] = values[leftIndex++];
      else
	tempArray[tempIndex++] = values[rightIndex++];
    while (leftIndex <= leftLast)
      tempArray[tempIndex++] = values[leftIndex++];
    while (rightIndex <= rightLast)
      tempArray[tempIndex++] = values[rightIndex++];
    for (tempIndex=0; tempIndex<tempArray.length; tempIndex++)
      values[leftFirst+tempIndex] = tempArray[tempIndex];
  }

  private static void heapSort() {
    PriQueueInterface<Integer> h = new Heap(values.length);
    for (int i=0; i<values.length; i++)
      h.enqueue(values[i]);
    for (int i=values.length-1; i>=0; i--)
      values[i] = h.dequeue();
  }

  public static void badSort(int[] a) {
    for (i=0; i<a.length; i++)
      a[i] = i;
  }

  public class Student {
    private int nNumber;	// the key
    private String name;
    private String major;
    // etc
    public Student(int nNumber, String name, String major) {
      this.nNumber = nNumber;
      this.name    = name;
      this.major   = major;
    }
    public int    getNNumber() { return nNumber; }
    public String getName()    { return name;    }
    public String getMajor()   { return major;   }

    public void   setNNumber(int nNumber) { this.nNumber = nNumber; }
    public void   setname(String name)    { this.name    = name;    }
    public void   setMajor(String major)  { this.major   = major;   }
  }

  public class StudentHashtable {
    private Student[] studentHashtable;
    private int size;
    public StudentHashtable(int size) {
      this.size = size;
      studentHashtable = new Student[size];
    }

    public int hash(int key) { return key % size; }

    public void add (Student s) {
      studentHashtable[hash(s.getNNumber())] = s;

    public Student get(Student s) {
      return studentHashtable[hash(s.getNNumber())];
    }
  }

  public void add (Student s) {
    int location = hash(s.getNNumber());
    while (studentHashtable[location] != null)
      location = (location+1) % capacity;
    studentHashtable[location] = s;
  }

  public Student get(Student s) {
    int location = hash(s.getNNumber());
    while (studentHashtable[location].getNNumber()!=s.getNNumber())
      location = (location+1) % capacity;
    return studentHashtable[location];
  }

		Insertion			Deletion

Structure	Traversal	Beginning	Middle	End	Beginning	Middle	End

Stringlog	XX	??		??
Stack		XX			XX
Queue				XX	XX
General List	XX	XX	XX	XX	XX	XX	XX

	BST	Array List	Lnk List
Constructor	O(1)	O(N)	O(1)
`isEmpty()`	O(1)	O(1)	O(1)
`reset()`	O(N)	O(1)	O(1)
`getNext()`	O(1)	O(1)	O(1)
`contains()/get()`	O(logN)	O(logN)	O(N)
`add()`	O(logN)	O(N)	O(N)
`remove()`	O(logN)	O(N)	O(N)

	enqueue	dequeue
Linked List	O(N)	O(1)
Heap	O(logN)	O(logN)
Binary Search Tree
Balanced	O(logN)	O(logN)
Skewed	O(N)	O(N)

Chapter 0 Administrivia

0.1 Contact Information

0.2 Course Web Page

0.3 Textbook

0.4 Email and the Mailman Mailing List

0.5 Grades

0.6 The Upper Left Board

0.7 Homeworks and Labs

0.7.1 Homework Numbering

0.7.2 Doing Labs on NYU Systems (i5.nyu.edu)

0.7.3 Doing Labs on non-NYU Systems

Mailing Labs from i5.nyu.edu

0.7.4 Obtaining Help with the Labs

0.7.5 Computer Language Used for Labs

0.8 A Grade of Incomplete

0.9 Academic Integrity Policy

0.10 The 101 Prerequisite

Chapter 1 Getting Organized

1.A What's the Course About

Performance

An Example of Performance vs Simplicity: kth Largest

Data Structures

Software Engineering

Client-Server Computing

1.1: Software Engineering

Software Life Cycles

Agile Methods

Goals of Quality Software

1.2 Object Orientation

The Unified Method

1.3 Classes, Objects, and Applications

Classes

Visibility Modifiers

The 14 Possibilities

Our Simplification

Objects

Reference vs. Value Semantics

Applications

Running a Program

1.4 Organizing Classes

Inheritance

The Inheritance Tree

Packages

The package Statement

The import Statement

The Extensive, Wonderful, Super-Slick Java Library Documentation

Package Names, CLASSPATH, and the Hierarchical Filesystem

Packages with Multiple Compilation Units

Subdirectories and Package Names with Dots

Running the Compiled Program

CLASSPATH and Multiple Packages

A Downloaded Example

1.5 Data Structures

Implementation-Dependent Structures

Arrays

Linked List

Implementation-Independent Structures

Stack

Queue

Sorted List

Tree

Graph

What is a Data Structure?

1.6 Basic Structuring Mechanisms

References

Reference Types Versus Primitive Types

Aliases

Garbage

Example

Comparing Objects

Passing Parameters

Arrays

Arrays of Objects

Two-Dimensional Arrays

1.7 Comparing Algorithms: Big-O Analysis

A Quandary

Big-O Notation

Common orders of Magnitude

Example 1: Sum of Consecutive Integers

Example 1 (alternate): Raising a Number to a Large Power

An Example of Performance vs Simplicity: k^th Largest

The `package` Statement

The `import` Statement

Package Names, `CLASSPATH`, and the Hierarchical Filesystem

`CLASSPATH` and Multiple Packages

2.2 The `StringLog` ADT Specification

Dealing with `CLASSPATH`

The `StringLogInterface`

Using the `StringLogInterface`

2.3 Array-Based `StringLog` Implementation

The `LLStringNode` Class

2.6 Linked List `StringLog` ADT Implementation

`insert()`

`clear()`

`isFull()`

`getName()`

`size()`

`toString()`

`contains()`