Sequential (Linear) Binary Selection Insertion Merge.

• Sequential (Linear)• Binary

• Selection• Insertion• Merge

• Suppose you have a telephone book and you want to search for a person’s telephone number. You know the person’s first and last name. How difficult is this?

• Suppose you have the same telephone book and you want to find a person that has a certain telephone number. How would you find it? Why is this more difficult?

• The Linear Search searches through a list sequentially (one element at time) looking for a match.

• The index position of a match is returned if found or -1 is returned if no match is found.

• It must go through the entire list in order to determine if there is no match.

int linearSearch(int[] stuff, int val){ for(int i=0; i< stuff.length; i++) { if (stuff[i] == val ) return i; } return -1; //returns -1 if not found}

// Suppose we have an array of names (Strings)int linearSearch(String[] stuff, String searchValue){ for(int i=0; i<stuff.length; i++) { if (stuff[i].equals(searchValue)) // OR if (stuff[i].compareTo(searchValue)==0)

return i; } return -1; //returns -1 if not found}// Note: same as linear search with primitives except // you use equals method instead of ==

// Can be generalized to work with any object, not // only Strings. Just substitute Object for String in// the parameter listint linearSearch(Object[] stuff, Object searchValue){ for(int i=0; i<stuff.length; i++) { if (stuff[i].equals(searchValue)) // OR if (stuff[i].compareTo(searchValue)==0)

return i; } return -1; //returns -1 if not found}

• The Linear/Sequential Search works fine if the array is relatively small (a few hundred elements). However, if the array is large, it could become slow.

• Average number of elements searched is n/2, where n is the array length.

• This search method works fine when the array is sorted or even when it is not sorted.

Hint: Sort the array by using Arrays.sort(arrayName);

0100100101

• The method of linear search works well for arrays that are fairly small (a few hundred elements).

• As the array gets very large (thousands or millions of elements), the behavior of the search degrades.

• When we have an array of elements that are in ascending order, such as a list of numbers or names, there is a much better way to proceed, using an algorithm known as binary search.

• This method is much faster than linear search for very large arrays.

• The Binary Search is only guaranteed to work with sorted lists (normally in ascending order).

• The basic idea of binary search is to examine the element at the array's midpoint on each pass through the search loop.

• If the current element matches the search value, we return its position

• If the current element is less than the search value, then we search the part of the array to the right of the midpoint (containing the positions of the greater items).

• Otherwise, we search the part of the array to the left of the midpoint (containing the positions of the lesser items).

• On each pass through the loop, the current leftmost position or the current rightmost position is adjusted to track the portion of the array being searched.

int binarySearch (int [] stuff, int searchValue ){ int bot= 0, top = stuff.length-1; while(bot<=top) { int middle = (bot + top) / 2; if (stuff[middle] == searchValue ) return middle; else { if (stuff[middle] > searchValue ) top = middle-1; else bot = middle+1; } } return -1;}

int[] stuff = {1, 6, 8, 10, 14, 22, 30, 50};

If you are searching for 25, how many times will you check stuff?

0 + 7 = 7 / 2 = 3stuff[3] = 10

4 + 7 = 11 / 2 = 5stuff[5] = 22

6 + 7 = 13 / 2 = 6stuff[6] = 30

1st pass

2nd pass

3rd pass

Given a list of N items.

What is the next largest power of 2?

If N is 100, the next largest power of 2 is 7.

Log2(100) = 6.64386

27 = 128.

It would take 7 checks max to determine if an item existed in a list of 100 items.

• Have 3 volunteers come to the front of the room and look at 3 different telephone books

• Each volunteer should report the number of pages in the book for that city

• Each volunteer should look for the same name (for example David Daniels) by simulating a binary search

• Report how many times they have to check a page before finding the page that contains the name

• Selection sort swaps the current element with the lowest element from the remaining elements in the list.

• Selection Sort does not swap each time it finds elements out of position.

• Selection sort makes a complete pass while searching for the next item to swap.

• At the end of a pass once the item is located, one swap is made.

original 9 2 8 5 1

0 1 2 3 4

pass 1 1 2 8 5 9

pass 2 1 2 8 5 9

pass 3 1 2 5 8 9

pass 4 1 2 5 8 9

Array length is 5. Number of passes = 5 – 1 = 4

public void selectionSort( int[] ray ){ for(int i=0; i< ray.length-1; i++) { int min = i; //min = location of lowest value for(int j = i+1; j< ray.length; j++) { if(ray[j] < ray[min])

min = j; //find location of lowest value } if( min != i) {

int temp = ray[min]; ray[min] = ray[i]; ray[i] = temp; //put lowest value in pos i

} }}

