Searching in General

Transcription

1 Searching in General Searching 1. using linear search on arrays, lists or files 2. using binary search trees 3. using a hash table 4. using binary search in sorted arrays (interval halving method). Data Structures, Sorting 1

2 Interval halving method Searching Given a sorted array a, we want an element in a equally big as x. Let low and high be lowest and highest index, respectivly, in the array. while low < high let mid be (low + high) div 2 if a[mid] < x let low be mid + 1 else let high be mid check if a[high] is as big as x If n is the number of elements in the array a and since we always split the problem to half its size, the algorithm is of O( 2 log n) Data Structures, Sorting 2

3 Why splitting in two equal segments? Searching If you split by 1 half you get: 50 % chans to be in the smaller part, and then you have decrased the size of the problem by 50 %. The same goes if you have the bigger part, so in average you decreased the size of the problem to: = 1 2 If you split by one third or one fourth you get: = 5 9 = 5 8 Data Structures, Sorting 3

4 The most common sorting algorithms 1. Insertion sort 2. Selection sort 3. Bubble sort 4. Merge sort 5. Quick sort 6. Adress sort, (bucket sort, hashing) 7. Radix sort 8. Heap sort (priority queues) 9. Binary search trees Data Structures, Sorting 4

5 Complexity When analyzing the complexity, we start analizing: the worst case (WC) and the best case (BC). If WC and BC have different Big O-complexity, we also analyze: the average case (AC) Data Structures, Sorting 5

6 Insertion Sort Sortings Algorithms Given an array a to be sorted. let i = smallest index + 1 while i highest index. if a[i] < a[i 1] let temp = a[i], a[i] = a[i 1] and j = i 1 while j > smallest index and a[j 1] > temp let a[j] = a[j 1] decrease j by 1 let a[j] = temp increase a[i] by 1 Data Structures, Sorting 6

7 Insertion Sort Complexity The best case: Its obviously when the array is already sorted. Only the if-condition is computed. If size n = a.length, we get: n 1 i=0 1 = n O(n), i.e. linear The worst case: When the array is sorted reversely. Gives: n 1 i=0 i j=1 1 = n 1 i=0 i = n (n 1) 2 O( n 2 ), i.e. quadratic Data Structures, Sorting 7

8 Insertion sort Complexity The average case: Assume that the inner loop only goes halfways, then we get: n 1 i=0 i 2 j=1 1 =... = N (N 1) 4 O(n 2 ), i.e. still quadratic Data Structures, Sorting 8

9 Selection Sort Given an array a to be sorted: let n be the number of not sorted elements in a while n > 1 search for index, i, of the biggest element in the segment of not sorted elements of a, swap the elements under i and the last element in segment i.e. the element most right of the not sorted elements decrease n, i.e. the number of unsorted elements, by 1 Data Structures, Sorting 9

10 Selection Sort Complexity Here we always have the same amount of work: n 1 i=0 i = n (n 1) 2 O( n 2 ), i.e. quadratic Data Structures, Sorting 10

11 Simple Version of Quick Sort Sorting Algorihtms quicksort( a,low, high) sort the segment low.. high-1 in the array a swap elements under low and low+high 2 (pivot element) let i low+1, j high while i < j while a[i] a[low] increment i by 1 while a[j 1] > a[low] decrement j by 1 if i < j, swap elements under i and j 1 swap elements under low and j 1 quicksort(a,low, i 1) quicksort(a, i, high) Data Structures, Sorting 11

12 Quick Sort Complexity Worst Case: Will occure when we always choose the smallest element as pivot element. Then the size of the of the segment to sort decreases only by 1 for each recursion. I.e. n 1 i=1 i = n (n 1) 2 O( n 2 ), i.e. quadratic Best Case: When we always split the segment in half. I.e. the recursion depth become 2 log n, so we get: 2 log n n i = n 2 log n 2 log n i O( n 2 log n ) i=1 i=1 Data Structures, Sorting 12

13 Quick Sort Complexity Average Case: Assuming that all permutations have the same probability yields approximately: 3+ 2 log n n i = n (3 + 2 log n) 3+ 2 log n i O(n 2 log n ) i=1 i=1 Data Structures, Sorting 13

14 Merge Sort Given a list to sort. construct a list of lists, where each list contains one of the elements of s, respectively. merge the lists pairwise until only one list remains! The merging algorithm: Let xxs and yys be two sorted lists If any of the two lists is empty, let the result of merge( xxs, yys) be the other list. Otherwise: let x : xs xxs and y : ys yys and perform: merge( x : xs, y : ys) if x < y let the resulting list be x : merge( xs, yys ) otherwise: let the resulting list be y : merge( xxs, ys ) Data Structures, Sorting 14

15 Merge Sort Complexity As for selection sort the amount of work is always the same. In each round of the loop the length of the lists will double, and every element is handled in each round, i.e. we get: 2 log n i=1 n = n 2 log n O( n 2 log n ) Data Structures, Sorting 15

16 Comparing in Java Comparing in Java In Java we have 3 main way of comparing the size. By the operators <, >, ==,..., only for values. By the natural order, i.e. the method compareto for all objects of a type which is a subtype of, i.e. implementing, interface Comparable< T >. By defining a Comparator<T>, and use its method compare, where you can choose any criteria you wish deciding the size. (Or the subclass Collator of Comparator<T> if you are working with String:s) Data Structures, Sorting 16

17 Sorting an Integer Array in Reverse Order Comparing in Java Define a Comparator: import java.util.*; public class RevOrderInt implements Comparator<Integer> { public int compare( Integer i1, Integer i2 ) { return i2.compareto(i1); // or return i2 - i1; } } and then, in order to reversely sort array ia use the code: Arrays.sort( ia, new RevOrderInt() ); Data Structures, Sorting 17

18 A More General Reversing Comparator Comparing in Java public class ReverseOrder<T extends Comparable<? super T>> implements Comparator<T> { } public int compare( T o1, T o2 ) { return o2.compareto( o1 ) } and then use: Arrays.sort( ia, new ReverseOrder<Integer>() ); Data Structures, Sorting 18