Class 30: Arrays

Held: Monday, 24 October 2005

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

Related Pages:

• EBoard.
• Sample Code.

Assignments

• Daily assignment posted at the end of class (on the eboard).

Notes:

• I was unable to write up something on parameterized classes during break. Expect something soon.
• For the remainder of the semester, I'll be giving daily assignments at the end of each class and will try to grade them on a plus/check/minus basis.

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 Vec2D classes allowed you to group logical aspects of a two-dimensional vector 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];
    

• Similarly, to create a collection of 10 strings and name the collection names, you would write

  String[] names = new String[10];
  

• Arrays are initialized with default values (0 for numbers, null for objects).
• 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[] vals = {3, 2, 6, 5};
  

• Similarly, to create an array of strings, you might write

  String[] rebelguys = { "Samuel", "William", "Jonathan", "Daniel" };
  

• Note that you don't need to indicate the size of an array when you use this technique.
• You can refer to a particular element of an array with name[index]
• For example, I could refer to element 3 of the stuff with stuff[3]
• You use these referrents to assign or get values. For example

  pen.println(rebelguys[0] + " is a rebel.");
  stuff[3] = stuff[3] * 2;
  

• 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.

  /**
   * Sum the values in stuff.
   */
  public double sum(double[] stuff) {
    double total = 0.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 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.

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.

     public long fibra(int n)
     {
        // Build a cache, use -1 for "I don't know."
        int cache = new long[n+1];
        cache[0] = 0;
        cache[1] = 1;
        for (int i = 2; i <= n; i++)
           cache[i] = -1;
        // Compute the nth number using the cache.
        fibra_helper(n, cache);
     } // fibra(int)
  
     public long fibra_helper(int n, long[] cache)
     {
        // If the cache contains no value
        if (cache[n] == -1)
           // Compute it
           cache[n] = fibra_helper(n-1, cache)
              + fibra_helper(n-2, cache);
        // The cache must now return a value, so
        // return it.
        return cache[n];
     } // fibra_helper
  

• Since each element of the array gets filled in once, this is a much faster 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.