{'fraction_non_alphanumeric': 0.04687588443157835, 'fraction_numerical': 0.013673817590788164, 'mean_word_length': 3.868627219400811, 'pattern_counts': {'":': 0, '<': 37, '<?xml version=': 0, '>': 19, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 34, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
The Quicksort algorithm and related topics

Sorting algorithms have attracted a great deal of attention and study, as they have numerous applications to Mathematics, Computer Science and related fields. In this thesis, we first deal with the mathematical analysis of the Quicksort algorithm and its variants. Specifically, we study the time complexity of the algorithm and we provide a complete demonstration of the variance of the number of comparisons required, a known result but one whose detailed proof is not easy to read out of the literature. We also examine variants of Quicksort, where multiple pivots are chosen for the partitioning of the array. The rest of this work is dedicated to the analysis of finding the true order by further pairwise comparisons when a partial order compatible with the true order is given in advance. We discuss a number of cases where the partially ordered sets arise at random. To this end, we employ results from Graph and Information Theory. Finally, we obtain an alternative bound on the number of linear extensions when the partially ordered set arises from a random graph, and discuss the possible application of Shellsort in merging chains.

1. If C divides A, then the algorithm terminates with C as the greatest common divisor.
2. If A mod C is equal to unity, the numbers are either prime or relatively prime and the algorithm terminates. Otherwise set A ← C, C ← A mod C and return to step 1.
By A mod C, we denote the remainder of the division of A by C, namely which is between 0 and C − 1. Here the floor function ⌊x⌋ of a real number x is the largest integer less than or equal to x. We observe that this algorithm operates recursively by successive divisions, until obtaining remainder equal to 0 or to 1. Since the remainder strictly reduces at each stage, the process is finite and eventually terminates.
Two main issues in relation to an algorithm are its running time or time complexity, which is the amount of time necessary to solve the problem, and its space complexity, which is the amount of memory needed for the execution The relation f (n) = ω g(n) implies that f dominates g, i.e.
The relation f (n) ∼ g(n) denotes the fact that f (n) and g(n) are asymptotically equivalent, i.e.
Further, best, worst and average case performance denote the resource usage, e.g. amount of memory in computer or running time, of a given algorithm at least, at most and on average, respectively. In other words, these terms describe the behaviour of an algorithm under optimal circumstances (e.g. best-case scenario), worst circumstances and on average [15]. In this work, the study will be concentrated on the average and worst case performance of Quicksort and its variants.
In our analysis, we will frequently come across with harmonic numbers, whose definition we now present. There are numerous interesting properties of harmonic numbers, which are not yet fully investigated and understood. Harmonic series have links with Stirling numbers [26] and arise frequently in the analysis of algorithms. For n large, it is well-known that [44], where γ = 0.57721 . . . is the Euler-Mascheroni constant. We will use this often, especially in the form H n = log e (n) + γ + o (1).
Note that throughout this thesis, we shall adopt the convention of writing explicitly the base of logarithms. For example, the natural logarithm of n is denoted by log e (n), instead of ln(n). Also, the end of a proof will be denoted by the symbol .

Introduction to Quicksort
Sorting an array of items is clearly a fundamental problem, directly linked to efficient searching with numerous applications. The problem is that given an array of keys, we want to rearrange these in non-decreasing order. Note that the order may be numerical, alphabetical or any other transitive relation defined on the keys [46]. In this work, the analysis deals with numerical order, where the keys are decimal numbers and we particularly focus on Quicksort algorithm and variants of it. Quicksort was invented by C. A. R. Hoare [29,30]. Here is the detailed definition. The steps taken by the Quicksort algorithm are: 1. Choose an element from the array, called pivot.
2. Rearrange the array by comparing every element to the pivot, so all elements smaller than or equal to the pivot come before the pivot and all elements greater than or equal to the pivot come after the pivot. 3. Recursively apply steps 1 and 2 to the subarray of the elements smaller than or equal to the pivot and to the subarray of the elements greater than or equal to the pivot.
Note that the original problem is divided into smaller ones, with (initially) two subarrays, the keys smaller than the pivot, and those bigger than it. Then recursively these are divided into smaller subarrays by further pivoting, until we get trivially sorted subarrays, which contain one or no elements. Given an array of n distinct keys A = {a 1 , a 2 , . . . , a n } that we want to quick sort, with all the n! permutations equally likely, the aim is to finding the unique permutation out of all the n! possible, such that the keys are in increasing order. The essence of Quicksort is the partition operation, where by a series of pairwise comparisons, the pivot is brought to its final place, with smaller elements on its left and greater elements to the right. Elements equal to pivot can be on either or both sides.
As we shall see, there are numerous partitioning schemes, and while the details of them are not central to this thesis, we should describe the basic ideas. A straightforward and natural way (see e.g. [46]) uses two pointers -a left pointer, initially at the left end of the array and a right pointer, initially at the right end of the array. We pick the leftmost element of the array as pivot and the right pointer scans from the right end of the array for a key less than the pivot. If it finds such a key, the pivot is swapped with that key. Then, the left pointer is increased by one and starts its scan, searching for a key greater than the pivot: if such a key is found, again the pivot is exchanged with it.
When the pointers are crossed, the pivot by repeated exchanges will "float" to its final position and the keys which are on its left are smaller and keys on its right are greater. The data movement of this scheme is quite large, since the pivot is swapped with the other elements.
A different partitioning scheme, described in [30] is the following. Two pointers i (the left pointer, initially 1) and j (the right pointer, initially n) are set and a key is arbitrarily chosen as pivot. The left pointer goes to the right until a key is found which is greater than the pivot. If one is found, its scan is stopped and the right pointer scans to the left until a key less than the pivot is found. If such a key is found, the right pointer stops and those two keys are exchanged. After the exchange, both pointers are stepped down one position and the lower one starts its scan. When pointers are crossed, i.e. when i ≥ j, the final exchange places the pivot in its final position, completing the partitioning. The number of comparisons required to partition an array of n keys is at least n − 1 and the expected number of exchanges is n 6 + 5 6n .
A third partitioning routine, called Lomuto's partition, is mentioned in [6] this involves exactly n − 1 comparisons, which is clearly best possible, but the downside is the increased number of exchanges. The expected number of key exchanges of this scheme is n−1 2 , [48].
We now consider the worst case and best case, analysis of Quicksort. Suppose we want to sort the following array, {a 1 < a 2 < . . . < a n } and we are very unlucky and our initial choice of pivot is the largest element a n . Then of course we only divide and conquer in a rather trivial sense: every element is below the pivot, and it has taken us n − 1 comparisons with a n to get here.
Suppose we now try again and are unlucky again, choosing a n−1 as pivot this time. Again the algorithm performs n − 2 comparisons and we are left with everything less than a n−1 . If we keep being unlucky in our choices of pivot, and keep choosing the largest element of what is left, after i recursive calls the running time of the algorithm will be equal to (n − 1) + (n − 2) + . . . + (n − i) comparisons, so the overall number of comparisons made is 1 + 2 + . . . + (n − 1) = n · (n − 1) 2 .
Thus Quicksort needs quadratic time to sort already sorted or reverse-sorted arrays if the choice of pivots is unfortunate.
If instead we always made good choices, choosing each pivot to be roughly in the middle of the array we are considering at present, then in the first round we make n − 1 comparisons, then in the two subarrays of size about n/2 we make about n/2 comparisons, then in each of the four subarrays of size about n/4 we make n/4 comparisons, and so on. So we make about n comparisons in total in each round. The number of rounds will be roughly log 2 (n) as we are splitting the arrays into roughly equally-sized subarrays at each stage, and it will take log 2 (n) recursions of this to get down to trivially sorted arrays.
Thus, in this good case we will need O n log 2 (n) comparisons. This is of course a rather informal argument, but does illustrate that the time complexity can be much smaller than the quadratic run-time in the worst case. This is already raising the question of what the typical time complexity will be: we address this in the next Chapter.
We briefly discuss the space complexity of the algorithm. There are n memory locations occupied by the keys. Moreover, the algorithm, due to its recursive nature, needs additional space for the storage of subarrays. The subarrays' boundaries are saved on to a stack, which is a data structure providing temporary storage. At the end of the partition routine, the pivot is placed in its final position between two subarrays (one of them possibly empty). Recursively, the algorithm is applied to the smaller subarray and the other one is pushed on to stack. Since, in best and average case of Quicksort, we have O log 2 (n) recursive calls, the required stack space is O log 2 (n) locations in memory. However, in worst case the stack may require O(n) locations, if the algorithm is applied to the larger subarray and the smaller one is saved to the stack [63].
This discussion makes it clear that the pivot selection plays a vital role in the performance of the algorithm. Many authors have proposed various techniques to remedy this situation and to avoid worst case behaviour, see [15], [30], [46], [62], [63] and [68]. These include the random shuffling of the array prior to initialisation of the algorithm, choosing as pivot the median of the array, or the median of a random sample of keys.
Scowen in his paper [62], suggested choosing as pivot the middle element of the array: his variant is dubbed "Quickersort". Using this rule for the choice of partitioning element, the aim is the splitting of the array into two halves of equal size. Thus, in case where the array is nearly sorted, quadratic time is avoided but if the chosen pivot is the minimum or maximum key, the algorithm's running time attains its worst case and this variant does not offer any more than choosing the pivot randomly. Singleton [68] suggested a better estimate of the median, by selecting as pivot the median of leftmost, rightmost and middle keys of the input array. Hoare [30] suggested the pivot may be chosen as the median of a random sample from the keys to be sorted, but he didn't analyse this approach.
One point is that Quicksort is not always very fast at sorting small arrays.
Knuth [46] presented and analysed a partitioning scheme, which takes n + 1 instead of n − 1 comparisons and the sorting of small subarrays (usually from about 9 to 15 elements) is implemented using insertion sort, since the recursive structure of Quicksort is better suited to large arrays. Insertion sort is a simple sorting algorithm, which gradually 'constructs' a sorted array from left to right, in the following manner. The first two elements are compared and exchanged, in case that are not in order. Then, the third element is compared with the element on its left. If it is greater, it is left at its initial location, otherwise is compared with the first element and accordingly is inserted to its position in the sorted array of 3 elements. This process is iteratively applied to the remaining elements, until the array is sorted. See as well in Cormen et al. [15], for a description of the algorithm.

Outline and contributions of thesis
This thesis consists of seven Chapters and one Appendix. After the first, introductory Chapter, the rest of the thesis is organised as follows: In Chapter 2, we consider the first and second moments of the number of comparisons made when pivots are chosen randomly. The result for the mean is known and easy: the result for the variance is known, but less easy to find a full proof of in the literature. We supply one. We briefly discuss the skewness of the number of comparisons and we study the asymptotic behaviour of the algorithm.
In Chapter 3, we analyse the idea of choosing the pivot as a centered statistic of a random sample of the keys to be sorted and we obtain the average number of comparisons required by these variants, showing that the running time can be greatly improved. Moreover, we present relevant definitions of entropy.
Not much of this is original, but some details about why various differential equations that arise in the analysis have the solutions they do (i.e. details about roots of indicial polynomials) are not in literature.
In We also present the application of Vandermonde matrices for the computation of the constants involved to the cost of these variants.
In Chapter 5, various cases of partially ordered sets are discussed and the number of comparisons needed for the complete sorting is studied. The 'informationtheoretic lower bound' is always ω(n) in these cases and we show that the time needed for the sorting of partial orders is O n log 2 (n) . The main contribution of this Chapter, is the derivation of the asymptotic number of comparisons needed, for the sorting of various partially ordered sets. The basic ideas used here are due to, amongst others, Cardinal et al. [13], Fredman [25], Kahn and Kim [40], Kislitsyn [41], but the working out of the detailed consequences for these partial orders seems to be new.
In Chapter 6, we consider random graph orders, where the 'informationtheoretic lower bound' is of the same order of magnitude as the number of keys being sorted. We derive a new bound on the number of linear extensions using entropy arguments, though it is not at present competitive with an older bound in the literature [4].
In Chapter 7, we conclude the thesis, presenting future research directions.
At this final Chapter, we derive another bound of the number of comparisons required to sort a random interval order and we discuss the merging of linearly ordered sets.
In Appendix A, we present the MAPLE calculations, regarding the derivation of the variance of the number of comparisons of dual pivot Quicksort, analysed in subsection 4.1.1.

Random selection of pivot
In this Chapter, the mathematical analysis of Quicksort is presented, under the assumption that the pivots are uniformly selected at random. Specifically, the major expected costs regarding the time complexity of the algorithm and the second moment are computed. The derivation of the average costs is unified under a general recurrence relation, demonstrating the amenability of the algorithm to a complete mathematical treatment. We also address the asymptotic analysis of the algorithm and we close this Chapter considering the presence of equal keys.

Expected number of comparisons
This discussion of lucky and unlucky choices of pivot suggests the idea of selecting the pivot at random, as randomisation often helps to improve running time in algorithms with bad worst-case, but good average-case complexity [69]. For example, we could choose the pivots randomly for a discrete uniform distribution on the array we are looking at each stage. Recall that the uniform distribution on a finite set assigns equal probability to each element of it. It is clear that for n = 0 or n = 1, C 0 = C 1 = 0 as there is nothing to sort.
These are the initial or "seed" values of the recurrence relation for the number of comparisons, given in the following Lemma.
Lemma 2.1.2. The random number of comparisons C n for the sorting of an array consisting of n ≥ 2 keys, is given by where U n follows the uniform distribution over the set {1, 2, . . . , n} and C ⋆ n−Un is identically distributed to C Un−1 and independent of it conditional on U n .
Proof. The choice of U n as pivot, and comparing the other n − 1 elements with it, splits the array into two subarrays. There is one subarray of all U n − 1 elements smaller than the pivot and another one of all n − U n elements greater than the pivot. Obviously these two subarrays are disjoint. Then recursively two pivots are randomly selected from the two subarrays, until the array is sorted, and so we get the equation.
This allows us to find that the expected complexity of Quicksort applied to n keys is: Using conditional expectation and noting that U n = k has probability 1/n, we get, writing a k for E(C k ), that a n = n k=1 1 n (a k−1 + a n−k ) + n − 1 =⇒ a n = 2 n n−1 k=0 a k + n − 1.
We have to solve this recurrence relation, in order to obtain a closed form for the expected number of comparisons. The following result is well-known (e.g. see in [15], [63]): Theorem 2.1.3. The expected number a n of comparisons for Quicksort with uniform selection of pivots is a n = 2(n + 1)H n − 4n.
We now show a slick way of solving the recurrence about the expected number of comparisons using generating functions. This approach is also noted in various places, e.g. [44], [55], [63]. We again start from a n = 2 n n−1 j=0 a j + n − 1.
We multiply through by n to clear fractions, getting changing round the order of summation. To evaluate ∞ n=2 n(n − 1)x n−2 , simply note this is the 2nd derivative of ∞ n=0 x n . Since the latter sum is equal to Multiplying the sum by x now gives We evaluate the last double-sum. The inner sum is of course x j /(1 − x) being a geometric series. Thus we get This is now a fairly standard kind of differential equation. Multiplying both sides by (1 − x) 2 , we see Setting x = 0, we get f (0) = 0 on the left-hand side, and on the right-hand side we get c, so c = 0. Therefore Expanding out log e (1 − x) as a series, −x − x 2 /2 − x 3 /3 − . . ., and similarly Thus, looking at coefficients of x n on both sides, we get on the left-hand side a n . On the right-hand side, we get the coefficient for each x j in the first series (which is 1/j) times the term for the x n−j in the other, namely (n − j + 1). So we get a n = 2 Some texts give a different argument for this, as follows.
Since X ij ∈ {0, 1}, then E(X ij ) = P(X ij = 1). This event occurs when y i and y j are compared. Clearly, this happens when y i or y j is the first number chosen as pivot from the set Y = {y i , y i+1 , . . . , y j−1 , y j }. (Because otherwise if some element between them is chosen, y k say, y i and y j are compared to y k and y i is put below y k and y j above it with the result that y i and y j are never compared).
Since the pivot is chosen uniformly at random, the probability the one of these two elements is the first of the j − i + 1 elements chosen is equal to The change of sum is justified by writing out the possible rows for fixed i and columns for a fixed k, then changing round from summing rows first to summing columns first. This is, as 2/k does not depend on i, equal to Thus, proving the claim.
Also of some interest is the mean number of partitioning stages E(P n ) of the algorithm applied to n keys as input. For the case where we simply use Quicksort for all the sorting, it is obvious that we will have P 0 = 0 and for n ≥ 1, the number of partitioning stages P n obeys the following recurrence conditional on j being the rank of the pivot P n = 1 + P j−1 + P n−j .
Observe that P 1 = 1 and P 2 = 2. Taking expectations, and noting that the pivot is uniformly chosen at random and that the two sums j E(P j−1 ) and j E(P n−j ) are equal, we see Multiplying both sides by n and differencing the recurrence relation, as we did for the derivation of the expected number of comparisons, we have Finally, E(P n ) = n.

Expected number of exchanges
Here we consider the number of exchanges or swaps performed by the algorithm, which is mentioned by Hoare [30] as a relevant quantity. We assume that each swap has a fixed cost and as in the previous section, we assume that the keys are distinct and that all n! permutations are equally likely to be the input: this in particular implies that the pivot is chosen uniformly at random from the array.
We should specify the partitioning procedure. Assume that we have to sort n distinct keys, where their locations in the array are numbered from left to right by 1, 2, . . . , n. Set two pointers i ← 1 and j ← n − 1 and select the element at location n as a pivot. First, compare the element at location 1 with the pivot.
If this key is less than the pivot, increase i by one until an element greater than the pivot is found. If an element greater than the pivot is found, stop and compare the element at location n − 1 with the pivot. If this key is greater than the pivot, then decrease j by one and compare the next element to the pivot.
If an element less than the pivot is found, then the j pointer stops its scan and the keys that the two pointers refer are exchanged.
Increase i by one, decrease j by one and in the same manner continue the scanning of the array until i ≥ j. At the end of the partitioning operation, the pivot is placed in its final position k, where 1 ≤ k ≤ n, and Quicksort is recursively invoked to sort the subarray of k − 1 keys less than the pivot and the subarray of n − k keys greater than the pivot [29,30].
Note that the probability of a key being greater than the pivot is The number of keys which are greater than pivot, and were moved during Therefore, considering also that pivots are uniformly chosen and noting that we have to count the final swap with the pivot at the end of partition operation, we obtain n k=1 (n − k)(k − 1) n(n − 1) Let S n be the total number of exchanges, when the algorithm is applied to an array of n distinct keys. We have that S 0 = S 1 = 0 and for n ≥ 2, the following recurrence holds S n = "Number of exchanges during partition routine" Since the pivot is chosen uniformly at random, the recurrence for the expected number of exchanges is This recurrence relation is similar to the recurrences about the mean number of comparisons and will be solved by the same way. Subtracting (n−1)E(S n−1 ) from nE(S n ), the recurrence becomes Telescoping, the last relation yields Tidying up, the average number of exchanges in course of the algorithm is Its asymptotic value is n log e (n) 3 .
It follows that asymptotically the mean number of exchanges is about 1/6 of the average number of comparisons.
In a variant of the algorithm analysed in [46] and [63], which we briefly mentioned in the introduction, partitioning of n keys takes n + 1 comparisons and subfiles of m or fewer elements are sorted using insertion sort. Then the average number of comparisons, partitioning stages and exchanges respectively, For m = 0, we obtain the average quantities when there is no switch to insertion sort. Note that in this case the expected costs are E(C n ) = 2(n + 1)H n − 2n, E(P n ) = n and E(S n ) = 2(n + 1)H n − 5n 6 .

Variance
We now similarly discuss the variance of the number of comparisons in Quicksort. Although the result has been known for many years -see [46], exercise 6.2.2-8 for an outline -there is not really a full version of all the details written down conveniently that we are aware of, so we have provided such an account -this summary has been put on the arXiv, [33]. The sources [43], [55] and [63] were useful in putting the argument together. Again, generating functions will be used. The result is: The variance of the number of comparisons of Quicksort on n keys, with a pivot chosen uniformly at random is We start with a recurrence for the generating function of C n , namely f n (z) = ∞ k=0 P(C n = k)z k . We will use this to reduce the proof of the Theorem to proving a certain recurrence formula for the expression f ′′ n (1) 2 .

Theorem 2.3.2. In Random Quicksort of n keys, the generating functions
Proof. We have, using the equation noting that C m−1 and C n−m are conditionally independent subject to the pivot. Thus Multiplying by z k and summing over k, so as to get the generating function f n of C n on the left, we obtain as required.
This of course will give a recursion for the variance, using the well-known formula for variance in terms of the generating function f X (z): We use this formula together with Eq. (2.1). The first order derivative of f n (z) From standard properties of generating functions, it holds that Differentiating again we obtain Setting z = 1 [55], i.e. the mean number of comparisons to sort an array of (j − 1) and (n − j) elements respectively. Setting B n = f ′′ using the symmetry of the sums. What this argument has shown for us is the following -compare [43] where it is also shown that this recurrence has to be solved, though no details of how to solve it are given. and It will be convenient first to develop some theory on various sums involving harmonic numbers. Often we used MAPLE to verify these relations initially, but we provide complete proofs here. As a brief reminder, M j denotes the expected number of comparisons needed to sort an array of j keys. Recall that M j = 2(j + 1)H j − 4j. Thus, For the computation of the first sum of Eq. (2.2), a Lemma follows Proof. The sum can be written as The last equation can be easily seen to be equivalent with the statement of the Lemma.
Thus we can find out about the sum of the M j s, that it holds for n ∈ N Corollary 2.3.5.
Now, we will compute the term n j=1 M j−1 M n−j . We shall use three Lemmas for the following proof.

Proof.
To do this, we will again use the formula obtained previously for M j .
We have We need to work out the value of n j=1 j 2 H j−1 : completing the proof.
After some tedious calculations, the recurrence relation becomes Subtracting nB n from (n + 1)B n+1 , We obtain We have to work out the following sum n j=1 jH j−1 H n+1−j .
We note that Sedgewick [63], presents and proves the following result: Proof. By the definition of harmonic numbers, we have 1 j H j = (n + 1)H n − n.
Eq. (2.4) can be written as It can be easily verified that Making repeated use of Eq. (2.5), we obtain the identity We have then The order of summation was interchanged. We can sum on all j and for k = j, we must count this term twice. We obtain The following Corollary is a direct consequence of Eq. (2.5) and (2.6).

Corollary 2.3.10. For n ∈ N, it holds
Proof.
H n n + 1 and by iteration, We will use the above Lemma and Corollary in our analysis. We have that The second sum substituting j = n + 1 − i becomes H n+1−j j .
As we have seen it is equal to Hence, by Lemma 2.3.9, Using the above result and Eq. (2.3), we have Having worked out all the expressions involved in the following relation This becomes Dividing both sides by (n + 1)(n + 2) and unwinding the recurrence, Finally, multiplying by (n + 1) we obtain B n = 2(n + 1) 2 (H 2 n − H (2) n ) − H n (n + 1)(8n + 2) + 23n 2 + 17n 2 .

"Divide and Conquer" recurrences
We have computed the mean and variance of the number of comparisons made by Quicksort that mainly contribute to its time complexity. Because of the sim-ple structure of the algorithm (dividing into smaller subproblems) we can in fact approach many other related problems in the same spirit. Let F (n) denote the expected value of some random variable associated with randomised Quicksort and T (n) be the average value of the "toll function", which is the needed cost to divide the problem into two simpler subproblems. Then F (n) is equal to the contribution T (n), plus the measures required sort the resulting subarrays of (i − 1) and (n − i) elements, where the pivot i can be any key of the array with equal probability.
Thus, the recurrence relation is This is the general type of recurrences arising in the analysis of Quicksort, which can be manipulated using the difference method or by generating functions. Since an empty array or an one having a unique key is trivially solved, the initial values of the recurrence is The first method leads to the elimination of the sum, by subtracting (n − 1)F (n − 1) from nF (n) -see [46]. The recurrence becomes and dividing by n(n + 1) we have This recurrence can be immediately solved by "unfolding" its terms. The general solution is When the sorting of subarrays of m keys or less is done by insertion sort, the solution of the recurrence is Another classic approach, which is more transparent and elegant, is the application of generating functions. The recurrence is transformed to a differential equation, which is then solved. The function is written in terms of series and the extracted coefficient is the solution. Multiplying by nx n and then summing with respect to n, in order to obtain the generating function The double sum is equal to Cancelling out x and multiplying by (1 − x) 2 , where C is constant, which can be found using the initial condition G(0) = 0.
The solution then is being written as power series and the coefficient sequence found is the expected sought cost. Now, one can obtain any expected cost of the algorithm, just by using these results. The "toll function" will be different for each case. Plugging in the average value, the finding becomes a matter of simple operations. This type of analysis unifies the recurrences of Quicksort into a single one and provides an intuitive insight of the algorithm.

Higher moments
We have effectively calculated the first and second moments of C n in Quicksort.
Existing literature does not seem to address much questions about skewness and kurtosis, which are sometimes held to be interesting features of a random variable. Here, we present an inconclusive discussion about the sign of the skewness.
Using the probability generating function, we can obtain higher moments of the algorithm's complexity. A Lemma follows Lemma 2.5.1. Let a random variable X having probability generating function: For the k-th order derivative it holds that Proof. Simply by computing successively the k-th order derivative of f X (z), we obtain n · (n − 1) · . . . · (n − k + 1)P(X = n) · z n−k Setting z = 1, the proof follows directly. Note that the argument is similar to continuous random variables.
Using MAPLE, we obtained a recursive form for the general k-th order derivative of the generating function.

Lemma 2.5.2. Let
be the generating function of Quicksort's complexity in sorting n keys. The k ∈ N order derivative is given by where the Γ function is defined for complex variable z = 0, −1, −2, . . . as and when z is a positive integer, then Γ(z) = (z − 1)!.
Proof. For k = 0, the result follows trivially. Assume that the statement of the Lemma holds for k = m. The (m + 1)-th order derivative is Therefore, The well-known identity, (e.g. see [26]) completes the proof.
We should point out that Lemma 2.5.2 is an immediate consequence of Leibniz's product rule. Next, we shall ask a Question about the sign of the skewness of the time complexity of the algorithm, as it is moderately difficult to solve the recurrence involved, in order to compute the third moment. We already have seen that the possibility of worst-case performance of the algorithm is rather small and in the majority of cases the running time is close to the average time complexity which is O n log 2 (n) . Intuitively, this suggests that the complexity is negatively skewed. We present the following Question: However, great deal of attention must be exercised to the fact that the random number of comparisons required to sort the segment of keys less than the pivot and the segment of keys that are greater than the pivot are conditionally independent, subject to the choice of pivot.

Asymptotic analysis
After having examined the number of comparisons of Quicksort, in terms of average and worst case scenarios, and its variance, it is desirable also to study the concentration of the random variable C n about its mean. One might hope, by analogy with other probabilistic situations, that for large values of n the number of comparisons is highly likely to be very close to the mean.
The analysis will be confined to the number of comparisons, because this is the most relevant measure for this thesis. Since our results will be asymptotic in nature, we need to have some relevant ideas about convergence of sequences of random variables. The following definitions come from [8], [21].
at every point x where F is continuous. Here F n (x) and F (x) are respectively the cumulative distribution functions of random variables X n and X. We shall denote this type of convergence by X n We will denote this type of convergence by X n P −→ X.
Note that convergence in L p -norm, for p ≥ 1, implies convergence in probability, and it is also easy to see that convergence in probability implies convergence in distribution: see e.g. [8]. Both converse statements are false in general.
We also present the definition of martingale, which shall be employed in a later stage of our analysis.

Binary trees
In this subsection, a central notion to the analysis of Quicksort, and in general to the analysis of algorithms is discussed. We begin with a definition.

Definition 2.6.3. A graph is defined as an ordered pair of two sets (V, E). The set V corresponds to the set of vertices or nodes. The set E is the set of edges,
which are pairs of distinct vertices.
One kind of graph we concentrate on are trees. A definition of a tree (which suits us) is as follows [44]: Tree is a finite set ∆ of nodes, such that: (i) There is a unique node called the root of the tree.
(ii) The remaining nodes are partitioned into k ∈ N disjoint sets ∆ 1 , ∆ 2 , . . . , ∆ k and each of these sets is a tree. Those trees are called the subtrees of the root.
A particularly common tree is a binary tree. It is defined as a tree with the property that every node has at most 2 subtrees, i.e. each node -excluding the root -is adjacent to one parent, so to speak, and up to two offspring, namely left and right child nodes. Note here that nodes which do not have any child nodes are called external. Otherwise, they are called internal. The size of a binary tree is the number of its nodes. The depth of a node is simply the number of edges from that node to the root in the (unique) shortest path between them and the height of a binary tree is the length from the deepest node to the root.
An extended binary tree is a binary tree with the property that every internal node has exactly two offspring [44]. Let D j be the depth of insertion of a key in a random binary tree of size j − 1. Since the root node is first inserted to an empty tree, it holds that D 1 := 0. The next inserted key is compared with the key at the root and if it is smaller, is placed to the left; otherwise is attached as a right subtree, thus D 2 := 1.
Thus, we define the internal path length of an extended binary tree having n internal nodes, to be equal to the sum over all internal nodes, of their distances to the root. Let us denote this quantity by X n . We then have that Similarly, the external path length is defined as the total number of edges in all the shortest paths from external nodes to the root node. The next Lemma gives a relationship between those two quantities.
Lemma 2.6.5 (Knuth [44]). For an extended binary tree with n internal nodes it holds that where Y n denotes the external path length of the tree.
Proof. Suppose that we remove the two offspring of an internal node v, with its offspring being external nodes of the tree. We suppose that v is at distance h from the root. Then the external path length is reduced by 2(h+1), as its two offspring are removed. At the same time, the external path length is increased by h, because the vertex v has just become an external node. Thus, the net change is equal to −2(h+1)+h = −(h+2). For internal path length the change is a reduction by −h as v is no longer internal. Thus, overall, the change in The Lemma follows by induction.
Binary trees play a fundamental and crucial role in computing and in the analysis of algorithms. They are widely used as data structures, because fast insertion, deletion and searching for a given record can be achieved. In Quicksort, letting nodes represent keys, the algorithm's operation can be depicted as a binary tree. The root node stores the initial pivot element. Since the algorithm at each recursion splits the initial array into two subarrays and so on, we have an ordered binary tree. The left child of the root stores the pivot chosen to sort all keys less than the value of root and the right child node stores the pivot for sorting the elements greater than the root.
The process continues until the algorithm divides the array into trivial subarrays of order 0 or 1, which do not need any more sorting. These elements are stored as external or leaf nodes in this binary structure. It easily follows that for any given node storing a key k, its left subtree store keys less than k and similarly its right subtree contain keys greater than k.
In variants of Quicksort, where many pivots are utilised to partitioning process, the generalisation of binary trees provides a framework for the analysis, though we do not develop this in detail here. In the next subsection, the lim-iting distribution of the number of comparisons will be analysed, in terms of trees.

Limiting behaviour
We have previously seen that the operation of the algorithm can effectively be represented as a binary tree. Internal nodes store pivots selected at each recursion step of the algorithm: so the root vertex, for example, stores the first pivot with which all other elements are compared. We are interested in the total number of comparisons made. To understand this, we note that every vertex is compared with the first pivot which is at level 0 of the tree. The array is divided into two parts -those above the pivot, and those below it. (Either of these subarrays may be empty). If a subarray is not empty, a pivot is found in it and is attached to the root as a child on the left, for the elements smaller than the first pivot or on the right for the elements larger than the pivot.
The process then continues recursively and each element at level k in the tree is compared with each of the k elements above it. Thus the total number of comparisons made is the sum of the depths of all nodes in the tree. This is equivalent to the internal path length of the extended binary tree. Thus, where Y n is the external path length of the tree. To see this, we simply use Lemma 2.6.5. This fact can be also found in [49].
Generally, assume that we have to sort an array of n distinct items with pivots uniformly chosen. All n! orderings of keys are equally likely. This is equivalent to carrying out n successive insertions [46]. Initially, the root node is inserted.
The second key to be inserted is compared with the key at the root. If it is less than that key, it is attached as its left subtree. Otherwise, it is inserted as the right subtree. This process continues recursively by a series of comparisons of keys, until all n keys have been inserted. Traversing the binary search tree in order, i.e. visiting the nodes of the left subtree, the root and the nodes of the right subtree, keys are printed in ascending order. Thus, Quicksort can be explicitly analysed in this way.
Recall that each internal node corresponds to the pivot at a given recursion of the Quicksort process (e.g. the depth of a given node). Thus the first pivot corresponds to the root node, its descendants or child nodes are pivots chosen from the two subarrays to be sorted, etc. Eventually, after n insertions, we have built a binary search tree from top to bottom. We can use this approach to understand the following Theorem of Régnier [58].
Theorem 2.6.6 (Régnier [58]). Let random variables Y n and X n denote respectively the external and internal path length of binary search tree, built by n successive insertions of keys. Then the random variables

form a martingale with null expectations. For their variances it holds
Proof. By induction on n, the base case being trivial. Suppose we have an (n − 2)-vertex tree and consider the insertion of the (n − 1)-th key in the random binary tree. Its depth of insertion is D n−1 , so that a formerly external node becomes an internal and we see that its two (new) descendants are both at depth D n−1 + 1. Recall that D n is the random variable counting the depth of insertion of a key in a random binary tree of size n − 1, thus D 1 := 0 and The following equation concerning conditional expectations holds: This recurrence yields Summing and using that the left-hand side is a telescopic sum, The last equation is justified by Lemma 2.6.5. Also, we have Thus, taking expectations and using E(E(U|V )) = E(U),

This recurrence has solution
For Z n , we deduce that Therefore, Z n form a martingale. Further, note that Z n is a linear transformation of the internal path length X n , so we get that Previously, we saw that the number of comparisons is just the internal path length of a binary search tree. As a reminder the variance of the number of comparisons is equal to n − 2(n + 1)H n + 13n. Hence, For the purpose of obtaining the asymptotics of the variance, an important family of functions, which is called polygamma functions are discussed. The digamma function is and for complex variable z = 0, −1, −2, . . . can be written as [1], In general, ∀k ∈ N, the set , forms the family of polygamma functions. Differentiating Eq. (2.7), (2.8) By Eq. (2.7), it easily follows that H n = ψ(n + 1) + γ.
Further, using the fact that ζ(2) = lim n→∞ H 1 j s is the Riemann zeta function for Re(s) > 1, we obtain Eq. (2.9) is asymptotically equivalent to thus, the asymptotic variance is Remark 2.6.7. We note that there is a typo in the expression for the asymptotic variance in Régnier's paper [58], which is given as The correct formula for the asymptotic variance is stated in Fill and Janson [22].
The key point about martingales is that they converge. Theorem 2.6.8 (Feller [21]). Let Z n be a martingale, and suppose further that there is a constant C such that E(Z 2 n ) < C for all n. Then there is a random variable Z to which Z n converges, with probability 1. Further, E(Z n ) = E(Z) for all n.
We showed that It is important to emphasise that the random variable Z to which we get convergence is not normally distributed. We saw that the total number of comparisons to sort an array of n ≥ 2 keys, when the pivot is a uniform random variable on {1, 2, . . . , n} is equal to the number of comparisons to sort the subarray of U n − 1 keys below pivot plus the number of comparisons to sort the subarray of n − U n elements above pivot plus n − 1 comparisons done to partition the array. Therefore, where the random variables X Un−1 and X * n−Un are identically distributed and independent conditional on U n .
Consider the random variables The previous equation can be rewritten in the following form By a simple manipulation, it follows that [22], [59] The random variable U n /n converges to a uniformly distributed variable Ξ on Proof. The moment generating function of U n is given by For the random variable U n /n, it is The random variable Ξ has moment generating function Now the moment generating function of U n /n is an approximation to the average value of e sx over the interval [0, 1] and so, as n tends to infinity, we can replace it by its integral and now all that is required has been proved.
For the function using the previous Lemma and recalling that asymptotically the expected complexity of Quicksort is 2n log e (n) it follows that Thus C n (n · U n /n) converges to C(Ξ), (see as well in [59]). Therefore, we obtain But this does not work for the normal. Indeed, if Y (and hence Y * ) are normals with mean zero and variance σ 2 , a necessary condition for Y Ξ + Y * (1 − Ξ) + C(Ξ) to have mean 0 (which would be needed for the equality to hold) would be that C(Ξ) = 0. This equality happens with probability equal to 0, as we can easily deduce. Thus, the distribution which the sequence Y n converges is not Gaussian.

Deviations of Quicksort
It is desirable to derive bounds on the deviation of the random number of pairwise comparisons, needed to sort an array of n distinct elements from its expected value, as n gets arbitrarily large. We remind ourselves that the pivot is uniformly chosen at random.
In the recent paper of McDiarmid [51], Theorem 2.6.11 is revisited using concentration arguments. By this result, it can be easily deduced, that Quicksort with good pivot choices performs well, with negligible perturbations from its expected number of comparisons. As we previously saw, Quicksort can be depicted as an ordered binary tree. The root node or node 1 corresponds to the input array of length L 1 = n to be sorted.
A pivot with rank U n = {1, 2, . . . , n} is selected uniformly at random and the initial array is divided into two subarrays, one with elements less than the pivot and a second, with elements greater than the pivot. Then, the node at the left corresponds to the subarray of keys that are less than the pivot, with length L 2 = U n − 1 and the node at the right corresponds to the subarray of keys that are greater than the pivot, with length L 3 = n − U n .
Recursively, Quicksort runs on these two subarrays and split them in four subarrays, until we get trivial subarrays and the initial array is sorted. For j = 1, 2 . . . let L j be the length of the array to be sorted at j node and M n k be the maximum cardinality of the 2 k subarrays, after k recursions of Quicksort.
It is [50], The following Lemma gives an upper bound for the probability that the maximum length of 2 k subarrays M n k , will exceed α times the initial set's length n.
We easily see that the upper bound is rather small quantity. Thus, we deduce that the length of the array is rapidly decreasing, as Quicksort runs.
For any 0 < α < 1 and any integer k ≥ log e 1 a it holds So far, the analysis explicitly assumed the presence of distinct numbers. However, in many sorting problems, one can come across with duplicates. As we will see next, we have to consider the presence of equal numbers and how this affects the algorithm's performance.

Quicksorting arrays with repeated elements
In this section, we consider the presence of equal keys. In some cases, there may be multiple occurrences of some of the keys -so that there is a multiset of keys to be sorted. If a key a i appears s i times, we call s i the multiplicity of Thus, we have a multiset of the array {s 1 · a 1 , s 2 · a 2 , . . . , s n · a n }, with s 1 + s 2 + . . . + s n = N and n is the number of distinct keys. Without loss of generality, we assume that we have to sort a random permutation of the array {s 1 · 1, s 2 · 2, . . . , s n · n}. Obviously, when s 1 = s 2 = . . . = s n = 1, then the array contains n = N distinct keys.
Consider an array consisting of keys with "large" multiplicities. The usual Quicksort algorithm is quite likely to perform badly, since keys equal to the pivot are not being exchanged. Recall that Hoare's partitioning routine [30] described in the previous Chapter, utilises two pointers that scan for keys greater than and less than the pivot, so at the end of partition, keys equal to pivot may be on either or both subarrays, leading to unbalanced partitioning which we saw is usually undesirable. The algorithm can be further tweaked for efficient sorting of duplicates, using a ternary partition scheme [7]. Keys less than pivot are on left, keys equal to pivot on middle and on right, keys greater than the pivot.
Hoare's partitioning scheme can be easily modified, in order for the pointers to stop on equal keys with the pivot. In other words, the lower pointer searches for a key greater than or equal to the pivot and the upper one for a key smaller than or equal to the pivot. Sedgewick [64] considers a partitioning routine, where only one of the pointers stops on keys either greater or smaller than the pivot.
The recurrence for the expected number of key comparisons E C(s 1 , s 2 , . . . , s n ) is The analysis has been done in [64]. The solution of the recurrence is Note that when n = N, i.e. the keys to be sorted are distinct, Eq. (2.10) yields the expected number of comparisons, when the array is partitioned using n − 1 comparisons. As we saw in the previous Chapter, a different partitioning scheme proposed and analysed in [46], [63], utilises N + 1 comparisons for partitioning an array of N keys. In this case, an upper bound for large n to the expected number of comparisons is [64], Chapter 3

Sorting by sampling
The preceding analysis has shown that Quicksort is prone to poor performance, when the chosen pivots happen to be (close to) the smallest or greatest keys in the array to be sorted. The partitioning yields trivial subarrays, leading to quadratic running time taken by the algorithm, and increasing the chances of 'crashing', i.e. an application of Quicksort may terminate unsuccessfully through running out of memory. On the other hand, good choices of pivot yield a much more efficient algorithm. The uniform model suggests that in fact any key has equal probability to be selected as pivot. In this Chapter, we discuss and analyse the general idea of how one can increase the probability that the selected pivots will produce (reasonably) balanced partitions, by trying to ensure that their ranks are 'near' the middle of the array.
A naive idea towards this, would be finding the median of the keys and use this as pivot. However, it is obvious that the finding of median imposes additional costs to the algorithm. Therefore, despite the always good choices, this method might not be better than choosing the pivot randomly. Instead of finding the median of the array to be sorted, it might be more efficient to randomly pick a sample from the array, find its median and use this as pivot. In what it follows, we will analyse this idea and its variants.

Median of (2k+1) partitioning
Singleton [68] suggested to randomly select three keys from the array to be sorted and use their median as pivot, leading to a better estimate of the median of the array and reducing further the chances of worst case occurrence.
This modification can be generalised as to choosing a sample of (2k +1) keys at every recursive stage, computing their median and using that median as pivot, partitioning n > 2k + 1 keys. Arrays that contain at most (2k + 1) keys are sorted by a simpler algorithm, such as insertion sort. The cost of sorting these small arrays is linear with respect to n.
Letting C n{2k+1} denote the number of comparisons required to sort n keys when the pivot is the median of a random sample of (2k + 1) elements, uniformly selected from the relevant array, the recurrence for the average number of comparisons is given by (see [46]) Multiplying both sides by n 2k + 1 , Multiplying by z n and summing over n, in order to obtain the generating function for the expected number of comparisons, where f (2k+1) (z) denotes the (2k + 1)-th order derivative of f (z). For the first sum in the right-hand side of Eq. (3.1) The (2k + 2)-th order derivative of z/(1 − z) can be easily seen by induction that is equal to Expanding out the double sum of Eq. (3.1), The recurrence is transformed to the following differential equation Multiplying both sides by which is a Cauchy-Euler differential equation. This type of differential equations arises naturally to the analysis of searching-sorting algorithms and urn models [14]. Substituting x = 1 − z, and putting h( We use the differential operator Θ for the solution of the differential equation.
It is defined by and by induction Applying the operator, our equation becomes where the indicial polynomial is equal to We proceed to identify the nature of the roots of the polynomial. A Lemma follows: 3k + 2, if k is odd and the 2 k 2 complex roots ρ 1 , . . . , ρ ⌊ k 2 ⌋ with their conjugates Proof. Let α = x + iy being a root of the polynomial. Then From Eq. (3.2), we deduce that k real roots of the polynomial P 2k+1 (Θ) are Then To see all roots are simple, assume that there does exist a repeated root α.
Since the roots are simple, we can factor our polynomial in the form The solution to the differential equation Therefore, applying (2k + 1) times the solution, we obtain where c j are the constants of integration. Note that Reverting to the previous notation, Using the identity [26], H n+m − H m n + m m z n and the binomial Theorem, the solution of the differential equation can be written in terms of series, Extracting the coefficients, the expected number of comparisons of 'median of (2k + 1)' Quicksort is The real roots of the polynomial 0, 1, . . . , (k − 1) do not contribute to the expected number of comparisons, since n > 2k + 1 and when k is odd, the root (3k + 2) adds a negligible constant contribution. Further, note that the root The asymptotics of the real parts in the last sum is given in [27]. It is proved and asymptotically the expected number of key comparisons is since all the other roots have real parts greater than −2. The solution contains the case of ordinary Quicksort, where the pivot is randomly selected and of 'median of 3' Quicksort. The coefficient of the leading term in the latter case thus the expected number of key comparisons is van Emden [19] obtained the asymptotic cost of the expected number of comparisons, using entropy arguments. The leading term is equal to Here g(x) denotes the probability density of the median of a random sample of (2k + 1) elements and E(H) is the expected information yielded from a comparison. The nice and simple asymptotic form for the mean number of comparisons is Note that this result, yields the expected number of comparisons of standard Quicksort, for k = 0. In this case, The notion of entropy is of great importance to the analysis presented in this thesis. Entropy is a measure of uncertainty regarding the events of a random variable. In other words, a higher uncertainty about the outcome of a random variable pertains to increased entropy. In the trivial case, where the probability of occurrence of an event is 1, the entropy is equal to 0, as there is no uncertainty. A formal definition follows [65].
The base b of the logarithm will be normally equal to two; in this case we measure bits of entropy. We should mention that the notation H(X) does not merely denote a function of X; entropy is a function of the probability distribution. Generally, in sorting algorithms that utilise comparisons for this task, entropy quantifies the amount of information gained from the sorting.
Consider an unsorted array, with all the n! permutations equally likely. A comparison gives 1 bit of information, thus at least log 2 (n!) = Ω n log 2 (n) comparisons are needed for a complete sort -see in [5]. This quantity is called information-theoretic lower bound. The range of entropy is given in the following Lemma. Proof. Since log b p(x i ) ≤ 0, the left inequality follows immediately. Noting that the logarithm is concave function and applying Jensen's inequality [38], which for a random variable X and a concave function f , states that The next four definitions can be found in [16], [53] and [65].
where p(x, y) is the probability that X takes the value x and Y the value y. p(x, y) p(y) .
Definition 3.1.6. The information content of a random variable X, with probability distribution P(X) is From definition 3.1.6, one can easily deduce, that In other words, entropy is the expected value of the information. We proceed to the definition of mutual information.
Definition 3.1.7. The mutual information of two discrete random variables X and Y is defined as: and quantifies the amount of information provided about X by Y .
These definitions will be used in a later part of the thesis.
We have to point out that up until now, our analysis did not take into account the added overhead of finding the median at each stage. In the simple case of three elements, the overhead is not significant, but for larger samples this might have adversary effects to the efficiency of Quicksort.
For the selection of the median, we use Hoare's Find algorithm [29] or For the sample of (2k+1) keys, the rank of the median is k+1. Therefore, The cost for finding the median of a random sample of 3 keys is 8/3 comparisons at each stage. However, as the sample of keys increases, in order to obtain a more accurate estimate of the median, the added overhead imposes a bottleneck to the efficiency of the algorithm.
The computation of other measures of this variant, such as the expected number of exchanges and passes can be performed by solving analogous recurrences, as the one for the number of comparisons. The average number of passes is recursively given by where the "toll function" is now one recursive call to the algorithm, after the chosen pivot is the median of (2k + 1) keys, which yields two subarrays. This recurrence can be turned to a differential equation with solution noting that for k = 0, the average number of passes is n. In the scheme, where arrays containing m or fewer keys are sorted by insertion sort, the average costs are reduced. We refer to [27] where this variant is analysed.

Remedian Quicksort
In the previous section, we analysed the modification of Quicksort, where the pivot is selected as the median of a sample of (2k + 1) elements. This variant are selected as elements of the sample. In case that two keys of this sample happen to be the smallest (or greatest) elements of the array, the chosen pivot will be 2 (or n − 1), leading to trivial partitioning, making Quicksort everything else, except quick! In [63], a permutation of the array {1, . . . , 15} is given, which leads Quicksort to worst-case performance and in [20], an algorithm is presented which forms the worst-case permutation.
In order to remedy this, a bigger sample of (2k + 1) β keys is randomly selected, its remedian is found and used as partitioning element of the array to be sorted. The remedian of the sample is recursively defined to be the median of (2k + 1) remedians of (2k + 1) β−1 elements, where the remedian of (2k + 1) elements is the median, and is shown to be a robust estimator of the median [60], [72].
A particular case of the remedian Quicksort widely used in sorting applications is Tukey's 'ninther', where the selected pivot is the median of three medians of three samples, each containing three elements [14], [72]. In practical implementations, this variant exhibits faster running time [7] with little added overhead. Specifically, the computation of the remedian of 9 elements takes on average 4 × 8 3 comparisons at each call -four times more than finding the median of 3 randomly chosen keys.
Let C n{(2k+1) β } denote the number of comparisons required for the complete sorting of an array of n distinct keys, where the chosen pivot at each call is the remedian of a random sample of (2k + 1) β elements. The recurrence relation is much more complicated than the previous ones and the probability p β j that the remedian of (2k + 1) β elements is the (j + 1)-th element is is the multinomial coefficient and p(α 1 , . . . , α 2k+1 ) is defined by with p (0) = 1. See as well [14], where the 'splitting' probabilities of 3 d remedian are presented.
Bentley's and McIlroy's experiments on the 'remedian of 3 2 ' Quicksort [7] showed that the average number of key comparisons is 1.094n log 2 (n) − 0.74n, very close to the information-theoretic lower bound of n log 2 (n) − 1.44n. This Quicksort utilises the 'ninther' partitioning for large arrays, then the 'median of 3' is used and as the algorithm proceeds, the partitioning strategy changes to the standard uniform pivot selection. The paper written by Durand [18] con- ing. An obvious advantage of this method, is that the cost of computing the median or remedian of a sample at each call of the algorithm is avoided and instead all the pivots for the subsequent calls belong in one sample.

Samplesort
Having examined the strategy of selecting the median of a sample as pivot and the more complicated 'remedian' variant, we proceed to the analysis of Samplesort algorithm invented by Frazer and McKellar [24]. Instead to randomly select a sample of keys at each stage, computing the median and using it as pivot, a larger sample of 2 k − 1 keys is selected and extracted out of the array.
It is sorted and its keys are being used as partitioning elements for the sorting of the array.
First the median of the sample is used as pivot, then the lower quartile to the lower subarray and the upper one to the subarray of the elements that are greater than the median. When the sample is exhausted, the resulting subarrays can be recursively sorted by the same procedure or by standard Quicksort.
For convenience, let 2t + 1 = 2 k − 1 and let us denote the total number of comparisons of Samplesort applied to n keys by C to the number of comparisons to sort the sample of 2 k − 1 elements, plus the number of comparisons to insert its elements to the remainder of the array, plus the number of comparisons required to sort the resulting 2 k subarrays, using ordinary Quicksort [24]. For the sorting of the sample, we use Quicksort and the average number of comparisons is Assume that the sorted sample is the median x t+1 is inserted to its final position in the array of n − 2t keys, by pairwise comparisons of the n − 2t − 1 keys to x t+1 . The cost of partitioning is n − 2t − 1 comparisons. Then, the first quartile is inserted to the subarray of the elements less than the median x t+1 and the third quartile to the subarray of the elements greater than x t+1 . The cost of partitioning these two subarrays is n − 2t − 1 comparisons, since the sum of their lengths is n − 2t − 1 keys. The process is continued until all the elements of the sample are used as pivots and this will take 2t + 1 partitioning stages. Thus, an approximation to the average number of comparisons for the insertion of the sample is [24], [49], After all elements have inserted, there are 2(t + 1) subarrays to be sorted by Quicksort. The expected number of comparisons is [24] 2(n + 1)(H n+1 − H 2(t+1) ) − 2(n − 2t − 1).
For large values of n, the expected number of comparisons is given by the following Corollary.
It is worthwhile to note that the programming of Samplesort is simple and straightforward, thus making it a suitable candidate to sorting applications. It is proven in [24], that the procedure is asymptotically optimal, i.e. as n → ∞, the expected number of comparisons approaches the information-theoretic bound. The process of randomly drawing the sample out of the array to be samplesorted should be carefully selected, to the effect that the elements of the sample will produce 'balanced' partitions. The main feature of Samplesort is that partitioning preserves the order of the sample, thus its keys are exchanged with the ones that they have to, so as to the exhaustion of the sample, its elements to be spread far apart.
In the direction of choosing a more 'centered' sample, one can proceed by randomly selecting three samples -each containing three keys -and computing their medians, at an extra cost of 8 comparisons. For the sorting of larger arrays, the number of samples will obviously be greater. The medians will be used as elements of the sample and the remaining elements can be randomly chosen from the array. It should be noted, that this is an initial idea, lacking the mathematical analysis.
Albacea [2] derived a modification of Samplesort. This variant starts with 1 key, that is used as pivot for the partition of 2 keys, so to have a sorted array of 3 keys. These keys are used as pivots for the partitioning of 4 keys, so as to obtain a sorted array of 7 keys and so on, until the whole array is sorted. It is proven [2] that the estimated expected number of key comparisons is n⌈log 2 (n + 1)⌉ − 2 ⌈log 2 (n+1)⌉ − n + ⌈log 2 (n + 1)⌉ + 1. We show that the average case analyses of these variants can be fully described by a general recurrence model, which is transformed to a differential equation, whose solution provides the expected cost of these variants. Further, we demonstrate that the integration constants involved in the solution, can be efficiently computed using Vandermonde matrices.

Quicksorting on two pivots
Along the array is partitioned into three subarrays: one with (i − 1) keys smaller than i, a subarray of (j − i − 1) keys between two pivots and the part of (n − j) elements greater than j.
The algorithm then is recursively applied to each of these subarrays. The number of comparisons during the first stage is for i = 1, . . . , n − 1, and j = i + 1, . . . , n. Note that in the specific partitioning scheme, each element is compared once to i and elements greater than i are compared to j as well. The average number of comparisons for the partitioning of n distinct keys is Letting C n,2 denote the number of comparisons of dual pivot Quicksort applied to an array of n items, the recurrence for the expected number of comparisons is Note that the three double sums above are equal. Therefore, the recurrence becomes E(C n,2 ) = 5n − 7 3 + 6 n(n − 1) Letting a n = E(C n,2 ), we have a n = 5n − 7 3 + 6 n(n − 1) It holds that a 0 = a 1 = 0. Multiplying both sides by n 2 , we obtain n 2 a n = n 2 5n − 7 3 + 6 n(n − 1) This recurrence will be solved by the difference method. We have ∆F (n) := F (n + 1) − F (n) and for higher orders Applying the difference operator ∆ n 2 a n = n + 1 2 a n+1 − n 2 a n = 5n 2 − 3n 2 + 3 n−1 i=0 a i ∆ 2 n 2 a n = ∆ n + 1 2 a n+1 − ∆ n 2 a n = 5n + 1 + 3a n .
Unwinding, we have n 4 a n = 18 The second sum of Eq. (4.1) is thus n 4 a n = 9 2 =⇒ a n = 9 2 + 10 n + 1 5 The expected number of comparisons, when two pivots are chosen is a n = 2(n + 1)H n − 4n.
This is exactly the same as the expected number of comparisons for ordinary Quicksort.
Next, the expected number of key exchanges will be computed. The exchanges during partitioning are performed as follows. Set two pointers l ← 2, u ← n−1 and store temporarily the pivots in another array of size two, so the cells at locations 1 and n are empty, leaving two "holes".
After the pivots are sorted by one comparison, the key at position 2 is compared to the first pivot (i.e. the smaller of the two pivots); if it is less than the pivot, it is put into the left hole, which now is moved one position to the right and l is increased by one. If it (i.e. the key at position 2) is greater than the first pivot, it is compared to the second pivot (i.e. the greater of the two pivots). If it is less than the second pivot, l is increased by one, otherwise l stops. Now, the u pointer starts its downward scan. If an examined key is greater than both pivots, it is put into the right hole, which is moved one position to the left and u is decreased by one. If a key is less than the second pivot and greater than the first, then u is decreased by one. In case that a key is less than the first pivot, then u stops its scan and the key that is greater to the second pivot, where l has stopped is put to the right hole, which is moved one position to the left and the key where u has stopped is put to the left hole, which is moved one position to the right. Then, l is increased by one, u is decreased by one and l resumes its scan.
When pointers are crossed, the first pivot is put to the left hole, the second pivot is put to the right hole and partition is completed, since keys less than the first pivot are on its left, keys between two pivots on the middle and keys greater than the second pivot are on its right subarray. Note that the auxiliary space required for the storing of pivots is O(1), since at the end of the partition routine, the pivots are moved back to the array and two other new pivots can be stored, as the algorithm operates on a given subarray. We refer to [63] for further details of this scheme.
The average number of swaps during the first stage is since (i − 1) keys are less than pivot i. Thus, the average contribution is For the (n − j) keys greater than j the average value is the same, because the sums are equal. Adding the two final "exchanges" to get the pivots in place, the average number of exchanges during the partitioning routine is 2(n + 1) 3 .
Letting S n,2 denote the number of exchanges of dual pivot Quicksort, the recurrence for the mean number of exchanges in course of the algorithm is E(S n,2 ) = 2(n + 1) 3 Multiplying both sides by n 2 , n 2 E(S n,2 ) = n(n − 1)(n + 1) 3 + 3 This recurrence is solved in [63]: here we present a solution using generating functions. Letting b n = E(S n,2 ) and g(z) = ∞ n=0 b n z n be the generating function of the average number of exchanges, the recurrence is transformed to the following differential equation: The double sum is equal to and our differential equation becomes

The differential equation can be simplified by multiplying both sides by
An elementary approach to solving this differential equation, is to assume that the solution is of the form x m [9]. Substituting the "trial solution" to Eq. Eq. (4.2), which can be found e.g. using the method in [61], is By the initial conditions f (1) = −f ′ (1) = 0, the solution is In the next section, we will examine the generalised version of this differential equation. Reverting to variable z and discarding terms for n ≤ 3, we see that, expanding out the fraction term as a series, g(z) = The recurrence for the number of partitioning stages P n,2 is much simpler; P n,2 = 1 + P i−1,2 + P j−i−1,2 + P n−j,2 .
By the same reasoning, as in the derivation of the expected number of exchanges, the solution is E(P n,2 ) = 2 5 (n + 1) − 1 2 .

The variance of the number of key comparisons
It is desirable to compute the variance of the number of key comparisons of dual pivot Quicksort, as this measure provides a grip of the deviation of the random number of comparisons from its expected value. By the recursive relation, we have noting that the resulting subarrays are independently sorted, the above is Letting f n (z) = ∞ t=0 P(C n,2 = t)z t be the ordinary probability generating function for the number of comparisons needed to sort n keys, we obtain It holds that f n (1) = 1 and f ′ n (1) = 2(n+1)H n −4n. The second order derivative of Eq. (4.3) evaluated at z = 1 is recursively given by The fourth and fifth sum turn out to be equal and by simple manipulation of indices, the sums involving products of expected values are equal. The double sum of the product of the mean number of comparisons can be simplified as follows, using Corollary 2.3.5: Further, using The four sums can be evaluated using Corollary 3 in [70].
Using the well known fact that the variance of the number of key comparisons of dual pivot Quicksort is 7n 2 − 4(n + 1) 2 H (2) n − 2(n + 1)H n + 13n. Note that the variance of dual pivot Quicksort is identical with the variance of ordinary Quicksort. In the next subsection, we provide the theoretical explanation of this fact.

Distribution of the number of key comparisons
Our results have shown that dual pivot Quicksort has the same expected number of comparisons, and the same variance, as in the case of 'one-pivot' Quicksort. Thus, it is natural to ask if the two random variables have the same distribution. We now show this, after an argument sketched by Prof. Colin McDiarmid [52].
Suppose that an array of n distinct keys x 1 , x 2 , . . . , x n is to be sorted by Quicksort and let, as usual, C n be the random number of comparisons required for the sorting. Obviously, C 1 = 0, C 2 = 1 and for n ≥ 3 we pick uniformly at random an ordered pair of distinct indices (I, J) in [n] = {1, 2, . . . , n} and we use x I as the first pivot. Given that I = i, the pivot x i partitions the array of n keys to the subarray of (i − 1) keys less than x i and to the subarray of (n − i) keys greater than x i by (n − 1) comparisons.
Given that I = i, if x J < x i , then x J is a uniformly at random chosen pivot from the subarray of (i − 1) elements less than x i . In this case, for I = i and J = j, the subarray of (i − 1) keys is partitioned to the subarray of (j − 1) keys less than x j and to the subarray of (i − j − 1) keys greater than x j by (i − 2) comparisons. Note that (i − 2) keys are compared to both pivots in two partitioning stages. Therefore, the following recurrence holds: where C If x J > x i , then x J is a uniformly at random selected pivot from the subarray of (n − i) keys greater than x i . Given that I = i and J = j, the subarray of (n − i) keys is partitioned to the subarray of (j − i − 1) keys less than x j and to the subarray of (n − j) keys greater than x j by (n − i − 1) comparisons. The recurrence relation is where as in the previous recurrence, C (1) n , C thus for any two pivots selected uniformly at random, the recurrences are the same.
Recall that for the random number of comparisons C n,2 of dual pivot Quicksort, it holds that C 1,2 = 0, C 2,2 = 1 and for n ≥ 3 we choose uniformly at random an ordered pair of distinct indices (I, J) in [n] = {1, 2, . . . , n}. The pivots x I and x J are sorted by one comparison and we assume that its outcome is x I < x J . Given that I = i and J = j, the array is partitioned to the subarray of (i − 1) keys less than x i , the subarray of (j − i − 1) keys between two pivots and the subarray of (n − j) keys greater than x j . Since keys greater than x i are compared with the other pivot as well, the recurrence for the random number of comparisons is n,2 and C (3) n,2 are independent copies of C n,2 . Note that when x I > x J , the recurrence is the same. Thus, since dual pivot Quicksort and ordinary Quicksort satisfy the same recurrence and have the same initial conditions for n = 1, 2, we deduce that the random variables C n,2 and C n are identically distributed.

Multikey partitioning
A natural extension of having two pivots would be to have some other number k of pivots. Here, we study the idea of randomly picking k pivots i 1 , i 2 , . . . , i k and partitioning the array simultaneously according to these.
Again, let a random permutation of the array {1, 2, . . . , n} be given to be sorted using this variant, with all the n! permutations equally likely to be the input.
The k rightmost keys are chosen as pivots, are compared to each other and exchanged, if they are out of order. The sorting of the pivots can be efficiently implemented by insertion sort. Since all n! permutations of the keys are equally likely to be the input, this amounts to the fact that any k-subset of keys has equal probability to be selected.
The remaining (n − k) keys are compared to the pivots and the array is partitioned to (k + 1) subarrays. The partitioning can be performed as follows. We compare the leftmost key to a randomly chosen pivot; if it is smaller than this pivot, it is compared with another smaller pivot (if one exists). Otherwise it is compared with a larger pivot (to the right) and after a series of comparisons, is inserted to its place between any two pivots, or to the left of the smallest pivot or to the right of the greatest pivot. We continue in the same fashion, until all keys are examined.
In [28], each of the (n − k) keys is compared to the pivots by binary search, so a key is compared first to the median of the sorted array of the pivots. If it is less, is compared with the first quartile, otherwise is compared with the third quartile and after a series of comparisons is inserted to its position. In worst case, it takes O log 2 (k) comparisons for the insertion of a key. Then, multipivot Quicksort is recursively applied to each of the resulting segments that contains at least (k + 1) keys and arrays with less than (k + 1) keys are sorted by insertion sort in O(n) time. This is equivalent to (k +1)-ary search trees, which is a generalisation of binary trees. Indeed, if n ≥ k + 1, the k pivots are stored in the root node of the tree in increasing order and the remaining (n − k) keys are placed in the resulting (k + 1) subtrees of the root. In case that n = 0, the tree is empty and if n ≤ k, the tree has a single node, which stores the keys in order. Under the assumption of uniformity, this is a (k + 1)-random tree of n nodes -see the article of Chern et al. [14] and Mahmoud's book [49] for the correspondence between trees and variants of Quicksort.
Let f (n, k) denote the expected cost of the algorithm applied to an array of n keys. We deliberately allow some flexibility in the form of cost; a typical example might be the number of comparisons. The expected cost of this variant is recursively given by f (n, k) = T (n, k) is the average value of a "toll function" τ (n, k) during the first recursive call and f (i ′ 1 − 1, k) denotes the average cost for sorting the subarray of (i ′ 1 − 1) elements less than i ′ 1 by multipivot Quicksort on k pivots.
Though this looks a complex k-index summation, the recursion can be simplified, by noting that the pivots are randomly selected and the sums are equal, f (n, k) = T (n, k) Multiplying both sides by n k , the recurrence relation becomes For notational convenience, let f (n, k) = a n and consider the generating func- The recurrence is transformed to a k-th order differential equation since it can be easily seen by induction that the k-th order derivative of Multiplying by This differential equation is an equidimensional Cauchy-Euler equation, as the one encountered in the previous Chapter. Changing variables . Applying the differential operator Θ, where Θg(z) = zg ′ (z), the differential equation becomes and the indicial polynomial P k (Θ) is equal to P k (Θ) = (−1) k Θ k − (k + 1)!.
Using the notation from [26],  Proof. Let α = x + iy be a root of the polynomial. It holds Suppose that Re(α) < −2. Then Considering the moduli in Eq. (4.5), we see that the left-hand side is a product of numbers which are all greater than 1, and so the overall product is greater than 1, but the right-hand side is equal to 1, leading to contradiction. Therefore every root has real part greater than or equal to −2. Further, looking over the same argument, we see that the only way we can have the real part being equal to −2 is if the imaginary part is equal to zero.
By the Fundamental Theorem of Algebra a polynomial of degree n has n complex roots with multiplicities. Note that −2 is always a simple root since, Suppose that α is a repeated root. Since Re(α) ≥ −2, we can write α = (x − 2) + iy with x ≥ 0. By the above comments we have that In particular, Im(α) = 0. But that imaginary part is equal to k−1 j=0 y (x−2−j) 2 +y 2 which is clearly only equal to zero if y = 0 i.e. the root is real. We will thus have obtained our contradiction if we can show that there are no real roots other than −2 and (for k even) k + 1.
To do this, suppose that we did have a real root α > −2. We note first that α > 0: because if not, then since −2 is also a root, there is a root of P ′ between −2 and 0 by Rolle's Theorem. But since P ′ k (β) = 0 implies that k−1 j=0 1 β−j = 0 and when β < 0 this number is clearly negative. Thus any real root α is positive. It is also ≤ k + 1 as if it were greater than k + 1 we would have α(α − 1) . . . (α − k + 1) > (k + 1)!. Further, note that k + 1 is a root if and only if k is even and there cannot be a root in α ∈ [k, k + 1) as the product Suppose then that α ∈ (j, j + 1) for some 0 ≤ j ≤ k − 1. Then the product of the non-negative numbers in the sequence α, α − 1, . . . , α − k + 1 is at most Thus, to get α being a root, we have to have that However the largest in modulus of α −j −1, . . . , α −k + 1 is α −k + 1 > j + 1 −k and so their product is less than (k − 1 − j)!. Consequently our inequalities together imply and this is a contradiction, completing the proof.
The differential equation can be written as Letting r k = −2 and the remaining (k − 1) simple roots be r 1 , r 2 , . . . , r k−1 , we Combining both solutions, where s i = c i + d i . The constants of integration can be found solving the following system of equations In terms of series; The third sum of Eq. (4.7) adds to the solution a constant negligible contribution. Also, the root (k + 1), when k is even, contributes a constant and the root r k = −2, adds s k (n + 1), with s k ∈ R. Extracting the coefficients, the expected cost of multipivot Quicksort is a n = a(k) H k+1 − 1 (n + 1)H n − n + s k (n + 1) + 2 The asymptotics of the last sum can be found by the well-known Stirling's formula, that states [26] n! ∼ √ 2πn n e n .
Expressing the binomial coefficient in terms of Γ functions, we have The relation 6.1.26 in [1] reads for x, y ∈ R, Using Stirling's formula, Therefore the term is bounded by and asymptotically, the expected cost is since all the other roots have real parts greater than −2.
Knowing the coefficients, any mean cost of the generalisation of the algorithm can be directly computed, using this solution, which assumes a simple form.
These coefficients are related to the number of pivots used during the partitioning scheme. In [28], the average number of comparisons of the first stage is given by: where s denotes the number of partitions, when s − 1 pivots are used or equivalently the maximum number of descendants of a node of an s-ary tree. The coefficient a(s)n is equal to a(s) = ⌈log 2 (s)⌉ + s − 2 ⌈log 2 (s)⌉ s .
Thus, the average number of comparisons of Quicksort on k pivots is

Derivation of integration constants using Vandermonde matrices
The constants of integration can be found using Vandermonde matrices. Differentiating m times Eq. (4.6), The result can be easily proven by induction or by Leibniz's product rule. Using the initial conditions, namely that g and its first (k − 1) derivatives are 0 when evaluated at z = 1, we obtain for m = 0, 1, . . . , (k − 1). In matrix form, the linear system is . . .
Here we use the well-known identity x n = n Turning the coefficient matrix into a Vandermonde one and using the identity n j=0 (−1) j j! n j = (−1) n , (see subsection 24 In [73], the inverse of Vandermonde matrix is given, in terms of product of an upper and lower triangular matrices. Letting A −1 denote the inverse, it is equal to It is clear that the lower triangular matrix, post-multiplied by the vector Thus, the solution is and the expected number of partitioning stages of multipivot Quicksort on k pivots is Note that therefore the mean number of partitioning stages is We remark that a generalised version of this result can be found in [28]. In [35], it was shown that the constants of integration can be computed for arbitrary values of the coefficients a(k) and b(k) by the same method, as in the derivation of the integration constants in the simple case of a(k) = 0 and b(k) = 1.
At the end of this section, it should be noted that the worst-case probability is not eliminated, but is less likely to occur. In an unfortunate situation, where the k smallest or greatest keys are selected as pivots, partitioning will yield trivial subarrays and one containing the remaining elements. If the chosen pivots happen to be close to the quantiles of the array, this yields an optimal partitioning of the array. In the next section, we examine ways of a more efficient selection of pivots.

Multipivot-median partitioning
The preceding analysis of multipivot Quicksort, where k pivots are uniformly selected at random has showed that the worst-case scenario is less likely from the standard 'one-pivot' model. Is any other way, where we can reduce further the probability of such scenario? We have seen that choosing the median from a random sample of the array to be sorted, yields savings to the running time of the algorithm. Since we have examined the analysis of multiple pivots, then we can select these pivots as the quantiles of a bigger random sample.
Thus, one can randomly choose a larger sample of k(t + 1) − 1 keys, find the (t + 1)-st, 2(t + 1)-th, . . . , (k − 1)(t + 1)-th smallest keys and use these (k − 1) statistics as pivots. Note that for k = 2, this variant contains the median of 2t + 1 Quicksort as a special case and for t = 0, we have the multipivot algorithm, whose mathematical analysis was presented in the previous section.
This 'generalised Quicksort' was introduced by Hennequin [28]. Let T (n {k,t} ) be the average of a "toll function" during the first pass and f (n {k,t} ) the total expected cost of this variant, when applied to an array of n keys. The following recurrence (which is not presented so simply in Hennequin) holds: As before, the general recurrence of average cost is translated to a differential equation with indicial polynomial [28], A Lemma follows concerning the whereabouts of the roots of this polynomial: Proof. It can be easily deduced that the integers 0, 1, . . . , (t − 1) and −2 are roots of the polynomial. Now, when t is odd and k is even, then k(t + 1) − 1 is odd and so a root α of the polynomial will satisfy and by simple manipulations we can now verify that k(t + 1) + t is also a root.
Similarly, if t is even and k is odd, we have that k(t + 1) − 1 is even and Eq.
It will be proved by contradiction that all roots have real parts greater than or equal to −2. Note that the argument is similar with the proofs of Lemmas 3.1.1 and 4.2.1. For any root r = x + iy, with x, y ∈ R holds For r = 0, 1, . . . , (t − 1), Eq. (4.9) can be written as (4.10) Assume that Re(r) < −2, then Considering the product of moduli, we see that the left-hand side of Eq. (4.10) is greater than or equal to (in modulus) the telescoping product k(t + 1)/(t + 1) = k, which gives a contradiction. Further, this argument shows that −2 is the unique root with the least real part.
By the Lemma, the polynomial can be written in terms of simple factors and the differential equation can be solved using the same way, as in other variants of Quicksort, previously analysed. The average cost of 'generalised Quicksort' when the "toll function" is linear and its average is a(k, t)n + O(1).
Our analyses of the average cost of the algorithm and its variants has showed that any Quicksort needs on average Cn log e (n) + O(n) key comparisons for the complete sorting of a file consisting of n distinct keys. The constant C can be made very close to the information-theoretic bound, as we saw. In many sorting applications the 'median of 3' is being used, with savings on the average time and little overhead for the computation of median. For large arrays, one can use the 'remedian of 3 2 ' Quicksort.

Chapter 5
Partial order of keys

Introduction
Here, we investigate the analysis of Quicksort under the assumption of prior information of the order of keys. Specifically, we assume that there is a partial order on the keys. The rough idea is to see how much having partial information compatible with the true order allows us to speed up the process of finding the true order.
Let us illustrate the idea first with a simple example. Suppose that there are d levels with k keys at each level, so that n = kd. Anything in a higher level is known to be above everything in a lower level. Computing the ratio of the expected complexities, we have where C * n and C n denote the number of comparisons of Quicksort with uniform pivot selection and in case of partial order, respectively. We consider the following cases: 1. When d is fixed number, then as n tends to infinity, Thus, 2n log e (n) = lim n→∞ log e (k) log e (n) = lim n→∞ log e (n/d) log e (n) = 1.
We see that Quicksort is on average twice as fast, when sorting a partially ordered array. Var(C k ). For simplicity, we assume k → ∞ as n → ∞ and do asymptotics. We then have (for m either n or k) and thus we get so the variance of the version with the presorting is reduced by a factor of about d. These suggest there is interest in studying this situation, we now do so in more detail.

Partially ordered sets
An approach of having additional information is the partial order of the keys.
We shall employ this assumption along the following lines. First, we present a definition [56].

Definition 5.2.1. Let a finite set P equipped with a binary relation '≤' which
has the following properties. (Here, x, y and z are elements of P ).
Then the pair (P, ≤) is called Partially Ordered Set.
Henceforth, in this thesis we abbreviate 'partially ordered set' to 'poset'. We also present two key definitions [56]. (i) A minimal element of (P, ≤), is an element with the property that no other element is smaller than it. A maximal element of (P, ≤), is an element with the property that no other element is greater than it.
(ii) A chain in P is a set T of elements, where every pair of elements of T are comparable. The number of elements of P in the longest chain in P is called the height of P and denoted by h(P ).
(iii) An antichain in P is a set U of elements, no two of which are comparable.
The number of elements of P in the order of the largest antichain is called the width of P , and is denoted by w(P ).
(iv) A total order in P is a partial order where every pair of elements are comparable. have a partial order on a set, there will be several ways of extending it to a total order on that set. Often, we will use ≺ rather than < to denote the partial order. Further, we present the following definition, that we will come across later. Another example of a partial order which usually is not a total order is the collection of subsets of a fixed set X, with the partial order ≤ being inclusion, normally denoted as ⊆. It is easy to check that, for any A ⊆ X, we have that A ≤ A since any set is a subset of itself: if A ≤ B ≤ A then we indeed have that A = B, giving asymmetry: and finally, if A ⊆ B ⊆ C then of course A ⊆ C and so ≤ will be transitive. This is not a total order if X has order at least 2, as {x 1 } ⊆ X and {x 2 } are not comparable for x 1 = x 2 members of X. However, when we have a partial order on a set P there will be at least one total order on P extending it, and in fact usually there will be several such:

Definition 5.2.5.
A linear extension of a partial order (P, ≺) is a total order < on the set P such that whenever x ≺ y in the partial order, then we have x < y in the total order too. The number of linear extensions of a poset P is denoted by e(P ).
In other words, a linear extension of a partial order is a total order on the same set which is compatible with the partial order. This is of course of great relevance to us, as the situation we are in is that we are given partial information on the true order of the set of elements and want to know how many more pairwise comparisons we have to do to work out the true order on it: that is, we are trying to identify which of the numerous linear extensions of the partial order is the true order on it, with as few comparisons as possible.
The number of linear extensions of a poset can vary substantially according to the structure of the poset. For example, trivially, if the partial order happens already to be a total order there is only one extension, namely itself. Equally trivially, if the partial order contains no comparisons -i.e. it provides no information whatsoever -then all n! possible orderings of the n elements of P are linear extensions.
Here is a generic lower bound on the number of pairwise comparisons we need to make in order to find the true order of our data, given a partial ordering P of it.
Theorem 5.2.6. Given a partial order (P, ≺) which is partial information about the true total order on the underlying set P , it takes at least log 2 e(P ) pairwise comparisons to find the total order.
Proof. Recall that linear extension or total order of a poset (P, ≺) is a total order compatible with the partial one. All elements are comparable, forming a unique chain. Now let x, y be incomparable, distinct members of poset. In A total orders, we will have that x < y and in B linear extensions, x > y. It holds that A + B = e(P ) so, Thus, after making one comparison, there are at least e(P ) 2 candidates. Similarly, of those number of linear extensions, choosing again two elements, we have to consider at least e(P ) 4 total orders. Thus, after r comparisons, we will examine at least e(P ) 2 r linear extensions. We want to identify the unique total order among the number e(P ) of all possible linear extensions. Therefore, this fraction becomes equal to unity when r = log 2 e(P ) comparisons. Kislitsyn [41] and independently Fredman [25], showed that often this lower bound is close to the truth. Theorem 5.2.8 (Fredman [25], Kislitsyn [41]). Sorting an array of n keys, which obeying a partial order P , can be achieved in worst case by log 2 e(P ) +2n comparisons.
Corollary 5.2.9. If P is a poset for which log 2 e(P ) grows faster than n, we have that the number of comparisons of finding the true total order, in worst case, is log 2 e(P ) 1 + o(1) .

Proof.
We have that this quantity is bounded below by log 2 e(P ) and above by log 2 e(P ) + 2n which is log 2 e(P ) 1 + o(1) by the assumption in the statement of the corollary.
Kahn and Kim [40] gave an algorithm for actually doing the finding of the true total order, which uses at most 54.45 log 2 e(P ) comparisons. This has recently been reproved by Cardinal et al. [13] whose proof manages to avoid Kahn and Kim's use of the ellipsoid method, a technique which though it is in theory polynomial-time, is difficult to do in practice. What all this makes clear is that, in considering how much information we can deduce from a random partial order, we will need to know about the logarithm of the number of linear extensions the partial order typically has.
Often a useful notion in studying posets is the theory of levels, [10], [42]. (ii) if x and y are in P 2 and x ≺ 2 y: (iii) if x ∈ P 1 and y ∈ P 2 , then automatically we have x ≺ y.
A useful definition for us will be the following [56].  So the point is that, if information is given in the partial order P and using pairwise comparisons to obtain the rest of the order, s(P ) is a lower bound on the number of comparisons which have to be done to find the true order.
The setup number is also known as the jump number. The following Lemma is used for the derivation of a simple lower bound on the setup number of a poset.
Lemma 5.2.13 (Dilworth [17]). The minimum number of chains into which a poset P can be partitioned is the width w(P ).
Proof. This is standard and there are several proofs, we refer to [17].
Proof. The best case is to partition the poset into w(P ) chains C 1 , C 2 , . . . , C w(P ) and hope that there is some ordering of these chains (which without loss of generality is the order given) such that every element in C i is less than the minimum element of C i+1 for each 1 ≤ i ≤ w −1. Because if this happens, then the total order is just the direct sum of the C i and we only have to do w(P ) − 1 comparisons of the maximum element of C i with the minimum element of What we will do for the next while is consider various ways in which we could have a partial order given to us before we start using Quicksort to determine the complete order. So we are imagining that a previous researcher had carried out some of the comparisons and we want to know how many more comparisons we have to carry out to determine the total order. We will consider cases where the poset is randomly generated. This means that all partial orders on S are equally likely to be chosen. The basic structural result on such posets is the following, rather surprising, one. [42]. Alternative proof by Brightwell, Prömel and Steger [11]). Suppose that ≤ is a uniform random partial order on Here is the key information on the number of linear extensions. Proof. We refer to Brightwell [10], page 66.

Corollary 5.3.5.
When P is selected uniformly at random, we have whp.
In other words, in this situation, the entropy lower bound on the number of comparisons required is essentially the right answer.

Proof.
We have by the previous result, taking ω(n) to go to infinity very slowly, in particular more slowly than log e (n), that log e (n/2)! (n/4)! 2 ω(n) ≤ log 2 e(P ) ≤ 1 log e (2) log e (n/2)! (n/4)! 2 ω(n) .  Thus the probability of the complementary event, namely that C n is within n log e log e (n) of its mean will tend to 1. Therefore, whp. the number of comparisons is in 2n log e (n) 1 + o(1) − n log e log e (n) , 2n log e (n) 1 + o(1) + n log e log e (n) .
On the other hand, we have just seen that with a uniform partial order of keys, it takes about · n log e (n) comparisons.
This number is indeed 1/ 2 log e (2) times the number Quicksort needs and the numerical value of this fraction is as stated.
It is of interest to compare this with the naive lower bound on setup number, which performs rather poorly here.

Corollary 5.3.7. The setup number of a uniform random poset is at least
Proof. This is immediate from the lower bound s(P ) ≥ w(P ) − 1 and the fact that, by the Theorem of Kleitman and Rothschild [42], we clearly have that w(P ) is greater than n/2 + O(1). Thus in this case the simplest setup number lower bound is not a very good one, as we have seen that the true answer is O n log(n) in this model.
This in turn implies that if we were to use Quicksort, even in the optimal cases, we would have to compare n/2 + O(1) pairs of keys. The expected time to do this would be asymptotically 2(n/2) log(n/2) ∼ n log(n).

Random bipartite orders
In this section, we inspect the number of linear extensions for bipartite orders.
Let present a definition [10]. We now think about the number of linear extensions. A linear extension of such an order will have to, amongst other things, put the set X in order -there are n! ways to do this -and there are similarly n! ways to order Y . However there will also be some choices to make elsewhere, because while we have some relations x < y for (x, y) ∈ X × Y in the partial order, we will also have some incomparable pairs. More precisely, the probability that a total order on X, a total order on Y and a decision rule α for each pair (x, y) ∈ X × Y on whether x ≺ y or y ≺ x, is a total order compatible with the partial order -i.e. a linear extension of the partial order -is (1 − p) ℓ(α) , where ℓ(α) is the number of reversals in α, that is the number of pairs (x, y) ∈ X × Y such that x > y in the total order.
Thus the expected number of linear extensions is (n!) 2 α (1 − p) ℓ(α) . The function multiplying (n!) 2 here is discussed at length in [10]: it is defined Though some more work needs to be done to check this, it turns out that whp.
the number of linear extensions is close to this mean value. We quote the result from Brightwell [10].
Theorem 5.4.2 (Brightwell [10]). The number of linear extensions e(P ) of a random bipartite partial order A p (X, Y ) with |X| = |Y | = n and probability p such that lim n→∞ p(n) · n 1/7 log 2 (n) 4/7 = ∞, satisfies whp., In particular this applies when 0 < p < 1 is a constant. More precisely, we have that whp.
Thus, for p constant, letting C = log 2 η(p) and noting that both logarithms approach 1 as n → ∞, we have that whp.
(Of course the two o(1) terms are different). Thus the order of magnitude of log 2 e(P ) is whp.
We need to be careful about comparing this example with Quicksort: we must remember that the total number of keys being sorted in this example is n + n = 2n. Therefore, the expected time would be 4n log e (2n) 1 + o(1) = 4n log e (n) 1 + o(1) . Thus the factor by which we are quicker here is again 2 log e (2). In other words, we get the same speed-up as for the uniform and bipartite cases. We now move forward to the analysis of random k-dimensional orders in Quicksort.

Random k-dimensional orders
Here, the application of Quicksort in a random k-dimensional order is considered. For this purpose, a definition follows: Definition 5.5.1. A random k-dimensional partial order on the set P = {1, 2, . . . , n} is defined as follows. We select k total orders on {1, 2, . . . , n} uniformly at random from all n! total orders on that set, say we chose ≤ 1 , ≤ 2 , . . . , ≤ k . We then define the partial order ≺ by Of course it is highly likely that some of the total orders will be inconsistent with each other, and so we will only get a partial order. We now have to change perspective: we assume that the partial order which results from these k total orders is given to us as partial information about the order on the set P , and that we have to use pairwise comparisons to find the true total order on P .
Therefore, the total order we are looking for, and the k total orders we used to define the partial order, may have little to do with each other.
We aim to estimate time complexity of finding the true order when the partial information given is a random k-dimensional order. Again, we use the Theorem 5.2.8 coupled with the information lower bound. Thus we need to know about the number of linear extensions of a random k-dimensional order. An important result follows, Theorem 5.5.2 (Brightwell [12]). The number e(P ) of linear extensions of a random k-dimensional partial order P with |P | = n satisfies whp.
Consequently we have that log 2 (e(P )) is bounded below by n · (1 − 1/k) · log 2 (n)(1 + o(1)) and similarly is bounded above by n · log 2 (2k) (1)). This is of course larger in order of magnitude (for fixed k, say) than 2n so the information lower bound is tight. Now, we deduce that Corollary 5.5.3. The time complexity of finding the true total order on a set given a random k-dimensional partial order on it, where k is a constant, is whp.

asymptotically equivalent to
n log e (n) log e (2) Proof. For the logarithm of the number of the linear extensions as n tends to infinity holds, Then, we obtain which completes the proof.
Therefore, the speed up relating to Quicksort with no prior information is on average n · log e (n) 2n · log e (n) log e (2)

Random interval orders
In this section, we examine the case where poset forms an interval order. A definition follows [23], [71].  showing that log 2 e(P ) is whp. at least cn log e (n) for some c > 0, which will of course be enough to show that the 2n term in the Fredman [25] -Kislitsyn [41] bound log 2 e(P ) + 2n is small compared with the term log 2 e(P ) . The main results that we need in this direction are the following two Theorems, regarding the size of the largest antichain and chain of a random interval order respectively. For their proofs, we refer to [39].
Theorem 5.6.5 (Justicz et al. [39]). Let Y n denote the maximum number of pairwise disjoint intervals in a family of n random intervals. Then The following Corollary gives a lower bound for the number of comparisons required to sort a random interval order: Corollary 5.6.6. The number of comparisons for sorting n keys, given a random interval order is whp. at least cn log e (n) 1 + o(1) , where one can take c = 1/2 log e (2) ≈ 0.72135.
Proof. Theorem 5.6.4 shows that the largest antichain of the random interval order is whp. at least r = ⌈(1 − ǫ)n/2⌉ for any ǫ > 0. This is because a family of intersecting intervals forms an antichain. Thus we need to sort all these r incomparable elements of the partial order in a total order extending it, and there are at least r! ways of doing this. Using Stirling's formula, we obtain Then we have that log 2 e(P ) has order of magnitude n log 2 (n): in particular 2n = o log 2 (e(P ) and so the complexity is log 2 e(P ) 1 + o(1) . Further, we have that log 2 e(P ) is at least, by the above, n(1−ǫ) log 2 (n) 1+o(1) /2 which is equal to n log e (n) 1 + o(1) 2 log e (2) and so we can take the constant c to be at least 1/2 log e (2).
We now present a much stronger result that gives sharp bounds on the number of linear extensions of a random interval order, following the insightful suggestions of Prof. Colin McDiarmid [52].
Theorem 5.6.7. The number of comparisons for sorting n keys, given a random interval order is whp. for 0 < ǫ < 1, between: Proof. Let 0 < a < b < 1 and consider the interval (a, b). Let I(i, j) be the , where i and j are positive integers with i odd and i < 2 j . Further, let j(a, b) be the least j such that i 2 j ∈ (a, b) for some positive integer i. There is a unique such i since if there were at least two odd i, then there is at least one even k between them and considering k/2 j , we can replace it by (k/2)/2 j−1 giving a smaller value of j and contradicting the definition of j.
Since i is unique, we may call it i(a, b).
We denote the interval I i(a, b), j(a, b) by J(a, b). Recall that i is odd with i < 2 j and observe that if b − a > 2 −j , then j(a, b) ≤ j. For a given such i and j, let A(i, j) be the set of all intervals (a, b), such that J(a, b) = I(i, j). The sets A(i, j) are antichains: for if we had two intervals (a 1 , b 1 ) and (a 2 , b 2 ) in A(i, j) with (a 1 , b 1 ) being less than (a 2 , b 2 ) (of course this is equivalent to b 1 < a 2 ) then saying that would imply that j(a 1 , b 1 ) = j(a 2 , b 2 ) and i(a 1 , b 1 ) = i(a 2 , b 2 ). But given that j(a 1 , b 1 ) = j(a 2 , b 2 ), there is clearly some i/2 j with i odd in (a 1 , b 1 ) which is less than any such in (a 2 , b 2 ) and the result follows. Indeed, if the midpoint of I(i, j) (i.e. i/2 j ) is less than the midpoint of I(i ′ , j ′ ) (i.e. i ′ /2 j ′ ) then no interval in A(i ′ , j ′ ) can precede any interval in A(i, j) in the interval order.
Let X and Y be independent and uniformly distributed random variables which denote the endpoints of a random interval in (0, 1). We have that The last equation follows because the probability density of Y , f Y (y) is 1 on Thus the random number N of intervals with length at most ǫ/4 is stochastically dominated by a binomial random variable B(n, ǫ/2) with n independent trials and success probability ǫ/2. Therefore, P N ≥ ǫn) ≤ P(B(n, ǫ/2) ≥ ǫn and this probability tends to 0, as n → ∞. This is a consequence of Chernoff's inequality, in the following form: if X is a binomially distributed variable with n independent trials and success probability p, then for δ > 0 Chernoff's inequality appears in various places: we refer to [8] and to [54].
Since the number being raised to the power n is < 1, this will indeed tend to 0 (in fact will do so rapidly). The result in our case follows plugging in p = ǫ/2 and δ = ǫ/2 and shows that the number of intervals with length at most ǫ/4 is whp. less than ǫn.
Let j 0 be a positive integer and m be the number of intervals I(i, j) with j ≤ j 0 .
Let I be a set of intervals and I ′ be the set of intervals in I with length > 2 −j 0 .
Let n(i, j) be the number of intervals of I ′ in A(i, j). Then, the number of linear extensions e(P ) satisfies, since we have to put each of the antichains in order and there are r! ways to order an antichain of r elements, and by convexity log 2 e(P ) ≥ n(i, j) log 2 n(i, j) e ≥ |I ′ | log 2 I ′ em .
Choosing j 0 sufficiently large that 2 −j 0 < ǫ/4 , the number of intervals of length at most 2 −j 0 is less than the number of intervals of length < ǫ/4 which by Chernoff's inequality is whp. < ǫn: thus almost all intervals have length at least 2 −j 0 and so I ′ has order at least (1 − ǫ)n. This will give us that whp.
This completes the proof, as this gives the lower bound and the upper bound is just a consequence of the fact that there are at most n! linear extensions of a partially ordered set with n keys, and then we use Stirling's formula again.
In the next Chapter we proceed to the analysis of partial orders where the information-theory lower bound is not ω(n). Central to the subsequent analysis are random graphs.

Chapter 6
Linear extensions of random graph orders Recall that in the previous Chapter, we examined the number of linear extensions of various partial orders, where the information-theoretic lower bound dominated the linear term. In this Chapter, we examine the case where both terms are asymptotically equivalent. We obtain bounds of the expected height of a random graph and we derive a new bound on the number of linear extensions of a random graph order.

Random graph orders
In this section, we consider random graphs. A definition follows [37]: By the definition, here and throughout this thesis, a random graph G(n, p) denotes a simple graph, without loops or multiple edges. An independent set of a graph is a subset of the vertex set, such that there is no edge connecting any two vertices. On the other hand, a clique of a random graph G(n, p) is a subset of its vertex set, with the property that an edge is arising between every two vertices. Note that p may very well depend on n. We will usually be interested in the behaviour as n → ∞. The point is that for a partial order we of course require transitivity by the axioms for a partially ordered set. But of course this is not guaranteed in a random graph. We could, for example, have the edges 1 ∼ 2 and 2 ∼ 3 in the random graph, but no edge between 1 and 3. Then of course we would have put in the edge 1 ∼ 3 as since 1 ≺ 2 and 2 ≺ 3 we must have 1 ≺ 3 by transitivity. Note that there are efficient algorithms for finding the transitive closure of a relation. What we aim to do next, following the analysis in the last section, is to consider how many comparisons will be needed to finalise the order of a set of keys when a random graph partial order on the set is given already. For our needs, we present the definition of graph entropy, introduced by Körner [47]. This definition is from Simonyi's survey on graph entropy [67].
where I(X ∧ Y ) is as in Definition 3.1.7.
As in the last Chapter, we need to know about the number of linear extensions.
The following Theorem from [4] will give us what we need. where ω(n) is any function tending to infinity with n (we usually think of it as doing so very slowly).
Proof. The proof follows directly from the previous Corollary.
In other words, the logarithm of the number of linear extensions is linear in n. Thus when we use Theorem 5.2.8, we see that both terms in it log 2 e(P ) and 2n are linear. So we do not get the exact asymptotics as in the previous Chapter. Recall that in that Chapter, we always had log 2 e(P ) = ω(n) so outweighed the linear term. (In many cases, log 2 (e(P )) was of order of magnitude n log e (n) so won comfortably). However here it is not clear what multiple of n will be the time complexity of finding the total order by pairwise comparisons.
Note that it will be at most some constant multiple of n, so this will be quicker than just using about 2n log e (n) comparisons in Quicksort -in other words, the partial order here does substantially speed up the process of finding the true order.
To deal with this question in more detail, we need to know about the structure of a random graph order. We concentrate to begin with on the case where p is a constant. In this case, we shall see that basically the partial order consists of a linear sum of smaller partial orders.

Additive parameters and decomposing posets Definition 6.2.1. A vertex v in any partial order is said to be a post if and only
if every other vertex of the partial order is comparable with it.
If v is a post in a partial order (P, ≺), then we can write the partial order as a linear sum of two subposets (P 1 , ≺) and (P 2 , ≺), namely Clearly two elements in the same P i which were comparable before still are, and any element x in P 1 is smaller than any element y in P 2 since x ≺ v ≺ y by assumption.

Definition 6.2.2. A parameter f of partial orders is said to be additive if and
only if, whenever P is the linear sum of two subposets P 1 and P 2 we have f (P ) = f (P 1 ) + f (P 2 ).
An example of an additive parameter is the height, as if we have a longest chain in P 1 and a longest chain in P 2 , we can concatenate them to form a chain in the linear sum, so f (P ) ≥ f (P 1 ) + f (P 2 ): and in the other direction, given a longest chain in P , we restrict to the subsets and get chains in P 1 and P 2 , so f (P ) ≤ f (P 1 ) + f (P 2 ), and so they are equal. Another example is the number of further comparisons needed to sort a partially ordered set which is a linear sum of two subposets. An important Lemma follows Proof. Write P = P 1 ⊕ P 2 . If we sort the whole linear sum of P 1 and P 2 with k comparisons, we have sorted P 1 and P 2 as well. Thus, taking k = c(P ), we see that c(P ) ≥ c(P 1 ) + c(P 2 ). (We have sorted P 1 and P 2 using k comparisons: we might have done it with fewer). Conversely, if we have sorted P 1 and P 2 with a total of k comparisons, then we have sorted the whole of P because, by definition, everything in P 1 is above everything in P 2 , thus c(P ) ≤ c(P 1 )+c(P 2 ).

The result follows.
Now here is a key result from Brightwell [10].
Basically, each bit between posts will be small. Indeed Brightwell's survey [10] also shows that for sufficiently large k, given our p (which remember is constant) there is a constant dependent of p, c(p) > 1 such that the probability that none of {2k, 4k, . . . , 2k 2 } are posts is less than or equal to c −k . We can now start showing how to use this idea to break down various invariants of P (n, p) into small units. We need some notation about posts. Let their posi-tions be where U 0 is the first post at or to the right of 0. Then we say that P j is the poset induced on the interval (U j , U j+1 ]. These posets are called the factors of the partial order. The next Theorem from [10] presents an important result, regarding convergence in distribution of additive parameters. Theorem 6.2.5 (Brightwell [10]). Let p be a constant with 0 < p < 1. Let f be an additive parameter of partial orders which is not proportional to |P |. Let Y and Z be the random variables f (P 0 ) and f (P −1 ) respectively. Further, suppose that the moments E(Y r ) and E(Z r ) are finite for all r ∈ N. Then there exist constants µ = µ(p) > 0 and σ = σ(p) > 0, such that E f (P (n, p)) /n → µ and Var f (P (n, p)) /n → σ 2 . Furthermore with convergence of all moments.
The following Corollary is a consequence of Theorem 6.2.5.
Proof. This follows easily from the previous Theorem.

Average height of random graph orders
What we really need to do now is to obtain bounds for the average number of linear extensions. Albert and Frieze [3], derived estimates for the average height of a random graph order, which is an additive parameter as we previously saw. The idea is the following. A random graph is sequentially constructed; at each step a new vertex j is added and the probability of an edge from it to any previously existing vertex i with i ≤ j is 1/2. They consider both an underestimate of the height and an overestimate. We present a generalisation of this construction with a constant probability p ∈ (0, 1) of an edge arising.
Proof. Let l k be the length of the longest chain in a random graph order of size k ∈ N and d k be the number of top endpoints of longest chains. Consider the addition of vertex (k + 1). The event that the new vertex (k + 1) is the new, unique, endpoint of a longest chain is the event that one or more of the edges from (k + 1) to the d k endpoints actually arises. In this event, what will happen is that the length of the longest chain will increase by 1 and the number of endpoints of longest chains will drop to 1, with probability 1 − (1 − p) d k . The complementary event is that the number of endpoints will be increased by one.
It is at the next step that we make a pessimistic assumption. The pessimistic assumption is that, in these cases where (k + 1) does not become the unique endpoint of a longest chain, the number of endpoints increases by 1 with probability only p. In fact, though there will certainly be at least one vertex one level below all the d k upper endpoints, in most cases there will be more than that -say r of them -so if (k+1) is joined to any of them the number of longest chains will increase, and the probability of this happening will be 1 − (1 − p) r .
In this event, the number of endpoints will increase by at least 1, but the length of the longest chain will remain unchanged.
Let the random variables η and θ denote the underestimates of the length of the longest chain and the number of endpoints of the longest chain(s) respectively. These variables obey the following recurrence: (η k+1 , θ k+1 ) =                (η k + 1, 1) with probability 1 − (1 − p) θ k (η k , θ k + 1) with probability p(1 − p) θ k (η k , θ k ) with probability (1 − p)(1 − p) θ k Also, let µ and φ be the overestimates of the length of the longest chain and the number of endpoints of the longest chain(s) respectively. In this case, the recurrence relation is: We consider only the second component. This is clearly a positive recurrent, irreducible, aperiodic, Markov process with state space the positive integers.
Thus a stationary distribution does exist with limiting probabilities p j = lim n→∞ P(θ n = j) and when θ k+1 = j + 1, then this could come about from θ k being j (with probability p(1 − p) j ) or from θ k being j + 1 (with probability (1 − p) (j+1)+1 = (1 − p) j+2 ). The solution giving the stationary distribution p j = lim n→∞ P(θ n = j) for the first case is The value of p 1 can be found by the following equation The expected height increment generally for p ∈ (0, 1) is Substituting p 1 , which is a function of p, the average height increment is which is equal to For the second (overestimate) case, the stationary distribution obeys the following recursive relation Thus, the value of p 1 can be retrieved by the following equation and the average height increment is which further simplified yields the simple expression Therefore, the average height increment in the overestimate case is The argument is complete.
We can rewrite the inverse of the overestimate as (1 − p) i .
The average height increment can be computed in terms of θ elliptic functions. This class of functions arises in many different areas of Mathematics and a comprehensive account of their analyses can be found at [1], [74]. The overestimate height increment assumes the simple form of where the θ 2 function is defined by, (see section 16.27
The previous equation can be expressed as a product, instead of summation.
It holds [74],  In the next section, we give sharp bounds for the average height.

Bounds on the height of random graph orders
We have managed to obtain functions f (p), which is the underestimate increment of the expected height and h(p), which is the overestimate of the expected height of a random graph partial order. We first give a lower bound on the underestimate function, which is easier to work with (more tractable). Proof. The probability of an edge arising between a newly added vertex (k+1) and any of the k existing vertices in a random graph is p, independently of the other edges. Thus, with probability p the length of a greedy chain will increase by one and with probability (1−p), the length will remain unchanged.
Thus, the expected increase in the height of a chain is p and the claim follows immediately.
Here is an upper bound on the overestimate function. This in turn is Note that as p tends from the left to 1 and this fact explains the convergence of the underestimate and overestimate, seen previously in Figure 6.1. Collecting more terms, we will be able to obtain a sharper bound in the following manner.
It holds that Its sharper than the previous one but again infinitely many terms are discarded. In order to obtain a bound using all terms, note that j(j − 1)/2 ≤ j 2 The θ 3 function is defined [1], q n 2 cos(2nz).
Thus, we obtained suitable bounds, such that In the following section, we present bounds on the number of linear extensions.

Expected number of linear extensions
Here we obtain bounds on the average number of linear extensions of a random partial order. We start by quoting a useful Theorem from [4], Theorem 6.5.1 (Alon et al. [4]). Let a random variable Y be geometrically distributed, i.e. P(Y = k) = pq k−1 , for k = 1, 2, . . . . Then, log e (k)pq k−1 < µ(p) where k(p) is defined as, with q = 1 − p.
The following Theorem regarding the expected number of linear extensions is the main contribution in this Chapter. Proof. We consider the longest chain C. We know that whp. E(|C|) ≤ h(p)n by Theorem 6.3.1. Now, by Lemma 5 of Cardinal et al. [13], which states that |C| ≥ 2 −H(P ) n, we deduce that where H(P ) denotes the entropy of the incomparability graph. By Lemma 4 of that paper, we also have that nH(P ) ≤ 2 log 2 (e(P )) .
Taking on both sides logarithms and applying Jensen's inequality [38], we get that whp. Thus, µ(p) is whp. bounded below by µ(p) ≥ − log 2 h(p) log e (2) 2 and the proof of the Theorem is complete.
As we can see from the following graph, the bound isn't tight compared with the one of Alon et al. [4]. However, its derivation provides an insight into the relation of the height of a random graph order with the number of linear extensions.

Sorting partially ordered arrays
Central to the analysis of the time complexity of sorting partially ordered sets, was the number of linear extensions, as a measure of the 'presortedness' of the array. Recall that the quantity log 2 (n!) is the lower bound of comparisons needed to sort an array of n keys, with no prior information. In all cases of partially ordered sets considered in Chapter 5, the constant 1/2 log 2 (e) Here, we discuss some preliminary ideas, that might be worthwhile for further study. Specifically, we propose the application of Shellsort for the merging of linearly ordered sets. Shellsort was invented by Donald Shell [66] in 1959 and is based on insertion sort. The algorithm runs from left to right, by comparing elements at a given gap or increment d ∈ N and exchanging them, if they are in reverse order, so in the array {a 1 , a 2 , . . . , a n } the d subarrays The sequence of the increments is crucial for the running time of the algorithm, as the pivot selection is important to Quicksort. Shell [66] proposed the sequence n 2 , n 4 , . . . , 1, which leads to quadratic time. Pratt [57] suggested a sequence of the form 2 a 3 b < n, where a, b ∈ N, which yields Θ n log 2 2 (n) time.
Incerpi and Sedgewick [36] have shown that there do exist log a (n) increments, for which the running time of the algorithm is O(n run-time.
In our problem, Shellsort can be fruitfully applied to merging chains, which can be done quite fast, using the knowledge of the partial order. Consider two chains C 1 and C 2 , C 1 = {a 1 < a 2 < . . . < a n } Starting from a 1 , with initial increment d = max{n, m}, the algorithm separately sorts d subarrays. At the second pass, the algorithm iterates from a 2 with increment d − 1. The final comparison of the element occupying the location d with its adjacent key in the position d + 1, terminates the merging process.