public void selSort(Car[] cars){ for(int i=0; i<cars.length-1; i++) { int spot = i; for(int j=i+1; j<cars.length; j++) { if(cars[j].compareTo(cars[spot])<0) spot = j; } if(spot==i) continue; //skip remaining lines; go to top of loop

Car save = cars[i]; cars[i] = cars[spot]; cars[spot] = save; } }

public void selSort(Car[] cars){ for(int i=0; i<cars.length-1; i++) { int spot = i; for(int j=i+1; j<cars.length; j++) { if(cars[j].compareTo(cars[spot])>0) spot = j; } if(spot==i) continue; //skip remaining lines; go to top of loop

Car save = cars[i]; cars[i] = cars[spot]; cars[spot] = save; } }

Original List Integer[] ray = {90,40,20,30,10,67};

pass 1 - 90 40 20 30 10 67pass 2 - 90 67 20 30 10 40pass 3 - 90 67 40 30 10 20pass 4 - 90 67 40 30 10 20pass 5 - 90 67 40 30 20 10

• Selection sort is pretty effective for small lists, but pretty horrible if used on large lists

• Selection sort consists of two loops

• The outer loops run based on the number of items in the list

• The inner loop runs to find the items that need to be moved

• The inner loop either locates the spot with the smallest value or the spot with the largest value (depending on whether you are sorting it in ascending or descending order)

• After the inner loop completes, a swap may occur if needed

• At most, selection sort will make one swap per pass

• A pass is one complete execution of the inner loop

• The insertion sort first selects an item and moves items up or down based on the comparison to the selected item.

• The idea is to get the selected item in proper position by shifting items around in the list.

• This is analogous to the way some people pick up playing cards and order them in their hands.

original 9 2 8 5 1

0 1 2 3 4

after pass 1 15892

after pass 2 15982

after pass 3 19852

after pass 4 98521

Blue signifies elements checked during the pass. They are sorted relative to each other.Highlighted element is the one inserted during the pass.

void insertionSort( int[] stuff){ for (int i=1; i< stuff.length; i++) { int val = stuff[i]; //item to insert

int j=i; while(j>0 && val<stuff[j-1]) { stuff[j] = stuff[j-1]; j--; } stuff[j]=val; }}

void insertionSort( String[] stuff ){ for (int i=1; i< stuff.length; i++) { String val = stuff[i]; //item to insert

int j=i; while(j>0 && val.compareTo(stuff[j-1])<0) { stuff[j] = stuff[j-1]; j--; } stuff[j]=val; }}

public class Box implements Comparable{ private double volume;

//constructor and other methods not listed

public int compareTo(Object obj) { Box otherBox = (Box) obj; if (volume < otherBox.volume) return -1; if (volume == otherBox.volume) return 0; return 1; }}

• Sorting cards: http://www.youtube.com/watch?v=gTxFxgvZmQs&NR=1 

• Sorting bars:http://www.youtube.com/watch?v=kSyJb-EfNVI&feature=related 

• Demo of Selection sort and insertion sort:http://www.cs.oswego.edu/~mohammad/classes/csc241/samples/sort/Sort2-E.html

• Comparing many different sort algorithms:http://cg.scs.carleton.ca/~morin/misc/sortalg/

• Racing different sort algorithms http://www.cs.bme.hu/~gsala/alg_anims/2/sortchoiceinp.html

• Java sorting overview:http://www.javamex.com/tutorials/collections/sorting_java_algorithm_performance.shtml

• Insertion Sort is normally more efficient than a Selection Sort

• Insertion Sort continually sorts the left side of the list while gradually moving to the end.

• This type of sort is similar to how many people sort cards in their hands

Arrays classfrequently used methods for arrays

Name Usesort(x) puts all items in array x in ascending

order

binarySearch(x,y) Prerequisite: array x must be sorted. Checks x for the location of y. This method returns the index where y is found. If y is not found, it returns -1 minus the position in the array list where x would be added.

equals(x,y) checks if arrays x and y have same values

fill(x, y) fills all spots in array x with value y

This is the array sort method you should use in your programs. It uses a Quicksort algorithm.

Collections classfrequently used methods for array lists

Name Usesort(x) puts all items in array list x in ascending

order

binarySearch(x,y) Prerequisite: array list x must be sorted. Checks x for the location of y. This method returns the index where y is found. If y is not found, it returns -1 minus the position in the array list where x would be added.

fill(x,y) fills all spots in array list x with value y

rotate(x,y) shifts items in array list x left or right y spots

reverse(x) reverses the order of the items in array list xThis is the sort method you should use for ArrayLists

It uses a Mergesort algorithm.

