cs 332: algorithms - gabriel istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2...
TRANSCRIPT
![Page 1: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/1.jpg)
1
Algorithms
Quicksort
Slide credit: David Luebke (Virginia)
![Page 2: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/2.jpg)
2
Sorting revisited
We have seen algorithms for sorting: INSERTION-SORT, MERGESORT
More generally: given a sequence of items
Each item has a characteristic called sorting key. The values of the sorting key belong to a set on which there exists a total order relationship
Sorting the sequence = arrange its elements such that the sorting keys are in increasing (or decreasing) order
![Page 3: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/3.jpg)
3
Sorting revisited
Other assumptions:
We shall consider that the sequence is stored in a random access memory (e.g. in an array)
This means that we will discuss about internal sorting
We shall analyze only sorting methods which are in place (the additional space needed for sorting has at most the size of an element/few elements.
Stability: preserves ordering of elements with identical keys
![Page 4: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/4.jpg)
4
Stability
Example: Initial configuration:
((Adam,9), (John, 10), (Peter,9), (Victor,8))
Stable sorting :
((John,10),(Adam,9),(Peter,9),(Victor,8))
Unstable sorting :
((John,10), (Peter,9),(Adam,9), (Victor,8))
![Page 5: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/5.jpg)
5
Row 1 Row 2 Row 3 Row 40
2
4
6
8
10
12
Column 1
Column 2
Column 3
![Page 6: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/6.jpg)
6
Homework 2
Assigned today, due next Wednesday Will be on web page shortly after class Thursday's seminar: will recover next week.
![Page 7: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/7.jpg)
7
Review: Quicksort
Sorts in place Sorts O(n lg n) in the average case Sorts O(n2) in the worst case
But in practice, it’s quick And the worst case doesn’t happen often (but more
on this later…)
![Page 8: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/8.jpg)
8
Quicksort
Another divide-and-conquer algorithm The array A[p..r] is partitioned into two non-
empty subarrays A[p..q] and A[q+1..r] Invariant: All elements in A[p..q] are less than all
elements in A[q+1..r]
The subarrays are recursively sorted by calls to quicksort
Unlike merge sort, no combining step: two subarrays form an already-sorted array
![Page 9: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/9.jpg)
9
Quicksort Code
Quicksort(A, p, r)
{
if (p < r)
{
q = Partition(A, p, r);
Quicksort(A, p, q);
Quicksort(A, q+1, r);
}
}
![Page 10: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/10.jpg)
10
Partition
Clearly, all the action takes place in the partition() function Rearranges the subarray in place End result:
Two subarrays All values in first subarray ≤ all values in second
Returns the index of the “pivot” element separating the two subarrays
How do you suppose we implement this?
![Page 11: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/11.jpg)
11
Partition In Words
Partition(A, p, r): Select an element to act as the “pivot” (which?) Grow two regions, A[p..i] and A[j..r]
All elements in A[p..i] <= pivot All elements in A[j..r] >= pivot
Increment i until A[i] >= pivot Decrement j until A[j] <= pivot Swap A[i] and A[j] Repeat until i >= j Return j
Note: slightly different from book’s partition()
![Page 12: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/12.jpg)
12
Partition Code
Partition(A, p, r)
x = A[p];
i = p - 1;
j = r + 1;
while (TRUE)
repeat
j--;
until A[j] <= x;
repeat
i++;
until A[i] >= x;
if (i < j)
Swap(A, i, j);
else
return j;
Illustrate on A = {5, 3, 2, 6, 4, 1, 3, 7};
What is the running time of partition()?
![Page 13: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/13.jpg)
13
Partition Code
Partition(A, p, r)
x = A[p];
i = p - 1;
j = r + 1;
while (TRUE)
repeat
j--;
until A[j] <= x;
repeat
i++;
until A[i] >= x;
if (i < j)
Swap(A, i, j);
else
return j;
partition() runs in O(n) time
![Page 14: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/14.jpg)
14
Analyzing Quicksort
What will be the worst case for the algorithm? Partition is always unbalanced
What will be the best case for the algorithm? Partition is perfectly balanced
Which is more likely? The latter, by far, except...
Will any particular input elicit the worst case? Yes: Already-sorted input
![Page 15: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/15.jpg)
15
Analyzing Quicksort
In the worst case:T(1) = Θ(1)
T(n) = T(n - 1) + Θ(n)
Works out to
T(n) = Θ(n2)
![Page 16: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/16.jpg)
16
Analyzing Quicksort
In the best case:T(n) = 2T(n/2) + Θ(n)
What does this work out to?T(n) = Θ(n lg n)
![Page 17: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/17.jpg)
17
Improving Quicksort
The real liability of quicksort is that it runs in O(n2) on already-sorted input
Book discusses two solutions: Randomize the input array, OR Pick a random pivot element
How will these solve the problem? By insuring that no particular input can be chosen
to make quicksort run in O(n2) time
![Page 18: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/18.jpg)
18
Analyzing Quicksort: Average Case
Assuming random input, average-case running time is much closer to O(n lg n) than O(n2)
First, a more intuitive explanation/example: Suppose that partition() always produces a 9-to-1
split. This looks quite unbalanced! The recurrence is thus:
T(n) = T(9n/10) + T(n/10) + n How deep will the recursion go? (draw it)
Use n instead of O(n) for convenience (how?)
![Page 19: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/19.jpg)
19
Analyzing Quicksort: Average Case
Intuitively, a real-life run of quicksort will produce a mix of “bad” and “good” splits Randomly distributed among the recursion tree Pretend for intuition that they alternate between
best-case (n/2 : n/2) and worst-case (n-1 : 1) What happens if we bad-split root node, then
good-split the resulting size (n-1) node?
![Page 20: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/20.jpg)
20
Analyzing Quicksort: Average Case
Intuitively, a real-life run of quicksort will produce a mix of “bad” and “good” splits Randomly distributed among the recursion tree Pretend for intuition that they alternate between
best-case (n/2 : n/2) and worst-case (n-1 : 1) What happens if we bad-split root node, then
good-split the resulting size (n-1) node? We end up with three subarrays, size 1, (n-1)/2, (n-1)/2 Combined cost of splits = n + n -1 = 2n -1 = O(n) No worse than if we had good-split the root node!
![Page 21: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/21.jpg)
21
Analyzing Quicksort: Average Case
Intuitively, the O(n) cost of a bad split (or 2 or 3 bad splits) can be absorbed into the O(n) cost of each good split
Thus running time of alternating bad and good splits is still O(n lg n), with slightly higher constants
How can we be more rigorous?
![Page 22: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/22.jpg)
22
Analyzing Quicksort: Average Case
For simplicity, assume: All inputs distinct (no repeats) Slightly different partition() procedure
partition around a random element, which is not included in subarrays
all splits (0:n-1, 1:n-2, 2:n-3, … , n-1:0) equally likely
What is the probability of a particular split happening?
Answer: 1/n
![Page 23: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/23.jpg)
23
Analyzing Quicksort: Average Case
So partition generates splits (0:n-1, 1:n-2, 2:n-3, … , n-2:1, n-1:0)
each with probability 1/n If T(n) is the expected running time,
What is each term under the summation for? What is the Θ(n) term for?
T (n )=1n∑k=0
n−1
[T ( k ) +T (n−1−k ) ]+Θ (n )
![Page 24: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/24.jpg)
24
Analyzing Quicksort: Average Case
So…
Note: this is just like the book’s recurrence (p166), except that the summation starts with k=0
We’ll take care of that in a second
T (n )=1n∑k= 0
n−1
[T (k )+T (n−1−k ) ]+Θ ( n )
2n∑k=0
n−1
T ( k ) +Θ (n )Write it on the board
![Page 25: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/25.jpg)
25
Analyzing Quicksort: Average Case
We can solve this recurrence using the dreaded substitution method Guess the answer Assume that the inductive hypothesis holds Substitute it in for some value < n Prove that it follows for n
![Page 26: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/26.jpg)
26
Analyzing Quicksort: Average Case
We can solve this recurrence using the dreaded substitution method Guess the answer
What’s the answer?
Assume that the inductive hypothesis holds Substitute it in for some value < n Prove that it follows for n
![Page 27: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/27.jpg)
27
Analyzing Quicksort: Average Case
We can solve this recurrence using the dreaded substitution method Guess the answer
T(n) = O(n lg n)
Assume that the inductive hypothesis holds Substitute it in for some value < n Prove that it follows for n
![Page 28: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/28.jpg)
28
Analyzing Quicksort: Average Case
We can solve this recurrence using the dreaded substitution method Guess the answer
T(n) = O(n lg n)
Assume that the inductive hypothesis holds What’s the inductive hypothesis?
Substitute it in for some value < n Prove that it follows for n
![Page 29: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/29.jpg)
29
Analyzing Quicksort: Average Case
We can solve this recurrence using the dreaded substitution method Guess the answer
T(n) = O(n lg n)
Assume that the inductive hypothesis holds T(n) ≤ an lg n + b for some constants a and b
Substitute it in for some value < n Prove that it follows for n
![Page 30: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/30.jpg)
30
Analyzing Quicksort: Average Case
We can solve this recurrence using the dreaded substitution method Guess the answer
T(n) = O(n lg n)
Assume that the inductive hypothesis holds T(n) ≤ an lg n + b for some constants a and b
Substitute it in for some value < n What value?
Prove that it follows for n
![Page 31: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/31.jpg)
31
Analyzing Quicksort: Average Case
We can solve this recurrence using the dreaded substitution method Guess the answer
T(n) = O(n lg n)
Assume that the inductive hypothesis holds T(n) ≤ an lg n + b for some constants a and b
Substitute it in for some value < n The value k in the recurrence
Prove that it follows for n
![Page 32: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/32.jpg)
32
Analyzing Quicksort: Average Case
We can solve this recurrence using the dreaded substitution method Guess the answer
T(n) = O(n lg n)
Assume that the inductive hypothesis holds T(n) ≤ an lg n + b for some constants a and b
Substitute it in for some value < n The value k in the recurrence
Prove that it follows for n Grind through it…
![Page 33: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/33.jpg)
33
Note: leaving the same recurrence as the book
What are we doing here?
Analyzing Quicksort: Average Case
T (n )=2n∑k= 0
n−1
T (k )+Θ (n )
2n∑k=0
n−1
( ak lg k+b ) +Θ (n )
2n [b+∑
k=1
n−1
(ak lg k+b )]+Θ ( n )
2n∑k=1
n−1
( ak lg k+b )+2bn
+Θ ( n )
2n∑k=1
n−1
( ak lg k+b ) +Θ (n )
The recurrence to be solved
What are we doing here?
What are we doing here?
Plug in inductive hypothesis
Expand out the k=0 case
2b/n is just a constant, so fold it into Θ(n)
![Page 34: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/34.jpg)
34
What are we doing here?
What are we doing here?
Evaluate the summation: b+b+…+b = b (n-1)
The recurrence to be solved
Since n-1<n, 2b(n-1)/n < 2b
Analyzing Quicksort: Average Case
T (n )=2n∑k=1
n−1
(ak lg k+b )+Θ (n )
2n∑k=1
n−1
ak lg k +2n∑k=1
n−1
b +Θ (n )
2an
∑k=1
n−1
k lg k+2bn
( n−1)+Θ ( n )
2an
∑k=1
n−1
k lg k+2b +Θ ( n )
What are we doing here?Distribute the summation
This summation gets its own set of slides later
![Page 35: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/35.jpg)
35 How did we do this?
Pick a large enough thatan/4 dominates Θ(n)+b
What are we doing here?Remember, our goal is to get T(n) ≤ an lg n + b
What the hell?We’ll prove this later
What are we doing here?Distribute the (2a/n) term
The recurrence to be solved
Analyzing Quicksort: Average Case
T (n )≤ 2an
∑k=1
n−1
k lg k+2b +Θ (n )
2an (12 n2 lg n−
18
n2)+2b +Θ (n )
an lg n−a4
n+2b+Θ (n )
an lg n+b+(Θ (n )+b−a4
n)an lg n+b
![Page 36: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/36.jpg)
36
Analyzing Quicksort: Average Case
So T(n) ≤ an lg n + b for certain a and b Thus the induction holds Thus T(n) = O(n lg n) Thus quicksort runs in O(n lg n) time on average
(phew!)
Oh yeah, the summation…
![Page 37: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/37.jpg)
37
What are we doing here?The lg k in the second term is bounded by lg n
Tightly Bounding The Key Summation
∑k=1
n−1
k lg k = ∑k=1
( n/2 )−1
k lg k+ ∑k= (n /2 )
n−1
k lg k
∑k=1
( n/2 )−1
k lg k+ ∑k= ( n/2 )
n−1
k lg n
∑k=1
( n/2 )−1
k lg k+ lgn ∑k= ( n/2 )
n−1
k What are we doing here?Move the lg n outside the summation
What are we doing here?Split the summation for a tighter bound
![Page 38: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/38.jpg)
38
The summation bound so far
Tightly BoundingThe Key Summation
∑k=1
n−1
k lg k≤ ∑k=1
( n/2 )−1
k lgk +lg n ∑k= ( n/2 )
n−1
k
∑k=1
( n/2 )−1
k lg ( n /2 )+lg n ∑k= (n /2 )
n−1
k
∑k=1
( n/2 )−1
k ( lg n−1 )+lg n ∑k= ( n /2 )
n−1
k
(lg n−1 ) ∑k=1
( n/2 )−1
k +lg n ∑k= ( n /2 )
n−1
k
What are we doing here?The lg k in the first term is bounded by lg n/2
What are we doing here?lg n/2 = lg n - 1
What are we doing here?Move (lg n - 1) outside the summation
![Page 39: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/39.jpg)
39
The summation bound so far
Tightly BoundingThe Key Summation
∑k=1
n−1
k lg k≤ (lg n−1 ) ∑k=1
( n/2 )−1
k+ lg n ∑k= ( n /2 )
n−1
k
lg n ∑k=1
( n /2 )−1
k− ∑k=1
( n/2 )−1
k +lg n ∑k= ( n /2 )
n−1
k
lg n∑k=1
n−1
k− ∑k=1
(n /2 )−1
k
lg n ((n−1 )( n )
2 )− ∑k=1
( n/2 )−1
k
What are we doing here?Distribute the (lg n - 1)
What are we doing here?The summations overlap in range; combine them
What are we doing here?The Gaussian series
![Page 40: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/40.jpg)
40
The summation bound so far
Tightly Bounding The Key Summation
∑k=1
n−1
k lg k≤ (( n−1 )(n )
2 ) lg n− ∑k=1
( n /2 )−1
k
12
[n (n−1 ) ] lg n− ∑k=1
n/2−1
k
12
[n (n−1 ) ] lg n−12 (n
2 )(n2 −1)1
2( n2 lg n−n lg n )−1
8n2+
n4
What are we doing here?Rearrange first term, place upper bound on second
What are we doing?X Gaussian series
What are we doing?Multiply it all out
![Page 41: CS 332: Algorithms - Gabriel Istrategabrielistrate.weebly.com/.../2/5/2/6/2526487/lecture7.pdf2 Sorting revisited We have seen algorithms for sorting: INSERTION-SORT, MERGESORT More](https://reader037.vdocument.in/reader037/viewer/2022090810/611c54771b1ef6273f3a634b/html5/thumbnails/41.jpg)
41
Tightly Bounding The Key Summation
∑k=1
n−1
k lg k≤ 12
( n2 lg n−n lg n )−18
n2+n4
12
n2 lg n−18
n2 when n≥2
Done!!!