Lecture 14 Objectives

Java Programming: From Problem Analysis to Program Design, Second Edition 1

Lecture 14 Objectives

Learn how to implement the sequential search algorithm.

Explore how to sort an array using bubble sort, selection sort, and insertion sort algorithms.

Learn how to implement the binary search algorithm. Become aware of the class Vector. Learn more about manipulating strings using the class String.


List Processing

List: A set of values of the same type. Basic operations performed on a list:

Search list for given item. Sort list. Insert item in list. Delete item from list.


Search

Necessary components to search a list: Array containing the list. Length of the list. Item for which you are searching.

After search completed: If item found, report “success” and return location in

array. If item not found, report “failure.”


Searchpublic static int seqSearch(int[] list, int listLength, int searchItem){ int loc; boolean found = false; for (loc = 0; loc < listLength; loc++) if (list[loc] == searchItem) { found = true; break; } if (found) return loc; else return -1;}


Sorting a List

Bubble sort Suppose list[0...n - 1] is a list of n elements, indexed 0 to n - 1. We want to rearrange (sort) the elements of list in increasing order. The bubble sort algorithm works as follows:

In a series of n - 1 iterations, the successive elements, list[index] and list[index + 1], of list are compared. If list[index] is greater than list[index + 1], then the elements list[index] and list[index + 1] are swapped (interchanged).


Bubble Sort


public static void bubbleSort(int list[], int listLength){ int temp; int counter, index; for (counter = 0; counter < listLength - 1; counter++) { for (index = 0; index < listLength - 1 – counter; index++) if (list[index] > list[index + 1]) { temp = list[index]; list[index] = list[index + 1]; list[index + 1] = temp; } }}

Bubble Sort


For a list of length n, an average bubble sort makes n(n – 1) / 2 key comparisons and about n(n – 1) / 4 item assignments.

Therefore, if n = 1000, bubble sort makes about 500,000 key comparisons and about 250,000 item assignments to sort the list.

Bubble Sort


Selection Sort

List is sorted by selecting list element and moving it to its proper position.

Algorithm finds position of smallest element and moves it to top of unsorted portion of list.

Repeats process above until entire list is sorted.


Selection Sort


public static void selectionSort(int[] list, int listLength){ int index; int smallestIndex; int minIndex; int temp; for (index = 0; index < listLength – 1; index++) { smallestIndex = index; for (minIndex = index + 1; minIndex < listLength; minIndex++) if (list[minIndex] < list[smallestIndex]) smallestIndex = minIndex;

temp = list[smallestIndex]; list[smallestIndex] = list[index]; list[index] = temp; }}

Selection Sort


For a list of length n, an average selection sort makes n(n – 1) / 2 key comparisons and 3(n – 1) item assignments.

Therefore, if n = 1000, selection sort makes about 500,000 key comparisons and about 3000 item assignments to sort the list.

Selection Sort


Insertion Sort

The insertion sort algorithm sorts the list by moving each element to its proper place.


Insertion Sort


public static void insertionSort(int[] list, int noOfElements){ int firstOutOfOrder, location; int temp; for (firstOutOfOrder = 1; firstOutOfOrder < noOfElements; firstOutOfOrder++) if (list[firstOutOfOrder] < list[firstOutOfOrder - 1]) { temp = list[firstOutOfOrder];

location = firstOutOfOrder; do { list[location] = list[location - 1]; location--; } while(location > 0 && list[location - 1] > temp); list[location] = temp; }} //end insertionSort

Insertion Sort


For a list of length n, on average, the insertion sort makes (n2 + 3n – 4) / 4 key comparisons and about n(n – 1) / 4 item assignments.

Therefore, if n = 1000, the insertion sort makes about 250,000 key comparisons and about 250,000 item assignments to sort the list.

Insertion Sort


Sequential Ordered Searchpublic static int seqOrderedSearch(int[] list, int listLength, int searchItem){ int loc; //Line 1 boolean found = false; //Line 2 for (loc = 0; loc < listLength; loc++) //Line 3 if (list[loc] >= searchItem) //Line 4 { found = true; //Line 5 break; //Line 6 } if (found) //Line 7 if (list[loc] == searchItem) //Line 8 return loc; //Line 9 else //Line 10 return -1; //Line 11 else //Line 12 return -1; //Line 13}


Binary Search

Can only be performed on a sorted list. Uses divide and conquer technique to search list. If L is a sorted list of size n, to determine whether

an element is in L, the binary search makes at most 2 * log2n + 2 key comparisons. (Faster than a sequential search.)


Binary Search Algorithm

Search item is compared with middle element of list.

If search item < middle element of list, search is restricted to first half of the list.

If search item > middle element of list, search is restricted to second half of the list.

If search item = middle element, search is complete.


Binary Search AlgorithmDetermine whether 75 is in the list.


public static int binarySearch(int[] list, int listLength, int searchItem){ int first = 0; int last = listLength - 1; int mid; boolean found = false; while (first <= last && !found) { mid = (first + last) / 2; if (list[mid] == searchItem) found = true; else if (list[mid] > searchItem) last = mid - 1; else first = mid + 1; } if (found) return mid; else return –1;} //end binarySearch

Binary Search Algorithm


Vectors

The class Vector can be used to implement a list.

Unlike an array, the size of a Vector object can grow/shrink during program execution.

You do not need to worry about the number of data elements in a vector.


Members of the class Vector


Vectors Every element of a Vector object is a reference

variable of the type Object. To add an element into a Vector object:

Create appropriate object. Store data into object. Store address of object holding data into Vector

object element.


Vector<String> stringList = new Vector<String>();

stringList.addElement("Spring");stringList.addElement("Summer");stringList.addElement("Fall");stringList.addElement("Winter");

Vectors


Programming Example: Election Results

Input: Two files File 1: Candidates’ names File 2: Voting data

Voting data format: candidate_name region# number_of_votes_for_this_candidate



Output: Election results in a tabular form. Each candidate’s name. Number of votes each candidate received in each

region. Total number of votes each candidate received.


Programming Example:Election Results (Solution)

The solution includes: Reading the candidates’ names into the array

candidateName. A two-dimensional array consisting of the votes by

region. An array consisting of the total votes parallel to the

candidateName array.


Programming Example:Election Results (Solution)

Sorting the array candidatesName. Processing the voting data. Calculating the total votes received by each

candidate. Outputting the results in tabular form.


Additional String Methods


Effects of Some String Methods


Programming Example: Pig Latin Strings

If string begins with a vowel, “-way” is appended to it. If first character is not a vowel:

Add “-” to end. Rotate characters until the first character is a vowel. Append “ay.”

Input: String Output: String in pig Latin


Programming Example: Pig Latin Strings (Solution)

Methods: isVowel, rotate, pigLatinString Use methods to:

Get the string (str). Find the pig Latin form of str by using the method pigLatinString.

Output the pig Latin form of str.


Programming Example: Pig Latin Strings (Sample Runs)


Lecture 14 Summary Lists Searching lists:

Sequential searching Sequential searching on an order list Binary search

Sorting lists: Bubble sort Selection sort Insertion sort


Lecture 14 Summary

Programming examples The class Vector

Members of the class Vector The class String

Additional methods of the class String

Lecture 14 Objectives

Documents

Transcript of Lecture 14 Objectives