Explaining Proof of Quick-Sort's O(nlog n) Expected Running Time

  • Context: MHB 
  • Thread starter Thread starter evinda
  • Start date Start date
  • Tags Tags
    Explanation Proof
Click For Summary
SUMMARY

The expected running time of the Quick-Sort algorithm is proven to be O(n log n) through a recurrence relation analysis. The algorithm selects a pivot randomly and partitions the input sequence into three parts: elements less than, equal to, and greater than the pivot. The recurrence relation T(n) is established as T(n) ≤ cn + (1/n) Σ[T(i-1) + T(n-i)], leading to the conclusion that T(n) ≤ k n log n for a constant k. This proof utilizes mathematical induction to establish the upper bound for the expected running time.

PREREQUISITES
  • Understanding of Quick-Sort algorithm mechanics
  • Familiarity with recurrence relations
  • Knowledge of mathematical induction
  • Basic concepts of algorithmic time complexity
NEXT STEPS
  • Study the derivation of recurrence relations in algorithms
  • Learn about mathematical induction techniques in algorithm analysis
  • Explore the impact of pivot selection strategies on Quick-Sort performance
  • Investigate average-case vs worst-case time complexities in sorting algorithms
USEFUL FOR

Computer science students, algorithm designers, and software engineers interested in understanding sorting algorithms and their performance analysis.

evinda
Gold Member
MHB
Messages
3,741
Reaction score
0
Hello! (Wave)

View attachment 4422

View attachment 4423I am trying to understand the proof that the expected running time of quick-sort is $O(n \log n)$.

Could you maybe explain it to me?
 

Attachments

  • worst.PNG
    worst.PNG
    25.6 KB · Views: 115
  • proof1.PNG
    proof1.PNG
    31.5 KB · Views: 107
Technology news on Phys.org
Suppose that we use the following algorithm:

Code:
Quicksort(S):
1.  if S contains at most one element then return S
    else
2.       choose an element a randomly from S;
3.       let S1, S2, and S3 be the sequences of elements in S less than, equal to, and greater than a, respectively;
4.       return Quicksort(S1) followed by S2 followed by Quicksort(S3)
I have tried the following:

Let T(n) be the expected time required by the Quicksort algorithm in order to sort a sequence of n elements. We have that T(0)=T(1)=b for a constant b.

We suppose that the elements a is the i-th smallest elements of the n elements of the sequence S.
Then the 2 recursive calls of Quicksort have expected time T(i-1) and T(n-i), respectively.
Since the lines 2-3 require time O(n) and the line 1 requires time O(1), we have the following recurrence relation:

T(n) \leq cn+ \frac{1}{n} \sum_{i=1}^n \left[ T(i-1)+T(n-i)\right], n \geq 2

\\ T(n) \leq cn+ \frac{1}{n} \sum_{i=1}^n \left[ T(i-1)+T(n-i)\right] \\ \leq cn+ \frac{1}{n} \sum_{i=1}^n \left[ 2T(i-1) \right] =cn+ \frac{2}{n} \sum_{i=0}^{n-1} T(i) \\ \Rightarrow T(n) \leq cn+ \frac{2}{n} \sum_{i=0}^{n-1} T(i)(1)

We will show that for n \geq 2, T(n) \leq k n \log n, for k=2(c+b) positive.

For n=2: From the relation (1) we have T(2) \leq c2+ 2b=2(c+b) \checkmark

We suppose that T(n) \leq k n \log n γfor some n \geq 2.

We will show that T(n+1) \leq k (n+1) \log (n+1) .

From the relation (1) we have T(n+1) \leq c(n+1)+ \frac{2}{n+1} \sum_{i=0}^{n} T(i) \leq c(n+1)+ \frac{2}{n+1} (n+1) T(n)= c(n+1)+2T(n) \leq c(n+1)+2 k n \log n \leq (n+1) (c+2k \log n)How could we continue? Or should we use strong induction?
 

Similar threads

  • · Replies 4 ·
Replies
4
Views
1K
  • · Replies 1 ·
Replies
1
Views
2K
  • · Replies 1 ·
Replies
1
Views
2K
  • · Replies 1 ·
Replies
1
Views
1K
  • · Replies 11 ·
Replies
11
Views
4K
  • · Replies 12 ·
Replies
12
Views
4K
  • · Replies 17 ·
Replies
17
Views
4K
  • · Replies 15 ·
Replies
15
Views
2K
  • · Replies 2 ·
Replies
2
Views
2K
  • · Replies 11 ·
Replies
11
Views
3K