Class 21: Arrays

Held: Friday, 1 October 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.
• Sample Code.

Due

• Exam 1

Assignments

• Homework 22: Fibonacci numbers.

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 Fraction classes allowed you to group logical aspects of a Fraction 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 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.