Starting Out with Java Chapter 15, 16.1, and 16.2

Checkpoint Question 16.6 - On average, with an array of 20,000 elements, how many comparisons will the Sequential Search perform?

10,000 comparisons.

Checkpoint Question 16.7 - With an array of 20,000 elements, what is the maximum number of comparisons the binary search will perform?

15 comparisons.

Checkpoint Question 15.2 - What is a base case?

A base case is the part of the problem that recursion is NOT used to solve.

What is the Binary Search Algorithm?

A clever algorithm that is much more efficient than the Sequential Search. Its only requirement is that the values in the array must be sorted in some order. It's an search algorithm that starts in the middle of an array. If the value is lower than the element in the middle, it will search the first half of the array. From there it will start at the middle of the first half and repeat the steps. If the value is higher than the element in the middle, it will search the second half. From there, once again, it will start in the middle of the portion and repeat the steps. This process continues until the value being searched for is found or there are no more elements to test.

What is a recursive method?

A method that calls itself.

Checkpoint Question 15.4 - What causes a recursive algorithm to stop calling itself.

A recursive algorithm stops calling itself when the base case is reached.

Checkpoint Question 15.3 - What is a recursive case?

A recursive case is the part of the problem that recursion IS used to solve.

What is a search algorithm?

A search algorithm is a method of locating a specific item in a larger collection of data.

What are sorting algorithms?

A technique for scanning through an array and rearranging its contents in some specific order.

What four algorithms can be used to sort an array?

Bubble Sort, Selection Sort, Insertion Sort, and Quicksort.

Short Answer - How is a problem usually reduced with a recursive method?

By being broken down smaller and smaller(closer and closer to the base case) with each recursion.

In a recursive case, why must we reduce the problem to a smaller version of the original problem?

By reducing the problem with each recursive call, the base case will eventually be reached and the recursion will stop. If we don't reduce the problem with each call we'll have endless recursion.

What is direct recursion?

Direct recursion is when a recursive method directly calls itself.

Checkpoint Question 15.5 - What is direct recursion? What is indirect recursion?

Direct recursion is when a recursive method directly calls itself. Indirect recursion is when a recursive method(method A) calls another method(method B) that calls the original recursive method(method A). This then repeats until the base case is reached. There can be multiple methods between each recursive call.

T or F - It is not necessary to have a base case in all recursive algorithms.

F - It is always necessary to have a base case in all recursive algorithms. If there is no base case you'll have endless recursion.

T or F - Some problems can be solved through recursion only.

F - No problem requires recursion to be solved

T or F - In the base case, a recursive method calls itself with a smaller version of the original problem.

F - The base case is the part of the problem that recursion is NOT used. In the recursion case is when a recursive method calls itself with a smaller version of the original problem.

T or F - The first call to a recursive method is part of its "depth of recursion".

F - The first call to a recursive method is just another method call. The "depth of recursion" would start when the recursive method calls itself.

How do you fix endless recursion?

Having a base case fixes endless recursion.

Short Answer - When recursion is used to solve a problem, why must the recursive method call itself to solve a smaller version of the original problem?

If a recursive algorithm doesn't get smaller or closer to the base case, it will call itself endlessly.

How the compareTo( ) method works.

If the calling object is less than the object passed as an argument, the method returns a negative number. If the calling object is equal to the object passed as an argument, the method returns 0. If the calling object is greater to the object passed as an argument, the method returns a positive number.

What is indirect recursion?

Indirect recursion in when a recursive method(method A) calls another method(method B) which calls the original recursive method(method A). This will then repeat until the base case is reached, unless it's an endless recursive method.

Short Answer - What type of recursive method do you think would be more difficult to debug: one that uses direct recursion, or one that uses indirect recursion? Why?

Indirect recursion is more difficult to debug because you have to go through all of the methods that get called for each recursion.

How does the Insertion Sort sort values?