String s = "abcdefghijklmnop";System.out.println(s.indexOf(“R"));

int[] ray = {3,4,5,6,11,18,91};System.out.println(Arrays.binarySearch(ray,5));

int[] ray = {3,4,5,6,11,18,91};System.out.println(Arrays.binarySearch(ray,15));

OUTPUT

-12-6

int[] ray = {13,6,17,18,2,-5};Arrays.sort(ray);

for(int i = 0; i < ray.length; i++){ System.out.println(ray[i]);}

OUTPUT-526131718

ArrayList<Integer> ray; ray=new ArrayList<Integer>();ray.add(21);ray.add(2);ray.add(13);ray.add(-1);ray.add(3);Collections.sort(ray);

for(int num : ray ) System.out.println(num);

OUTPUT-1231321

public class Athlete implements Comparable{ private String lastName, firstName; //constructor and other methods not listed

public int compareTo(Object obj) { Athlete otherAthlete = (Athlete) obj; if (lastName.compareTo(other Athlete.lastName)<0) return -1; if (lastName.compareTo(other Athlete.lastName)>0) return 1; return 0; }}

ArrayList<Athlete> list; list=new ArrayList<Athlete>();list.add(new Athlete(“Bob”,”Smith”));list.add(new Athlete(“Tom”,”Jones”));list.add(new Athlete(“Sue”,”Adams”));list.add(new Athlete(“Joe”,”Bass”));list.add(new Athlete(“Sara”,”Weiss”));Collections.sort(list);

for(Athlete athlete : list ) System.out.println(athlete);

OUTPUTSue AdamsJoe BassTom JonesBob SmithSara Weiss

• Athlete object class needs to implement Comparable• Have to redefine compareTo() method• toString() method will make the print work as desired

int[] intArray = {9, 2, 4, -12}; Arrays.sort(intArray); // [-12, 2, 4, 9]

String[] strArray = {"y", "b", "H"};Arrays.sort(strArray); // [H, b, y]

// Case-insensitive sort Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); // [b, H, y]

// Reverse-order sort Arrays.sort(strArray, Collections.reverseOrder()); // [y, b, H]

// Case-insensitive reverse-order sort Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); Collections.reverse(Arrays.asList(strArray)); // [y, H, b]

Widget Corp.

Store A Store B Store C

Register 1

Register 2

Money

Money

Money

Money

Money

Money

Money

Money

What is the difference?

i++ assigns i value before incrementing:int[] array = {10, 20, 30, 40};i = 0;System.out.println(array[i]);System.out.println(array[i++]);System.out.println(array[i]);

++i assigns i value after incrementing:int i = 0;System.out.println(array[i]);System.out.println(array[++i]);System.out.println(array[i]);

OUTPUT

101020

OUTPUT

102020

32

16 16

8 8 8 8

4 4 4 4 4 4 4 4

• Merge sort splits the list into smaller sections working its way down to groups of two or one.

• Once the smallest groups are reached, the merge method is called to organize the smaller lists.

• Merge copies from the sub list to a temp array.

• The items are put in the temp array in sorted order.

1 . . 32

1 . . 16 17 . . 32

17 . .25 26 . . 321 . . 8 9. . 16

Merge sort chops in half repeatedly to avoid processing the whole list at once.

void mergeSort(Comparable[] stuff, int front, int back){ int mid = (front+back)/2; if(mid==front) return; mergeSort(stuff, front, mid); mergeSort(stuff, mid, back); merge(stuff, front, back);}

Collections.sort( ) uses mergeSort.

Arrays.sort( ) uses mergeSort for objects.

void merge(Comparable[] stuff, int front, int back) {

Comparable[] temp = new Comparable[back-front]; int i = front, j = (front+back)/2, k =0, mid =j; while( i<mid && j<back)

{ if(stuff[i].compareTo(stuff[j])<0) temp[k++]= stuff[i++]; else temp[k++]= stuff[j++]; } while(i<mid) temp[k++]= stuff[i++]; while(j<back) temp[k++]= stuff[j++]; for(i = 0; i<back-front; ++i) stuff[front+i]=temp[i];}

Original List Integer[] stuff = {90,40,20,30,67,10};

pass 1 - 90 20 40 30 67 10pass 2 - 20 40 90 30 67 10pass 3 - 20 40 90 30 10 67pass 4 - 20 40 90 10 30 67pass 5 - 10 20 30 40 67 90

The mergeSort method alone has a Log2N run time, but cannot be run without the merge method.

The merge method alone has an N run time and can be run without the mergeSort method.

Racing the Sort Algorithms:

http://cg.scs.carleton.ca/~morin/misc/sortalg/

http://www.cs.ubc.ca/~harrison/Java/sorting-demo.html

http://www.cs.bme.hu/~gsala/alg_anims/2/sortchoiceinp.html

Name Best Case Avg. Case Worst

Selection Sort

Insertion Sort

Merge Sort

@ If the data is sorted, Insertion sort should only make one pass through the list. If this case is present, Insertion sort would have a best case of O(n).