sequential (linear) binary selection insertion merge
TRANSCRIPT
• 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).