CS 46A - Lecture 21

Pre-class reading

• Sections 7.6.6 - 7.8

Common Array Algorithm: Locating the Position of an Element

• Problem: Locate the position of an element so that you can replace or remove it
• Use a variation of the linear search algorithm, but remember the position instead of the matching element
• Example: Locate the position of the first element that is larger than 100:

  int pos = 0; 
  boolean found = false; 
  while (pos < values.size() && !found) 
  { 
     if (values.get(pos) > 100) { found = true; } 
     else { pos++; } 
  } 
  if (found) { System.out.println("Position: " + pos); } 
  else { System.out.println("Not found"); }

Lecture 21 Clicker Question 1

The algorithm above locates the first match. What if you want to get all matching values?

1. You can collect all matching values in an ArrayList<Double>
2. You can collect the positions of all matching values in an int[] array
3. You can supply a function

   int findFirst(double[] values, double limit, int startPosition)

   and call it repeatedly

4. All of the above will work

Common Array Algorithm: Removing an Element

• Array list ⇒ use method remove
• Unordered array ⇒
  1. Overwrite the element to be removed with the last element of the array
  2. Decrement the variable tracking the size of the array

  values[pos] = values[valuesSize - 1]; 
  valuesSize--;

• Ordered array ⇒
  1. Move all elements following the element to be removed to a lower index
  2. Decrement the variable tracking the size of the array

  for (int i = pos; i < valuesSize - 1; i++) 
  { 
     values[i] = values[i + 1]; 
  } 
  valuesSize--;

Common Array Algorithm: Removing an Element

Common Array Algorithm: Inserting an Element

• Array list ⇒ use method add
• Unordered array ⇒
  1. Insert the element as the last element of the array
  2. Increment the variable tracking the size of the array

  if (valuesSize < values.length) 
  { 
     values[valuesSize] = newElement; 
     valuesSize++; 
  }

• Ordered array ⇒
  1. Start at the end of the array, move that element to a higher index, then move the one before that, and so on until you finally get to the insertion location
  2. Insert the element
  3. Increment the variable tracking the size of the array

  if (valuesSize < values.length) 
  { 
     for (int i = valuesSize; i > pos; i--) 
     { 
        values[i] = values[i - 1]; 
     } 
     values[pos] = newElement; 
     valuesSize++; 
  }

Common Array Algorithm: Inserting an Element

Lecture 21 Clicker Question 2

Consider this variation of the insertion algorithm.

if (valuesSize < values.length) 
{ 
   for (int i = pos + 1; i < valuesSize; i++) 
   { 
      values[i] = values[i - 1]; 
   } 
   values[pos] = newElement; 
   valuesSize++; 
}

What is the contents of values after the loop when pos is  3, newElement is 10, valuesSize is 6, and before the loop, values is

1 4 9 16 25 36 0 0 0 0

1. 1 4 9 10 16 25 36 0 0 0
2. 1 4 10 9 16 25 36 0 0 0
3. 1 4 9 10 16 16 16 0 0 0
4. Something else

Common Array Algorithm: Copying an Array

• Copying an array variable yields a second reference to the same array:

  double[] values = new double[6]; 
   . . .  // Fill array 
  double[] prices = values;  

• To make a true copy of an array, call the Arrays.copyOf method:

  double[] prices = Arrays.copyOf(values, values.length);  

• 

Common Array Algorithm: Growing an Array

• To grow an array that has run out of space, use the Arrays.copyOf method:

  values = Arrays.copyOf(values, 2 * values.length);

  

Common Array Algorithm: Growing an Array

• Example: Read an arbitrarily long sequence numbers into an array, without running out of space:

  int valuesSize = 0; 
  while (in.hasNextDouble()) 
  { 
     if (valuesSize == values.length) 
        values = Arrays.copyOf(values, 2 * values.length); 
     values[valuesSize] = in.nextDouble(); 
     valuesSize++;   
  }

Common Array Algorithm: Printing Element Separators

• When you display the elements of an array or array list, you usually want to separate them:

  Ann | Bob | Cindy

• Note that there is one fewer separator than there are elements
• Print the separator before each element except the initial one (with index 0):

  for (int i = 0; i < names.size(); i++) 
  { 
     if (i > 0) 
     { 
        System.out.print(" | "); 
     } 
     System.out.print(names.get(i)); 
  }

Lecture 21 Clicker Question 3

The following replacement has been suggested for the algorithm that prints element separators:

System.out.print(names.get(0)); 
for (int i = 1; i < names.size(); i++)
   System.out.print(" | " + names.get(i));

What is problematic about this suggestion?

1. Nothing—it works perfectly
2. It prints one separator too many
3. It prints one separator too few
4. It can cause an index out of bounds exception

Two-Dimensional Arrays

• When constructing a two-dimensional array, specify how many rows and columns are needed:

  final int ROWS = 3;
  final int COLUMNS = 3;
  String[][] board = new String[ROWS][COLUMNS];

• Access elements with an index pair:

  board[1][1] = "x"; 
  board[2][1] = "o";

Traversing Two-Dimensional Arrays

• It is common to use two nested loops when filling or searching:

  for (int i = 0; i < ROWS; i++)
     for (int j = 0; j < COLUMNS; j++)
        board[i][j] = " ";

• You can also recover the array dimensions from the array variable:
  • board.length is the number of rows
  • board[0].length is the number of columns

  for (int i = 0; i < board.length; i++) 
     for (int j = 0; j < board[0].length; j++) 
        board[i][j] = " ";