Class 23: Arrays

Held Wednesday, March 1, 2000

Overview

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

Notes

• Expect a homework assignment 3 tonight or tomorrow afternoon. I'll post it to the assignments page when it's ready.
• I decided to change the way I presented today's class, so today's outline is a somewhat sketchier than I'd like.
• Assignments:
  • Go over the specifications for discussion on Friday. Our goal will be to resolve differences.

Contents

• Arrays
  • Arrays in Java
• Improving Fibonacci with Arrays
• The Box Packing Problem
  • Improving the Solution with Arrays
• Dynamic Programming

Summary

• Arrays as a data structure
  • General model
  • Java's model
• An application: improving Fibonacci
• Another application: bin packing
• Due:
  • Preparatory reading of Lab J6
  • Project, Phase 2: Specifications
• Handouts:
  • Project, Phase 2

Arrays

• We use data structures in programming languages to allow us to 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 StudentInfo classes allowed you to group logical aspects of a student in one 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.
• Many languages provide arrays to support this type of collection.
• Arrays are fixed-sized collections of elements that you can index by number.

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 with the values 3, 2, 6, and 5, I would write

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

• 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
  

Improving Fibonacci with Arrays

• We can use arrays to improve the running time of our recursive Fibonacci algorithm.
• How? The biggest problem with Fibonacci is that we recompute values again and again.
• Rather than recomputing them, we'll store them in an array.
• More to come
• Note: rather than starting with N and working down to 1, we can also start with 1 and work up to N.

The Box Packing Problem

• 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?
• One solution is greedy: pick the most valuable package first.
• 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?
• Specifics to follow

Improving the Solution with Arrays

• More to come

Dynamic Programming

• We can generalize this use of arrays to store solutions to smaller problems.
• More to come