Exam 16: Sorting, Searching, and Algorithm Analysis

The worst case complexity function is a good measure to use when

One can sort an array a[ ] as follows.Start by observing that at stage 0,the array segment consisting of the single element a[0] is sorted.Now suppose that at the stage k,the segment a[0..k] is sorted.Take the element a[k+1],and call it X.By moving some of the elements in a[0..k] one place to the right,create a place to put X in so that now a[0..k+1] is sorted.The algorithm that uses this strategy is called

When applied to an array a[ ] of integers,the pseudo code Boolean sort = true Int k = 0 While sort == true and k < a.length-1 If a[k] > a[k+1] Then Sort = false End If K = k +1 End While

An array a[ ] of N elements is being sorted using the insertion sort algorithm.The algorithm is at the last stage,with the segment of the array in positions 0 through N-2 already sorted.How many array elements will a[N-1] have to be compared to,before it can be placed into its proper position?

Let F be an algorithm with complexity function f(n),and let G be an algorithm with complexity function g(n).If there exists a positive constant K such that the ratio f(n)/g(n)is less or equal to K for all n greater or equal to 1,then

The selection sort algorithm works by

Binary Search is in the complexity class

Consider the following implementation of insertion sort: Public static void insertionSort(int [ ] array){ Int unsortedValue;// The first unsorted value Int scan;// Used to scan the array // The outer loop steps the index variable through // each subscript in the array,starting at 1.This // is because element 0 is considered already sorted. For (int index = 1;index < array.length;index++){ // The first element outside the sorted segment is // array[index].Store the value of this element // in unsortedValue UnsortedValue = array[index]; // Start scan at the subscript of the first element // outside the sorted segment. Scan = index; // Move the first element outside the sorted segment // into its proper position within the sorted segment. While (scan > 0 && array[scan-1] > unsortedValue){ Array[scan] = array[scan - 1]; Scan --; } // Insert the unsorted value in its proper position // within the sorted segment. Array[scan] = unsortedValue; } } This method uses the < and > operators to compare array subscripts,as when index is compared against the length of the array,a.length.The method also uses these operators to compare array elements against each other,for example,in an expression such as a[scan-1] >unSortedValue.What would happen if we change every < operator to >,and change every > operator to < ?

The insertion sort algorithm works by

A search for an item X in an array starts at the lower end of the array,and then looks for X by comparing array items to X in order of increasing subscript.Such a method is called

If lower is the first subscript in a contiguous portion of an array,and upper is the last subscript,then the array item in the middle of that array portion is at subscript

A contigous segment of an array is given by specifying two subscripts,lower and upper.Which of the following expressions gives the subscript of the array element that is three quarters of the way from lower to upper?

Assuming a method Int findMax(int array[ ],int last)that returns the subscript of the largest value in the portion of an array whose elements are at 0 through last (inclusive),a recursive method for sorting in ascending order a portion of an array between 0 and last,inclusive,can be written as follows: Void rSort(int array[ ],int last){ If (last >= 1){ // Missing code } } If a method Void swap(int array[ ],int pos1,int pos2)can be used to swap the contents of two array entries,then the logic for the missing code is

Let F be an algorithm with complexity function f(n),and let G be an algorithm with complexity function g(n).If the ratio f(n)/g(n)converges to infinity as n increases to infinity,then

The binary search algorithm

Linear time is the class of all complexity functions that are in

The compareTo method of the Comparable interface

For a computational problem,the input size

The best method for searching an array that is not sorted is

If an array is known to be sorted,it can be searched very quickly by using