Download presentation
Presentation is loading. Please wait.
Published byLee Simpson Modified over 9 years ago
1
FASTER SORT using RECURSION : MERGE SORT 2015-T2 Lecture 15 School of Engineering and Computer Science, Victoria University of Wellington COMP 103 Marcus Frean
2
RECAP-TODAY RECAP Recursion TODAY Fast Sorts: Divide and Conquer Merge Sort (and analysis) Announcements Assignment #5: came out last Friday, but is due Friday 11 th Sept (ie. you get a really loooong time to complete it) Mid-term test: is this Friday 2
3
3 the test this Friday 20% of final grade, and takes 45 mins RoomsFROM TO Maclaurin 101A J Maclaurin 102K M Hunter 323N Z Please be on time, and bring your ID card. “Not-quite-Exam conditions”: keep a vacant seat between each put your ID card where it can be seen – at the end of the row. (no need to leave bags at the front) What’s in? everything up to and including Recursion old tests are a guide for what to expect
4
4 Stresses and strains 1 st year is stressful to most people. How’s your “mental health” and how well connected are you socially? Do any of the following resonate? freaked out, wound up flat, exhausted lonely, vulnerable just all over the place it’s normal in “doses”, but if this is you much of the time, that’s not ideal. Talking to a trained person (student health) is great, but there’s a long wait. If you’re struggling academically (e.g. you might not make 7 assignments, or you do badly on tomorrow’s test), then : omg-help@ecs.vuw.ac.nz knock on Craig’s door: CO 253 (Cotton building) 4
5
5 Well-being: some homework connect talk and listen, be there, feel connected be active do what you can do, enjoy what you do, move your mood take notice re-remembering the simple things that give you joy : good but the opposite (ruminating) : sucketh 5 And these are No-brainers for keeping a resilient brain: sleep intake under control (caffeine, booze, sugar) exercise for fun: waitbutwhy.com especially “Taming the mammoth”, and “The procrastination matrix”
6
6 Insertion sort, Selection Sort, Bubble Sort: All slow (except Insertion sort on almost sorted lists) O(n 2 ) Problem: Insertion and Bubble only compare adjacent items only move items one step at a time Selection compares every pair of items ignores results of previous comparisons. Solution: Must compare and swap items at a distance Must not perform redundant comparisons Slow Sorts
7
7 Divide and Conquer Sorts To Sort: Split Sort each part (recursive) Combine Where does the work happen ? MergeSort: split is trivial combine does all the work QuickSort: split does all the work combine is trivial Array Sorted Array Split Combine SubArray SortedSubArray Sort Split Combine SubArray Sort SortedSubArray Split Combine SubArray Sort SortedSubArray
8
8 MergeSort : the concept
10
10 MergeSort : the order when recursing...
11
11 67891011012345 MergeSort: the ‘merge’ method 67891011 012345 “from” array “to” array
12
12 Merge /** Merge from[low..mid-1] with from[mid..high-1] into to[low..high-1.*/ private static void merge(E[] from, E[] to, int low, int mid, int high, Comparator comp){ int index = low; // where we will put the item into "to“ int indxLeft = low; // index into the lower half of the "from" range int indxRight = mid; // index into the upper half of the "from" range while (indxLeft<mid && indxRight < high){ if (comp.compare(from[indxLeft], from[indxRight]) <=0) to[index++] = from[indxLeft++]; else to[index++] = from[indxRight++]; } // copy over the remainder. Note only one loop will do anything. while (indxLeft<mid) to[index++] = from[indxLeft++]; while (indxRight<high) to[index++] = from[indxRight++]; }
13
13 MergeSort – a wrapper method that starts it It looks like we an extra temporary array for each “level” (how many levels are there?) Somewhat REMARKABLY, it turns out we only need one (extra), and at each layer we can treat the other array as “storage” We start with a wrapper makes this second array, and fills it with a copy of the original data. public static void mergeSort(E[] data, int size, Comparator comp){ E[] other = (E[])new Object[size]; for (int i=0; i<size; i++) temp[i]=data[i]; mergeSort(data, temp, 0, size, comp); }
14
14 MergeSort – the recursive method private static void mergeSort(E[] data, E[] other, int low, int high, Comparator comp){ // sort items from low..high-1, using the other array if (high > low+1){ int mid = (low+high)/2; // mid = low of upper 1/2, = high of lower half. mergeSort(other, data, low, mid, comp); mergeSort(other, data, mid, high, comp); merge(other, data, low, mid, high, comp); } there are multiple calls to the recursive method in here. this will make a "tree" structure we swap other and data at each recursive call (= each “level”)
15
15 MergeSort: recursion ms(d, t, 0,16) ms(t, d, 0,8)ms(t, d, 8,16)mg(t, d, 0,8,16) ms(d,t,0,4) ms(d,t,4,8) mg(d,t,0,4,8) ms(t,d,0,2) ms(t,d,2,4) mg(t,d,0,2,4) ms(d,t,0,1) ms(d,t,1,2) mg(d,t,0,1,2) ms(d,t,2,3) ms(d,t,3,4) mg(d,t,2,3,4) ms(t,d,4,6) ms(t,d,6,8) mg(t,d,4,6,8) ms(d,t,4,5) ms(d,t,5,6) mg(d,t,4,5,6) ms(d,t,6,7) ms(d,t,7,8) mg(d,t,6,7,8) ms(d,t,8,12) ms(d,t,12,16) mg(d,t,0,8,16) (...)
16
16 MergeSort – will the two arrays 'mess up'? data to sort other to sort 'working' 'working' merge 'working' merge to sort
17
17 data [p a1 r f e q2 w q1 t z2 x c v b z1 a2 ] 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 msort(0..16) [p a1 r f e q2 w q1 t z2 x c v b z1 a2 ] msort(0..8) [p a1 r f e q2 w q1 ] msort(0..4 ) [p a1 r f ] msort(0..2 ) [p a1 ] msort(0..1 ) [p ] msort(1..2) [ a1 ] merge(0.1.2) [a1 p ] msort(2..4) [ r f ] msort(2..3) [ r ] msort(3..4) [ f ] merge(2.3.4) [ f r ] merge(0.2.4) [a1 f p r ] msort(4..8) [ e q2 w q1 ] msort(4..6) [ e q2 ] : : merge(4.5.6) [ e q2 ] msort(6..8) [ w q1 ] : : merge(6.7.8) [ q1 w ] merge(4.6.8) [ e q2 q1 w ] merge(0.4.8) [a1 e f p q2 q1 r w ] msort(8..16) [ t z2 x c v b z1 a2 ] : : merge(8.12.16) [ a2 b c t v x z1 z2 ] merge(0.8.16) [a1 a2 b c e f p q2 q1 r t v w x z1 z2 ]
18
18 Sorting Algorithm costs: Insertion sort, Selection Sort: All slow (except Insertion sort on almost-sorted lists) O(n 2 ) Merge Sort ? There’s no inner loop! How do you analyse recursive algorithms?
19
19 MergeSort private static void mergeSort (E[ ] data, E[ ] other, int low, int high, Comparator comp) { if (high > low+1) { int mid = (low+high)/2; mergeSort(other, data, low, mid, comp); mergeSort(other, data, mid, high, comp); merge(other, data, low, mid, high, comp); } } Cost of mergeSort: Three steps: first recursive call second recursive call merge: has to copy over (high-low) items
20
20 MergeSort Cost Level 1:2 * n/2= n Level 2:4 * n/4= n Level 3:8 * n/8= n Level 4:16 * n/16= n so in general, at any level k, there are n comparisons How many levels ? the number of times you can halve n is log n Total cost? = O( ) n = 1,000 n = 1,000,000
21
21 Analysing with Recurrence Relations private static void mergeSort(E[] data, E[] other, int low, int high, Comparator comp){ if (high > low+1){ int mid = (low+high)/2; mergeSort(other, data, low, mid, comp); mergeSort(other, data, mid, high, comp); merge(other, data, low, mid, high, comp); } } Cost of mergeSort = C(n) C(n) = C(n/2) + C(n/2) + n = 2 C(n/2) + n Recurrence Relation: (we will) Solve by repeated substitution & find pattern (we could) Solve by general method
22
22 Solving Recurrence Relations C(n) = 2 C(n/2) + n = 2 [ 2 C(n/4) + n/2] + n = 4 C(n/4) + 2 n = 4 [ 2 (C(n/8) + n/4] + 2 n = 8 C(n/8) + 3 n = 16 C(n/16) + 4 n : = 2 k C( n/2 k ) + k * n when n = 2 k, k = log(n) = n C (1) + log(n) * n and since C(1) = 0, C(n) = log(n) * n http://www.youtube.com/watch?v=XaqR3G_NVoo
Similar presentations
© 2025 SlidePlayer.com. Inc.
All rights reserved.