It begins by looking at the first two elements of the array. We compare these elements and, if necessary, we swap them so they are in the proper order. This becomes the sorted portion of the array. Then, we incorporate the third element into the part of the array that is already sorted. If we need to shift either of the first two elements to accommodate the third element, we do so. Once we have the third element into the correct position(relative to the first two elements), the initial portion of the array consisting of the first three elements will be sorted. This process continues with the fourth and subsequent elements, until all of the elements have been inserted into their proper positions.

Checkpoint Question 16.8 - If a Sequential Search is performed on an array, and it is known that some items are searched for more frequently than others, how can the contents of the array be reordered to improve the average performance of the search?

It can be reordered so that the most popular search items will be at the beginning of the array. This ensures that they are some of the first items to be found and this will significantly decrease the amount of comparisons that would have to be made to find them.

How does the Bubble Sort sort values?

It makes several passes through the elements of the array and the larger values "bubble" toward the end of the array with each pass.

What does it mean for an array to be sorted in "descending order"?

It means that the values in an array are stored from highest to lowest.

What does it mean for an array to be sorted in an "ascending order"?

It means that the values in an array are stored from lowest to highest.

After the base case is reached, and there are no more statements to be executed after the method call, where does control return to?

It returns to the previous instance in the call stack. For example: if you're in the fifth instance control would be returned to the fourth instance. This repeats until all instances of the method return.

When does overhead take place?

It takes place with each method call

What is the maximum number of comparisons a Binary Search will make for an array that has 50,000 elements?

It will make a maximum of 16 comparisons. 2^16 = 65,536.

What is the maximum number of comparisons a Binary Search will make for an array that has 1,000,000 elements?

It will make a maximum of 20 comparisons. 2^20 = 1,048,576.

Is recursion needed to solve certain problems?

No, recursion is never absolutely required to solve a problem. Any problem that can be solved recursively and be solved iteratively(with a loop).

Are recursive algorithms usually more efficient than iterative algorithms?

No, they are usually less efficient.

In the average case, how many times will the Sequential Search attempt to find an item?

On average, the amount of attempts it takes will be half of the amount of elements in the array.

What is overhead?

Overhead is actions performed by the JVM such as: allocating memory for parameters and local variables and storing the address of the program location where control returns after the method terminates.

Checkpoint Question 15.1 - It is said that a recursive algorithm has more overhead than an iterative algorithm, what does this mean?

Overhead is the actions the JVM makes each method call. This includes: allocating memory for parameters and local variables and storing the address of the program location where control returns after the method terminates.

How do you find the maximum number of comparisons the Binary Search Algorithm will make?

Powers of 2 are used. Simply find the smallest power of 2 that is greater than or equal to the number of elements in the array.

Short Answer - Which repetition is less efficient: a loop or a recursive method? Why?

Recursion is less efficient because it has more overhead than using a loop.

What are two types of search algorithms?

Sequential and Binary.

Common Errors to Avoid - Using an inefficient sort or search algorithm on a large array...

Simple algorithms like the Bubble Sort and the Sequential Search are inefficient because they access array elements so many times. More efficient algorithms like the Quicksort and Binary Search are preferrable, especially on large arrays.

T or F - An iterative algorithm will usually run faster than an equivalent recursive algorithm.

T

Common Errors to Avoid - Forgetting to sort data in an array before using a Binary Search Algorithm...

The Binary Search Algorithm requires that its data be already sorted.

Checkpoint Question 16.1 - Which of the sorting algorithms that we discussed makes several passes through an array and causes larger values to gradually move toward the end of the array?

The Bubble Sort algorithm.

Checkpoint Question 16.2 - One of the sorting algorithms that we discussed works like this: It begins by putting the initial portion of the array consisting of the first two elements in sorted order. Then the third element is moved to its correct position, relative to the first two elements. At that point the first three elements are in sorted order. This process continues with the fourth and subsequent elements until the entire array is sorted. Which algorithm is this?

The Insertion Sort algorithm.

