Before sending the compareTo message to an arbitrary object, that object must be cast to Comparable.

When the element type of an array is a reference type or interface, objects of those types or any subtype (subclass or implementing class) can be directly inserted into the array.

After accessing an object in an array, care must be taken to send it the appropriate messages or to cast it down to a type that can receive the appropriate messages.

An ArrayList object’s physical size is automatically updated as needed.

An ArrayList object can hold primitives.

The algorithm to compute the factorial of a number cannot be expressed in a recursive algorithm.

Consider the following method:

int recursiveMethod (int n){
   if (n == 1)
      return 1;
   else
      return n * recursiveMethod(n - 2);
}

This recursive method would always complete its recursion.

O(n log n) complexity is generally better (more efficient) than O(n²).

Consider an algorithm that is O(log n). Suppose you execute the algorithm once where the value of n is 10 and a second time where the value of n is 1000. The second execution will take three times longer than the first execution.

The summation algorithm’s best, worst, and average cases are all O(n).

The String class’s ____ method compares the contents of two String objects, but ignores the case of the characters.

The String class’s ____ method removes any white space from the beginning and end of a String object.

Which of the following will return the number of characters in a String object named s1?

Consider the following code:

int search (int[] a, int searchValue){
   for (int i = 0; i < a.length; i++)
      if (a[i] == searchValue)
         return i;
   return -1;
}

This method performs a ____ search on an array.

Suppose an unsorted array of five integers contains the values {4, 2, 5, 1, 3}. If a selection sort is performed on this array, the values stored in the array after the second pass of the sorting algorithm would be ____.

Consider the following pseudocode:

For each k from 1 to n - 1 (k is the index of array element to insert)
   Set itemToInsert to a[k]
   Set j to k - 1
   (j starts at k - 1 and is decremented until insertion   
   position is found)
      While (insertion position not found) and (not beginning
      of array)
         If itemToInsert < a[j]
            Move a[j] to index position j + 1
            Decrement j by 1
         Else
            The insertion position has been found
            itemToInsert should be positioned at index j + 1

This algorithm represents a(n) ____ sort.

Which of the following algorithms is a correct recursive algorithm for summing n numbers?

A recursive method with no stopping state will result in ____ recursion.

Consider the following method:

int sum (int[] a){
   int result = 0;
   for (int i = 0; i < a.length; i++){
      result += a[i];
   }
   return result;
}

The complexity of the algorithm represented by the method is ____.

A linear search has a complexity of ____.

Consider the following method:

int[] sumRows (int[][] a){
   int[] rowSum = new int[a.length];
   for (int row = 0; row < a.length; row++){
      for (int col = 0; col < a[row].length; col++){
         rowSum[row] += a[row][col];
      }
   }
   return rowSum;
}

The complexity of the algorithm represented by the method is ____.

The complexity of a recursive algorithm for computing the nth Fibonacci is ____.

A thorough analysis of an algorithm’s complexity divides its behavior into ____ types of cases.

Bubble sort’s best-case complexity is ____.

The binary search algorithm is ____.