Notes of Reading Introduction to Algorithm —— Quicksort

Just as Mergesort, Quicksort also applies Divide and Conquer. But in some cases, the time to call Quicksort can be $\Theta (n^2)$, just like Insertionsort, which is different from Mergesort. In most cases, however, the time to call Quicksort is $\Theta (n\lg n)$, and the constant factor is smaller. Moreover, it also has the advantage of sorting in place.

Partition

First, we should find a pivot. In the code below, we choose the last element to be the pivot. However, in the next part, we will randomize the partition, which will choose the pivot at random.

After choosing the pivot, we will divide the array into three parts. In part 1, all the elements are larger than or equal to the pivot. In part 2, all the elements are smaller than the pivot. Part 3 is just the pivot.

int Partition(int *A, int p, int r)
{
    int i = p - 1, q = p;
    for (; q < r; q++)
    {
    	if (A[q] <= A[r])
    	{
	        i++;
        	int temp;
        	temp = A[q]; A[q] = A[i]; A[i] = temp;
    	}
    }
    i++;
    int temp;
    temp = A[r]; A[r] = A[i]; A[i] = temp;
    return i;
}

Obviously, the time to call Partition is $\Theta (n)$, $n=r-p+1$.

Divide & Conquer

The array has been divide into three parts, then we “conquer” part 1 and part 2. As the elements are just in place, we needn’t combine.

void Quicksort(int *A, int p, int r)
{
    if (p < r)
    {
        int q = Partition(A, p, r);
        Quicksort(A, p, q-1);
        Quicksort(A, q+1, r);
    }
}

Performance of Quicksort

The time to call the Quicksort depends on the input array.

The Worst Case

Just think about this case, the numbers in the array are sorted, like 0, 1, 2, 3, … .

In this case, $T(n)=T(n-1)+\Theta (n)$. We can work out that the time complexity is $\Theta (n^2)$. In this case, the time complexity of Insertionsort is only $\Theta (n)$.

The Best Case

The best case turns up when part 1 and part 2 have the same number of elements for every partition. At this time, $T(n)<2T(\frac{n}{2})+\Theta (n)$. Therefore, the time complexity is $\Theta (n\lg n)$.

Analysis

In most cases, the time to call Quicksort is much closer to the best case other than the worst case. The two pictures below can help us to understand this.

Picture 1 shows that the unbalanced cases also have the time complexity of $O(n\lg n)$. Picture 2 shows that the worst case plus the best case has the same time complexity with the best case.

Randomized Version of Quicksort

In this version, we will choose the pivot at random. Then we have the reason to expect the split of the input to be balanced on average.

int RandomizedPartition(int *A, int p, int r)
{
    int i = rand() % (r - p + 1) + p;
    int temp;
    temp = A[i]; A[i] = A[r]; A[r] = temp;
    return Partition(A, p, r);
}

void RandomizedQuicksort(int *A, int p, int r)
{
    if (p < r)
    {
        int q = RandomizedPartition(A, p, r);
        RandomizedQuicksort(A, p, q-1);
        RandomizedQuicksort(A, q+1, r);
    }
}

Analysis of Quicksort

Obviously, the upper bound of Quicksort is $O(n)$.

In the function of Quicksort, we need to call RandomizedQuicksort for at most n times. And in every RandomizedQuicksort we will call RandomizedPartition , and then the Partition . Therefore, the time we cost is related to how much time we will cost in the function Partition.

Moreover, the time of calling Partition is related to the times we compare a pair of numbers, because the loop in the function includes the comparison.

We define $X_{ij}=I$ {$z_i$ is compared to $z_j$} , and all the times we compare equals $X=\sum _{i=1}^{n-1}\sum _{j=i+1}^n{X}_{ij}$. $E(X)=E(\sum _{i=1}^{n-1}\sum _{j=i+1}^n{X}_{ij})=\sum _{i=1}^{n-1}\sum _{j=i+1}^{n}E(X_{ij})=\sum _{i=1}^{n-1}\sum _{j=i+1}^n\mathrm{Pr}${$z_i$ is compared to $z_j$} .

$\mathrm{Pr}${$z_i$ is compared to $z_j$}$=$$\mathrm{Pr}${$z_i$ or $z_j$ is the first pivot to be chosen from the elements indexed from $i$ to $j$}$=\frac{2}{j-i+1}$.Then we can work out that $E(X)<O(n\lg n)$.

In conclusion, the average time we call RandomizedQuicksort has an upper bound —— $O(n\lg n)$.

All my codes along with Heapsort are shown below:

To get the complete code please visit my repositories: github.com.

Reference: Introduction to Algorithm