Checkpoint Question 16.3 - One of the sorting algorithms that we discussed works like this: The smallest value in the array is located and moved to element 0. Then the next smallest value is located and moved to element 1. This process continues until all of the elements are placed in their proper order. Which algorithm is this?

The Selection Sort algorithm.

What is the Sequential Search Algorithm?

The Sequential Search Algorithm is a search algorithm that uses a loop to step sequentially through an array, starting with the first element. It compares each element with the value being searched for and stops when the value is found or the end of the array is encountered.

Short Answer - What is the base case of each of the recursive methods listed in Algorithm Workbench 3, 4, and 5?

The base case in 3 is 10. The base case in 4 is 10. The base case in 5 is 0.

What is the "base case"?

The base case is the part of the problem where recursion is NOT used.

Short Answer - What is a recursive algorithm's base case? What is the recursive case?

The base case is the part of the problem where recursion is NOT used. The recursive case is the part of the problem that recursion IS being used.

When using the Bubble Sort to compare objects, what do you use?

The compareTo( ) method.

Checkpoint Question 16.5 - Describe the difference between the Sequential Search and Binary Search.

The difference is that a Sequential Search goes through each element one by one until the item is found while the Binary Search cuts what it has to search through in halves relative to whether the item is greater than or less than the element in the middle.

Short Answer - What is the difference between an iterative algorithm and a recursive algorithm?

The difference is that an iterative algorithm is called once while a recursive algorithm is called until the base case is reached.

What is "depth of recursion"?

The number of times a method calls itself.

Why do people use the recursive binary search algorithm more than its iterative version?

The recursive binary search algorithm is more elegant and easier to understand than its iterative version.

What is the "recursive case"?

The recursive case is the part of the problem where recursion IS used.

How does the Selection Sort sort values?

The smallest value in the array is located and moved to index 0. Then, the next smallest value is located and moved to index 1. This process continues until all of the elements have been placed in their proper order.

Find The Error - public class FindTheError { public static void main(String[ ] args) { myMethod(0); } public static void myMethod(int num) { System.out.print(num + " "); myMethod(num + 1); } }

There should be an if statement to define the base case. This has been fixed in the fixedMyMethod method below. public class FindTheError { public static void main(String[ ] args) { fixedMyMethod(0); } public static void originalMyMethod(int num) { System.out.print(num + " "); originalMyMethod(num + 1); } public static void fixedMyMethod(int num) { if (num < 50) System.out.print(num + " "); fixedMyMethod(num + 1); } }

Algorithm Workbench - What will the following program display? public class Checkpoint { public static void main(String[ ] args) { int num = 0; showMe(num); } public static void showMe(int arg) { System.out.printlln(arg); if (arg < 10) showMe(arg + 1); } }

This program will display: 0 1 2 3 4 5 6 7 8 9 10

Algorithm Workbench - What will this program display? public class Checkpoint { public static void main(String[ ] args) { int num = 0; showMe(num); } public static void showMe(int arg) { if (arg < 10) showMe(arg + 1); else System.out.println(arg); } }

This program will display: 10

Algorithm Workbench - What will the following program display? public class ReviewQuestion5 { public static void main(String[ ] args) { int x = 10; System.out.println(myMethod(x)); } public static int mymethod(int num) { if (arg <= 0) return 0; else return myMethod(num - 1) + num; } }

This program will display: 55

Common Errors to Avoid - Not reducing the problem with each recursive call..

Unless the problem is reduced(which usually means that the value of one or more critical parameters is reduced) with each recursive call, the method will not reach the base case. If the base case is not reached, the method will call itself infinitely.

Common Errors to Avoid - Not coding a base...

When a base case is reached, a recursive method stops calling itself. Without a base case, the method will continue to call itself infinitely.

When is a good time to implement a recursive algorithm?

When a problem has repetitive steps, such as the Towers of Hanoi game.

What is endless recursion?

When a recursive method calls itself over and over again. Much like an infinite loop, there is no code to stop it from repeating.

When can a problem be solved with recursion?

