Class 36: Arrays

Held: Monday, 5 April 2004

Summary: Today we visit one of Java's core data structures: the array. We consider two applications of arrays in writing algorithms.

Related Pages:

• EBoard.
• EIJ, Chapter J6.
• Fib.java.

Assignments:

• Read O1: Object-Oriented Design.

Notes:

• Are there questions on homework 5?
• Wednesday through Friday of this week will be on design issues.

Overview:

• Introduction to Arrays.
• Arrays in Java.
• An Application: Fibonacci Numbers.
• An Application: Box Packing.

Arrays

• Data structures in programming languages allow us to organize and manipulate data in more natural ways.
• You've already seen one way data structures are helpful: classes are, in effect, one way to build your own data structurs.
  • For example, your Rational classes allowed you to group logical aspects of a rational number into a whole.
• But sometimes you want to collect an unknown amount of information, just as you do with Scheme's lists and vectors.
• As importantly, you want to be able to visit the items one-by-one and access them by index.
• Many languages provide arrays to support this type of collection.
• Traditionally, arrays are fixed-sized collections of elements that you can index by number.
  • However, different languages provide different perspectives.

Arrays in Java

• Java provides one form of arrays, although with some interesting design decisions.
  • When you create an array, you must specify its length in advance.
  • Array indices range from 0 to length-1.
  • Arrays are somewhat homogeneous: all the elements are of the same type (or a subclass of the same type).
• You can declare arrays of a particular size with

  type[] name = new type[size];
  

  • For example, to create a collection of five numbers named stuff, you would write

    double[] stuff = new double[5];
    

• You can also fill in arrays when you create them. To do this, you would write

  type[] name = { val1, val2, ..., valn }
  ;
  

  • For example, to create an array of integers with the values 3, 2, 6, and 5, I would write

    int[] stuff = {3, 2, 6, 5};
    

  • Note that you don't need to indicate the size.
• You can refer to a particular element of an array with name[index]
• For example, I could element 3 of the stuff with stuff[3]
• You can also use variables (or even expressions) as indices. For example, if i held the value 3, then we could get element 3 of the stuff with stuff[i]
• You can always determine the number of elements in an array with name.length

• Once we have values in arrays, it's "easy" to do general computations with them. Here is a method that sums the values in an array.

  public double sum(double[] stuff) {
    double total = 0;     // The total of the numbers in stuff
    int i;                // A counter variable for stepping through
                          // the array
    // Step through the array, adding each subsequent value
    for(i = 0; i < stuff.length; i = i + 1) {
      total = total + stuff[i];
    }
    // Return the total value
    return total;
  } // sum
  

Example: The Fibonacci Sequence

• We'll start by looking at a procedure used to compute the Fibonacci sequence.
  • In case you've forgotten (or don't know), the sequence has the form 0 1 1 2 3 5 8 13 21 ...
  • That is, each number (except the first two) is the sum of the previous two numbers.
  • Why is this an interesting sequence?

A Recursive Implementation

• We can, of course, write a recursive solution to computing the nth Fibonacci number.

    public static long fib(int n) {
      if (n < 2)
        return n;
      else
        return fib(n-1) + fib(n-2);
    } // fib(int)
  

• It's short, it's elegant. it's recursive. What's not to like?
  • Well, let's consider the efficiency.
  • In effect, we do two recursive calls for each call and we don't shrink the parameter much.
  • Informally, that makes it an exponential algorithm.

Improving the Recursive Implementation

• Can we make this recursive implementation better? Certainly.
• In particular, We can use arrays to improve the running time of our recursive Fibonacci algorithm.
• How? The biggest problem with the recursive Fibonacci is that we recompute values again and again.
• If we cache (remember) results after we compute them, we can check the cache before repeating a recursive call.

    private static long[] cache;
    public static long fib(int n) {
      // Ensure that the cache is big enough.
      if ((cache == null) || (cache.length <= n)) {
        cache = new long[n+1];
        for (int i = 2; i <=n; i++) 
          cache[i] = -1;
        cache[0] = 0;
        cache[1] = 1;
      }
      // Check the cache.  If it's not initialized, initialize it.
      if (cache[n] == -1)
        cache[n] = fib(n-1) + fib(n-2);
      // Extract the value from the cache
      return cache[n];
    } // fib(int)
  

• Since each element of the array gets filled in once, this is an O(n) algorithm.
• The idea of caching values is often called dynamic programming. It's one of the algorithm design strategies you'll often employ.

An Iterative Implementation

• Of course, we can also compute the values left-to-right.
• Once we've computed all the values in the array of size n+1, we can easily return the nth Fibonacci number.

Another Example: Grain Packing

• Suppose we were in charge of putting boxes on a specialized UPS truck.
• Each box has a size (amount of space it occupies) and a value to UPS for shipping it on the truck.
• How do we maximize the value for the given space?
• We'll start by making two dangerous simplifying assumptions:
  • If the sum of volumes of the boxes selected is less than or equal to the volume of the truck, we can fit it in the truck.
  • For each value/size combination that exists, there are an arbitrary number of packages with that combination.
• One solution is greedy: repeatedly pick the most valuable package that still fits.
• What is the running time of that solution?
• Does that solution work?
• Another solution is exhaustive: try every combination and find the best.
• What is the running time of that solution?
• Does that solution work?

Box Packing with Arrays

• Can arrays help us make the solution better?
• Just as we used an array to cache partial results in the Fibonacci solution, we'll use an array to cache partial results in this solution.
• What are the partial results? The best possible choice for each size of truck.
• Implementation to be filled in by the class.
• Can we make this better?