When it can be broken down into successive smaller problems that are identical to the overall problem.

Why might a developer use a recursive algorithm over an iterative one?

While an iterative algorithm can execute faster, a programmer might be able to design a recursive algorithm faster.

Worst case scenario, how many times will the Sequential Search attempt to find an item?

Worst case, the amount of attempts it takes will match the number of elements in the array.

Common Errors to Avoid - Writing the recursive call in such a way that the base case is never reached...

You might have a base case and a recursive case that reduces the problem, but if the calculations are not performed in such a way that the base case is ultimately reached, the method will call itself infinitely.

This is the part of a problem that can be solved without recursion. a.) base case b.) solvable case c.) known case d.) recursion case

a.) base case

This refers to the actions taken internally by the JVM when a method is called. a.) overhead b.) set up c.) clean up d.) synchronization

a.) overhead

This search algorithm steps sequentially through an array, comparing each item with the search value. a.) sequential search b.) binary search c.) natural order search d.) selection search

a.) sequential search

This search algorithm will search half of the array on average. a.) sequential search b.) binary search c.) natural order search d.) selection search

a.) sequential search

This algorithm requires that the array's contents be sorted. a.) sequential search b.) binary search c.) natural order search d.) selection search

b.) binary search

This search algorithm repeatedly divides the portion of an array being searched in half. a.) sequential search b.) binary search c.) natural order search d.) selection search

b.) binary search

A method called once from a program's main method, and then it calls itself four times. The depth of recursion is __________. a.) one b.) four c.) five d.) nine

b.) four

if an array is sorted in this order, the values are stored from lowest to highest. a.) asymptotic b.) logarithmic c.) ascending d.) descending

c.) ascending

This is when a method explicitly calls itself. a.) explicit recursion b.) modal recursion c.) direct recursion d.) indirect recursion

c.) direct recursion

If an array is sorted in this order, the values are stored from highest to lowest. a.) asymptotic b.) logarithmic c.) ascending d.) descending

d.) descending

This is when method A calls method B, which in turn calls method A. a.) implicit recursion b.) modal recursion c.) direct recursion d.) indirect recursion

d.) indirect recursion

Factorial Recursive Method Code

private static int factorial(int n) { if (n == 0) return 1; // Base case else return n * factorial(n - 1); // recursive call }

Algorithm Workbench - Write an iterative version(using a loop instead of recursion) of the factorial method.

private static void factorial(int n) { int factorial = 1; for (int i = n; i > 0; i--) { factorial = factorial * i; } System.out.println(factorial); }

Endless Recursion in Code

public class EndlessRecursion { public static void message( ) { System.out.println("This is a recursive method."); message( ); } }

Fixed Recursive Code

public class Recursive { public static void message(int n) { if (n > 0) { System.out.println("This is a recursive method."); message(n - 1); } } }

Recursive Binary Search Method Code

public static int binarySearch(int[ ] array, int first, int last, int value) { int middle; // Mid point of search if (first > last) return -1; middle = (first + last) / 2; if (array[middle] == value) return middle; else if (array[middle] < value) return binarySearch(array, middle + 1, last, value); else return binarySearch(array, first, middle - 1, value); }

Fibonacci Series Recursive Method Code

public static int fib(int n) { if (n == 0) return 0; // Base case else if (n == 1) return 1; // Base case else return fib(n - 1) + fib(n - 2); // Recursive calls }

Binary Search Algorithm Code

public static int search(int[ ] array, int value) { int first; // First array element int last; // Last array element int middle; // Mid point of search int position; // Position of search value boolean found; // Flag first = 0; last = array.length - 1; position = -1; found = false; while (!found && first <= last) { middle = (first + last) / 2; if (array[middle] == value) { found = true; position = middle; } else if (array[middle] > value) last = middle - 1; else first = middle + 1; } return position; }

Sequential Search Algorithm Code

public static int search(int[ ] array, int value) { int index; // Loop control variable int position; // Position the value is found at boolean found; // Flag indicating search results // Element 0 is the starting point of the search index = 0; // Store the default values position and found position = -1; found = false; while (!found && index < array.length) { if (array[index] == value) { found = true; position = index; } index++; } }

Object Bubble Sort Code

public static void bubbleSort(Comparable[ ] array) { int lastPos; // Position of the last element to compare int index; // Index of an element to compare Comparable temp; // Used to swap to elements for (lastPos = array.length - 1; lastPos >= 0; lastPos--) { for (index = 0; index <= lastPos - 1; index++) { if (array[index].compareTo(array[index + 1]) > 0) { temp = array[index]; array[index] = array[index + 1]; array[index + 1] = temp; } } } } Notice that the bubbleSort method's parameter is declared as Comparable[ ] array. When we call this method, the argument that we pass must be an array of objects that implement Comparable.

Array Bubble Sort Code

public static void bubbleSort(int[ ] array) { int lastPos; // Position of the last element to compare int index; // Index of an element to compare int temp; // Used to swap to elements for (lastPos = array.length - 1; lastPos >= 0; lastPos--) { for (index = 0; index <= lastPos - 1; index++) { if (array[index] > array[index + 1]) { temp = array[index]; array[index] = array[index + 1]; array[index + 1] = temp; } } } } The lastPos variable will hold the index of the last element that is to be compared to its neighbor during a pass through the array. The index variable is used as an index into the array during each pass. The temp variable is used to hold the value of an element temporarily during a swap. The outer for loop will iterate once for each element in the array. It causes the lastPos variable to take on all the array's subscripts, from the highest subscript down to 0. After each iteration, lastPos is decremented by 1. The inner loop iterates once for each element in the portion of the array that is still unsorted. It starts at index 0 and increments up through lastPos - 1. During each iteration, the comparison in the if statement is performed. This if statement compares the element at array[index] with its neighbor array[index + 1]. If the element's neighbor is less, then the two are swapped.

Object Insertion Sort Code

public static void insertionSort(Comparable[ ] array) { Comparable unsortedValue; // The first unsorted value int scan; // Used to scan the array for (int index = 1; index < array.length; index++) { unsortedValue = array[scan - 1]; scan = index; while (scan > 0 && array[scan - 1] > unsortedValue) { array[scan] = array[scan - 1]; scan--; } array[scan] = unsortedValue; }

Array Insertion Sort Code

public static void insertionSort(int[ ] array) { int unsortedValue; // The first unsorted value int scan; // Used to scan the array for (int index = 1; index < array.length; index++) { unsortedValue = array[scan - 1]; scan = index; while (scan > 0 && array[scan - 1] > unsortedValue) { array[scan] = array[scan - 1]; scan--; } array[scan] = unsortedValue; }

Algorithm Work Bench - Modify the method you wrote in the previous Algorithm Workbench so it displays the String backward.

public static void reverseStringToChar(String str) { if (str.length() == 0) System.out.print("No more characters..." + '\n'); else { reverseStringToChar(str.substring(1)); System.out.print(str.charAt(0)); } }

Object Selection Sort Code

public static void selectionSort(Comparable[ ] array) { int startScan; // Starting position of the scan int index; // To hold a subscript value int minIndex; // Element with smallest value in the scan Comparable minValue; // The smallest value found in the scan for (startScan = 0; startScan < (array.length - 1); startScan++) { minIndex = startScan; minValue = array[startScan]; for (index = startScan + 1; index < array.length; index++) { if (array[index].compareTo(minValue) < 0) { minValue = array[index]; minIndex = index; } } array[minIndex] = array[startScan]; array[startScan] = minValue; } }

Array Selection Sort Code

public static void selectionSort(int[ ] array) { int startScan; // Starting position of the scan int index; // To hold a subscript value int minIndex; // Element with smallest value in the scan int minValue; // The smallest value found in the scan for (startScan = 0; startScan < (array.length - 1); startScan++) { minIndex = startScan; minValue = array[startScan]; for (index = startScan + 1; index < array.length; index++) { if (array[index] < minValue) { minValue = array[index]; minIndex = index; } } array[minIndex] = array[startScan]; array[startScan] = minValue; } }

Algorithm Workbench - Convert the following iterative method to one that uses recursion: public static void sign(int n) { while (n > 0) { System.out.println("No Parking"); n--; } }

public static void sign(int n) { if (n > 0) System.out.println("No Parking"); else sign(n - 1); }

Algorithm Work Bench - Write a method that accepts a String as an argument. The method should use recursion to display each individual character in the String.

public static void stringToChar(String str) { if (str.length() == 0) System.out.print('\n' + "No more characters..."); else { System.out.print(str.charAt(0)); stringToChar(str.substring(1)); } }

How the Selection Sort can be used in arranging an array's elements in ascending order:

| 5 | 7 | 2 | 8 | 9 | 1 | Since the smallest value(1) is stored at index 5, it is swapped with 5 which is stored at index 0. | 1 | 7 | 2 | 8 | 9 | 5 | Then the algorithm repeats the process, but because the element at position 0 is already the smallest in the array, it can be left out. This time, the algorithm begins the scan at position 1. | 1 | 2 | 7 | 8 | 9 | 5 | The array after the second pass. | 1 | 2 | 5 | 8 | 9 | 7 | The array after the third pass. | 1 | 2 | 5 | 7 | 9 | 8 | The array after the fourth pass. | 1 | 2 | 5 | 7 | 8 | 9 | The array after the fifth pass. All elements are in their correct position.

How the Bubble Sort can be used in arranging an array's elements in ascending order:

| 7 | 2 | 3 | 8 | 9 | 1 | The Bubble Sort starts by comparing the first two elements in the array. They are exchanged if the element at index 0 is greater than the element at index 1. | 2 | 7 | 3 | 8 | 9 | 1 | This step is repeated with elements at index 1 and 2. They are exchanged if the element at index 1 is greater than the element at index 2. | 2 | 3 | 7 | 8 | 9 | 1 | Next, elements at index 2 and 3 are compared. In this array, the elements are already in the proper order, so no exchange occurs. As the cycle continues, elements in index 3 and 4 are compared. Once again, you don't need to exchange them because they are already in proper order. When the elements in index 4 and 5 are compared, however, an exchange must take place because the element in index 4 is greater than the one in index 5. | 2 | 3 | 7 | 8 | 1 | 9 | At this point, the whole array has been scanned, and the largest value, 9, is in the correct position. There are other elements, however, that are not yet in their final position. So, another pass through the array is made, comparing each element with its neighbor. In the next pass, we stop comparing the next-to-last element(in this case index 4) because the last element(index 5) is already in the right position. | 2 | 3 | 7 | 1 | 8 | 9 | The second pass starts by comparing the elements in index 0 and 1, because those are already in the proper order no exchange takes place. The elements in index 1 and 2 are then compared, and no exchange takes place. 3 and 4 are compared, because the element in index 3 is greater than the one in index 4, they are switched. | 2 | 3 | 1 | 7 | 8 | 9 | The array after the third pass. | 2 | 1 | 3 | 7 | 8 | 9 | The array after the fourth pass. | 1 | 2 | 3 | 7 | 8 | 9 | The array after the fifth pass. At this point, all of the elements are in their proper positions.

How the Insertion Sort can be used in arranging an array's elements in ascending order:

| 7 | 2 | 4 | 6 | 3 | 1 | This is the array before being sorted. | 2 | 7 | 4 | 6 | 3 | 1 | This is the array after the first pass. | 2 | 4 | 7 | 6 | 3 | 1 | This is the array after the second pass. | 2 | 4 | 6 | 7 | 3 | 1 | This is the array after the third pass. | 2 | 3 | 4 | 6 | 7 | 1 | This is the array after the fourth pass. | 1 | 2 | 3 | 4 | 6 | 7 | This is the array after the fifth pass. All of the elements are in their proper positions.