Elementary Yet Precise Worst-case Analysis of MergeSort, A short version (SV)

TL;DR

This paper presents two elementary and precise derivations of the exact maximum comparison count in MergeSort, providing clear formulas and bounds that enhance understanding of its worst-case performance.

Contribution

It introduces two simple yet exact derivations of the worst-case comparison formula for MergeSort, along with smooth bounds and insights into its linear behavior between powers of two.

Findings

Exact formula for W(n) involving ceiling of log n

Smooth bounds on the maximum comparisons in MergeSort

W(n) linearly interpolates between key points

Abstract

This paper offers two elementary yet precise derivations of an exact formula \[ W(n) = \sum_{i=1} ^{n} \lceil \lg i \rceil = n \lceil \lg n \rceil - 2^{\lceil \lg n \rceil} + 1 \] for the maximum number $ W(n) $ of comparisons of keys performed by $ {\tt MergeSort} $ on an $ n $-element array. The first of the two, due to its structural regularity, is well worth carefully studying in its own right. Close smooth bounds on $ W(n) $ are derived. It seems interesting that $ W(n) $ is linear between the points $ n = 2^{\lfloor \lg n \rfloor} $ and it linearly interpolates its own lower bound $ n \lg n - n + 1 $ between these points.

Equations

$$W(n)=\sum _{i=1}^n\lceil \lg i\rceil =n\lceil \lg n\rceil -2^{\lceil \lg n\rceil }+1$$

$$\sum _{i=1}^n\lceil \lg i\rceil =\sum _{y=0}^{\lceil \lg n\rceil -1}(n-2^y).$$

$$\sum _{i=1}^n\lceil \lg i\rceil =n\lceil \lg n\rceil -2^{\lceil \lg n\rceil }+1.$$

$$W(n)$$

$$C_k=\max \{n-2^k,0\}.$$

$$n-2^k>0\text{mbox}if,andonlyif,\lceil \lg n\rceil -1\ge k,$$

$$W(n)=\sum _{k\in \mathbb{N}}{C}_k=\sum _{k=0}^{\lceil \lg n\rceil -1}(n-2^k)=n\lceil \lg n\rceil -2^{\lceil \lg n\rceil }+1=\sum _{i=1}^n\lceil \lg i\rceil .$$

$$W(n)=\sum _{i=1}^n\lceil \lg i\rceil =n\lceil \lg n\rceil -2^{\lceil \lg n\rceil }+1.$$

$$W(n)\le n(\lg n+1)-2^{\lg n}+1=n\lg n+n-n+1=n\lg n+1$$

$$W(n)\ge n\lg n-2^{\lg n+1}+1=n\lg n-2n+1.$$

$$W(n)\in \Theta (n\log n).$$

$$\epsilon =1+\theta -2^{\theta }\text{mbox}and\theta =\lceil \lg n\rceil -\lg n,$$

$$n\lceil \lg n\rceil -2^{\lceil \lg n\rceil }=n(\lg n+\epsilon -1),$$

$$W(n)=n(\lg n+\epsilon -1)+1=n\lg n+(\epsilon -1)n+1.$$

$$\delta =1-\lg e+\lg \lg e\approx 0.0860713320559342,$$

$$n=2^{\lfloor \ln n+\lg \lg e\rfloor }\ln 2$$

$$n\lg n-n+1\le W(n)\le n\lg n-(1-\delta )n+1<n\lg n-0.913n+1,$$

$$W(n)<n\lg n-cn+1.$$

$$\inf \{c\in \mathbb{R}\mid \forall n\in \mathbb{N}\setminus \{0\},W(n)<n\lg n-cn+1\}=1-\delta .$$

$$W(n)\le n\lg n-cn+1$$

$$W(n)=\lg n-cn+1.$$

$$\inf \{c\in \mathbb{R}\mid \forall n\in \mathbb{N}\setminus \{0\},W(n)\le n\lg n-cn+1\}=1-\delta .$$

$$W(n)\le \lceil n\lg n-cn\rceil .$$

$$\lceil n\lg n\rceil -n+1\le W(n)\le \lceil n\lg n-0.913n\rceil .$$

$$W(n)>\lceil n\lg n-0.914n\rceil .$$

$$h=\lceil \lg n\rceil .$$

$$(n-1)h=(n-1)(\lceil \lg n\rceil )<(n-1)(\lg n+1)\in O(n\log n).$$

$$S_n=n\lceil \lg n\rceil -2^{\lceil \lg n\rceil }+2n=n(\lg n+\epsilon +1).$$

$$A_n=\frac{1}{2}(1+\frac{1}{n-1})(\lg n+\epsilon )\approx \frac{1}{2}(\lg n+\epsilon ).$$

Full text

[TABLE]

for the maximum number $W(n)$ of comparisons of keys performed by ${\tt MergeSort}$ on an $n$-element array. The first of the two, due to its structural regularity, is well worth carefully studying in its own right.

Close smooth bounds on $W(n)$ are derived. It seems interesting that $W(n)$ is linear between the points $n=2^{\lfloor\lg n\rfloor}$ and it linearly interpolates its own lower bound $n\lg n-n+1$ between these points.

The manuscript (MS) of the full version of this paper, dated January 20, 2017, can be found at:

http://csc.csudh.edu/suchenek/Papers/Analysis_of_MergeSort.pdf

ACM Computing Classification

Theory of computation: Design and analysis of algorithms: Data structures design and analysis: Sorting and searching

Mathematics of computing: Discrete mathematics: Graph theory: Trees

Mathematics of computing: Continuous mathematics: Calculus

ACM classes: F.2.2; G.2.0; G.2.1; G.2.2

††journal: ar​Xiv.org for the record as a manuscript.

1. 1 Introduction
2. 2 Some Math prerequisites
3. 3 ${\tt MergeSort}$ and its worst-case behavior $W(n)$
4. 4 An easy yet precise derivation of $W(n)$
5. 5 Close smooth bounds on $W(n)$
6. 6 Other properties of the recursion tree $T_{n}$
7. 7 A derivation of $W(n)$ without references to the recursion tree
8. 8 Other work
9. 9 Best-case analysis of ${\tt MergeSort}$
10. A A Java code of ${\tt MergeSort}$
11. B Generating worst-case arrays for ${\tt MergeSort}$
12. C Notes from my Analysis of Algorithms lecture

1 Introduction

${\tt MergeSort}$ is one of the fundamental sorting algorithms that is being taught in undergraduate Computer Science curricula across the U.S. and elsewhere. Its worst-case performance, measured by the number of comparisons of keys performed while sorting them, is optimal for the class of algorithms that sort inductively222Inductive sorting of $n$ keys sorts a set of $n-1$ of those keys first, and then “sorts-in” the remaining $n$-th key. by comparisons of keys.333In its standard form analyzed in this paper, ${\tt MergeSort}$ is not an inductive sorting algorithm. However, its worst-case performance, measured by the number of comparisons of keys performed while sorting them, is equal to the worst-case performance of the binary insertion sort first described by Steinhaus in [5] that is worst-case optimal in the class of inductive sorting algorithms that sort by comparisons of keys; see [3] page 186. Historically, it444A bottom-up version of it, invented by John Neumann. was the first sorting algorithm to run in $O(n\lg n)$ time555In the worst case..

So it seems only fitting to provide an exact formula for ${\tt MergeSort}$’s worst-case performance and derive it precisely. Unfortunately, many otherwise decent texts offer unnecessarily imprecise666Notable exceptions in this category are [2] and [4] that derive almost exact formulas, but see Section 8 page 8 for a brief critique of the results and their proofs offered there. variants of it, and some with quite convoluted, incomplete, or incorrect proofs. Due to these imperfections, the fact that the worst-case performance of ${\tt MergeSort}$ is the same as that of another benchmark sorting algorithm, the binary insertion sort of [5], has remained unnoticed777Even in [3]..

In this paper, I present two outlines888The detailed derivations can be found in [9]. of elementary yet precise and complete derivations of an exact formula

[TABLE]

for the maximum number $W(n)$ 999Elementary derivation of an exact formula for the best-case performance $B(n)$ of ${\tt MergeSort}$, measured by the number of comparisons of keys performed while sorting them, has been done in [8]; see Section 9 page 9 of this paper. of comparisons of keys performed by ${\tt MergeSort}$ on an $n$-element array. The first of the two, due to its structural regularity, is well worth carefully studying in its own right.

Unlike some other basic sorting algorithms101010For instance, ${\tt Heapsort}$; see [7] for a complete analysis of its worst-case behavior. that run in $O(n\lg n)$ time, ${\tt MergeSort}$ exhibits a remarkably regular111111As revealed by Theorem 5.2, page 5.2. worst-case behavior, the elegant simplicity of which has been mostly lost on its rough analyses. In particular, $W(n)$ is linear121212See Figure 4 page 4. between the points $n=2^{\lfloor\lg n\rfloor}$ and it linearly interpolates its own lower bound $n\lg n-n+1$ 131313Given by the left-hand side of the inequality (12) page 12. between these points.

What follows is a short version (SV) of a manuscript dated January 20, 2017, of the full version version [9] of this paper that has been posted at:

http://csc.csudh.edu/suchenek/Papers/Analysis_of_MergeSort.pdf

The derivation of the worst case of ${\tt MergeSort}$ presented here is roughly the same141414Except for the present proof of Lemma 2.1 which I haven’t been using in my class. as the one I have been doing in my undergraduate Analysis of Algorithms class. C shows sample class notes from one of my lectures.

2 Some Math prerequisites

A manuscript of the full version [9] of this paper contains a clever derivation of a well-known151515See [3]. closed-form formula for $\sum_{i=1}^{n}\lceil\lg i\rceil$. It proves insightful in my worst-case analysis of ${\tt MergeSort}$ as its right-hand side will occur on page 5 in the fundamental equality (5) and serve as an instrument to derive the respective exact formula for ${\tt MergeSort}$’s worst-case behavior.

Lemma 2.1**.**

For every integer $n\geq 1$,

[TABLE]

Proof in [9]. $\Box$

From this one can easily conclude that:

Corollary 2.2**.**

For every integer $n\geq 1$,

[TABLE]

3 ${\tt MergeSort}$ and its worst-case behavior $W(n)$

A call to ${\tt MergeSort}$ inherits an $n$-element array ${\tt A}$ of integers and sorts it non-decreasingly, following the steps described below.

Algorithm ${\tt MergeSort}$ 3.1**.**

To sort an $n$-element array ${\tt A}$ do:

If $n\leq 1$ then return ${\tt A}$ to the caller, 2. 2.

If $n\geq 2$ then

1. (a)

pass the first $\lfloor\frac{n}{2}\rfloor$ elements of ${\tt A}$ to a recursive call to ${\tt MergeSort}$, 2. (b)

pass the last $\lceil\frac{n}{2}\rceil$ elements of ${\tt A}$ to another recursive call to ${\tt MergeSort}$, 3. (c)

linearly merge, by means of a call to ${\tt Merge}$, the non-decreasingly sorted arrays that were returned from those calls onto one non-decreasingly sorted array ${\tt A}^{\prime}$, 4. (d)

return ${\tt A}^{\prime}$ to the caller.

A Java code of ${\tt Merge}$ is shown on the Figure 1.161616A Java code of ${\tt MergeSort}$ is shown in A Figure 6 page 6.

A typical measure of the running time of ${\tt MergeSort}$ is the number of comparisons of keys, which for brevity I call comps, that it performs while sorting array ${\tt A}$.

Definition 3.2**.**

The worst-case running time

[TABLE]

of ${\tt MergeSort}$ is defined as the maximum number of comps it performs while sorting an array of $n$ distinct171717This assumption is superfluous for the purpose of worst-case analysis as the mere presence of duplicates does not force ${\tt MergeSort}$ to perform more comps. elements.

Clearly, if $n=0$ then $W(n)=0$. From this point on, I am going to assume that $n\geq 1$.181818This assumption turns out handy while using expression $\lg n$.

Since no comps are performed outside ${\tt Merge}$, $W(n)$ can be computed as the sum of numbers of comps performed by all calls to ${\tt Merge}$ during the execution of ${\tt MergeSort}$. The following classic results will be useful in my analysis.

Theorem 3.3**.**

The maximum number of comps performed by ${\tt Merge}$ on two sorted list of total number $n$ of elements is $n-1$.

Proof (constructive, with Java code that generates worst cases shown in the B) in [9]. $\Box$

Moreover, if the difference between the lengths of merged list is not larger than 1 then no algorithm that merges sorted lists by means of comps beats ${\tt Merge}$ in the worst case, that is, has a lower than $n-1$ maximum number of comps.191919Proof in [3], Sec. 5.3.2 page 198; the worst-case optimality of ${\tt Merge}$ ($n-1$ comps) was generalized in [6] over lists of lengths $k$ and $m$, with $k\leq m$, that satisfy $3k\geq 2m-2$. This fact makes ${\tt MergeSort}$ optimal in the intersection of the class of sorting algorithms that sort by merging two sorted lists of lengths’ difference not larger than 1 202020Or, by virtue of the above-quoted result from [6], with the difference not larger than the half of the length of the shorter list plus 1. with the class of sorting algorithms that sort by comps.

4 An easy yet precise derivation of $W(n)$

${\tt MergeSort}$ is a recursive algorithm. If $n\geq 2$ then it spurs a cascade of two or more recursive calls to itself. A rudimentary analysis of the respective recursion tree $T_{n}$, shown on Figure 2, yields a neat derivation of the exact formula for the maximum number $W(n)$ of comps that ${\tt MergeSort}$ performs on an $n$-element array.

The idea behind the derivation is strikingly simple. It is based on the observation212121Which I prove in [9] as Theorem 4.6, page 14. that for every $k\in\mathbb{N}$, the maximum number $C_{k}$ of comps performed at each level222222Empty or not. $k$ of $T_{n}$ is given by this neat formula:232323It is a simplification of formulas used in derivation presented in [2] and discussed in Section 8 page 8; in particular, it does not refer to the depth $h$ of the decision tree $T_{n}$.

[TABLE]

Since

[TABLE]

the Corollary 2.2 will allow me to conclude from (3) and (4) the main result of this paper242424This is how I have been deriving it in my undergraduate Analysis of Algorithms class for some 15 years or so, now.:

[TABLE]

The missing details252525Which I did not show in my Analysis of Algorithms class. in the above sketch are in [9]. Naturally, their only purpose is to prove the equality (3) for all $k\in\mathbb{N}$, as the rest, shown in (5), easily follows from it. In particular, we get:

The Main Theorem 4.1**.**

The number $W(n)$ of comparisons of keys that ${\tt MergeSort}$ performs in the worst case while sorting an $n$-element array is

[TABLE]

Proof in [9]. $\Box$

From that we can conclude a usual rough characterization of $W(n)$:

[TABLE]

and

[TABLE]

Therefore,

[TABLE]

The occurrence of $\sum_{i=1}^{n}\lceil\lg i\rceil$ in (6) allows to conclude that $W(n)$ is exactly equal262626[3] contains no mention of that fact. to the number of comparisons of keys that the binary insertion sort, considered by H. Steinhaus in [5] and analyzed in [3], performs in the worst case. Since the binary insertion sort is known to be worst-case optimal272727With respect to the number of comparisons of keys performed. in the class of algorithms that perform incremental sorting, ${\tt MergeSort}$ is worst-case optimal in that class282828Although it is not a member of that class., too. From this and from the observation at the end of Section 3, page 3, I conclude that no algorithm that sorts by merging two sorted lists and only by means of comps is worst-case optimal in the class of algorithms that sort by means of comps as it must perform 8 comps in the worst case while sorting 5 elements292929They can be split in two: 1 plus 4, and follow the binary insertion sort, or 2 plus 3, and follow ${\tt MergeSort}$., while one can sort 5 elements by means of comps with no more than 7 comps.

5 Close smooth bounds on $W(n)$

Our formula for $W(n)$ contains a function ceiling that is harder to analyze than arithmetic functions and their inverses. In this Section, I outline a derivation of close lower and upper bounds on $W(n)$ that are expressible by simple arithmetic formulas. I show that these bounds are the closest to $W(n)$ in the class of functions of the form $n\lg n+cn+1$, where $c$ is a real constant.

The detailed derivation and missing proofs can be found in [9].

Using the function $\varepsilon$ (analyzed briefly in [3] and [7]), a form of which is shown on Figure 3, given by:

[TABLE]

one can conclude303030See [7], Thm. 12.2 p. 94 for a proof. that, for every $n>0$,

[TABLE]

which yields

[TABLE]

Property 5.1**.**

Function $\varepsilon$ given by (7) is a continuous function of $n$ on the set of reals $>0$. It assumes the minimum [math] for every $n=2^{\lfloor\lg n\rfloor}$ and the maximum

[TABLE]

for every

[TABLE]

and only such $n$. The function $\varepsilon$ restricted to integers never reaches the value $\delta$. However, $\delta$ is the supremum of $\varepsilon$ restricted to integers.

Proof in [9]. $\Box$

Characterization (9) and Property 5.1 yield close smooth bounds of $W(n)$. They are both of the form $n\lg n+cn+1$ and they sandwich tightly $W(n)$ between each other. If one sees $W(n)$ as an infinite polygon323232Which it is., its lower bound circumscribes it and its upper bound inscribes it.

Theorem 5.2**.**

$W(n)$* is a continuous concave function, linear between the points $n=2^{\lfloor\lg n\rfloor}$, that for every $n>0$ satisfies this inequality:*

[TABLE]

with the left $\leq$ becoming $=$ for every $n=2^{\lfloor\lg n\rfloor}$ and the right $\leq$ becoming $=$ for every $n=2^{\lfloor\lg n+\lg\lg e\rfloor}\ln 2$, and only for such $n$. Moreover, the graph of $W(n)$ is tangent to the graph of $n\lg n-(1-\delta)n+1$ at the points $n=2^{\lfloor\lg n+\lg\lg e\rfloor}\ln 2$, and only at such points.

Proof in [9]. $\Box$

The bounds given by (12) are really close333333The distance between them is less than $\delta n\approx 0.0860713320559342n$ for any positive integer $n$. to the exact value of $W(n)$, as it is shown on Figure 4 page 4. The exact value $n\lceil\lg n\rceil-2^{\lceil\lg n\rceil}+1$ is a continuous function (if $n$ is interpreted as a real variable) despite that it incorporates discontinuous function ceiling.

Note 5.3**.**

It seems interesting that $W(n)=n\lceil\lg n\rceil-2^{\lceil\lg n\rceil}+1$ (whether $n$ is interpreted as a real variable or an integer variable) is linear between points $n=2^{\lfloor\lg n\rfloor}$ and linearly interpolates its own lower bound $n\lg n-n+1$ between these points.

For $n$ restricted to positive integers, the inequality (12) can be slightly enhanced by replacing the $\leq$ symbol with $<$, with the following result.

Theorem 5.4**.**

$1-\delta$* is the greatest constant $c$ such that for every integer $n\geq 1$,*

[TABLE]

Proof in [9]. $\Box$

Theorem 5.4 can be reformulated as follows.

Corollary 5.5**.**

[TABLE]

Proof in [9]. $\Box$

No upper bound of $W(n)$ that has a form $n\lg n-cn+1$ can coincide with $W(n)$ at any integer $n$, as the following fact ascertains.

Corollary 5.6**.**

There is no constant $c$ such that for every integer $n\geq 1$,

[TABLE]

and for some integer $n\geq 1$,

[TABLE]

Proof in [9]. $\Box$

In particular343434Note the $\leq$ symbol in (17).,

[TABLE]

Moreover, we can conclude from Theorem 5.4 the following fact.

Corollary 5.7**.**

$1-\delta$* is the greatest constant $c$ such that for every integer $n\geq 1$,*

[TABLE]

Proof in [9]. $\Box$

Since for any integer $n\geq 1$, $W(n)$ is integer, the lower bound given by (12) yields

[TABLE]

By virtue of Corollary 5.7, for some integers $n\geq 1$,353535For instance, for $n=11$.

[TABLE]

Although the bounds given by (19) 363636Almost the same bounds were given in [2]; see Section 8 for more details on this. are tighter than those given by (12), they nevertheless involve the discontinuous ceiling function, so that they may not be as easy to visualize or analyze as some differentiable functions, thus losing their advantage over the precise formula $W(n)=n\lceil\lg n\rceil-2^{\lceil\lg n\rceil}+1$. Therefore, the bounds given by (12) appear to have an analytic advantage over those given by (19).

6 Other properties of the recursion tree $T_{n}$

This sections contains some well-known auxiliary facts that I didn’t need for the derivation of the exact formula for $W(n)$ but am going to derive from the Main Lemma 4.1 of [9] for the sake of a thoroughness of my analysis of the decision tree $T_{n}$.

Theorem 6.1**.**

The depth $h$ of the recursion tree $T_{n}$ is

[TABLE]

Proof in [9]. $\Box$

Note 6.2**.**

Theorem 6.1 allows for quick derivation of fairly close upper bound on the number of comps performed by ${\tt MergeSort}$ on an $n$-element array. Since at each level of $T_{n}$ less than $n$ comparisons are performed by ${\tt Merge}$ and at level $h$ no comps are performed, and there are $h$ $=$ $\lceil\lg n\rceil$ levels below level $h$, the total number of comps is not larger than

[TABLE]

A cut of a tree $T_{n}$ is a set $\Gamma$ of nodes of $T$ such that every branch373737A maximal path. in $T_{n}$ has exactly one element in $\Gamma$.

Theorem 6.3**.**

The sum of values shown at the elements of any cut of $T_{n}$ is $n$.

Proof in [9]. $\Box$

Theorem 6.4**.**

The number of leaves in the recursion tree $T_{n}$ is $n$.

Proof in [9]. $\Box$

The following corollary provides some statistics about recursive calls to ${\tt MergeSort}$.

Corollary 6.5**.**

For every integer $n>0$,

1. (i)

$T_{n}$* has $2n-1$ nodes.* 2. (ii)

The number or recursive calls spurred by ${\tt MergeSort}$ on any $n$-element array is $2(n-1)$. 3. (iii)

The sum $S_{n}$ of all values shown in the recursion tree $T_{n}$ on Figure 2 is equal to:

[TABLE] 4. (iv)

The average size $A_{n}$ of array passed to any recursive call to ${\tt MergeSort}$ while sorting an $n$-element array is:

[TABLE]

Proof in [9]. $\Box$

Here is a very insightful property. It states that ${\tt MergeSort}$ is splitting its input array fairly evenly383838The sizes of the sub-arrays passed to recursive calls at any non-empty level $k$ of the decision tree $T_{n}$ above the last non-empty level $h$ are the same as the sizes of the elements of the maximally even partition of an $n$-element set onto $2^{k}$ subsets. so that at any level of the recursive tree, the difference between the lengths of the longest sub-array and the shortest sub-array is $\leq 1.$ This fact is the root cause of good worst-case performance of ${\tt MergeSort}$.

Property 6.6**.**

The difference between values shown by any two nodes in the same level of of the recursion tree $T_{n}$ is $\leq 1$.

Proof in [9]. $\Box$

Property 6.6 has this important consequence that ${\tt Merge}$ is, by virtue of the observation on page 3 after the Theorem 3.3 page 3.3, worst-case comparison-optimal while merging any two sub-arrays of the same level of the recursion tree. Thus the worst-case of ${\tt MergeSort}$ cannot be improved just by replacing ${\tt Merge}$ with some tricky merging ${\tt X}$ as long as ${\tt X}$ merges by means of comparisons of keys.

Corollary 6.7**.**

Replacing Merge with any other method that merges sorted arrays by means of comps will not improve the worst-case performance of ${\tt MergeSort}$ measured with the number of comps while sorting an array.

Proof.

Proof follows from the above observation. ∎

Since a parent must show a larger value than any of its children, the Property 6.6 has also the following consequence.

Corollary 6.8**.**

The leaves in the recursion tree $T_{n}$ can only reside at the last two non-empty levels of $T_{n}$.

Proof.

Proof follows from the Property 6.6 as the above observation indicates. ∎

As a result, one can conclude393939Cf. [3], Sec. 5.3.1 Ex. 20 page 195. that the recursion tree $T_{n}$ has the miminum internal and external path lengths among all binary trees on $2n-1$ nodes.

Since all nodes at the level $h$ of the recursion tree $T_{n}$ are leaves and show value $1$, no node at level $h-1$ can show a value $>2$. Indeed, level $h-1$ may only contain leaves, that show value $1$, and parents of nodes of level $h$ that show value $1+1=2$. This observation and the previous result allow for easy characterization of contents of the last two non-empty levels of tree $T_{n}$.

Corollary 6.9**.**

For every $n\geq 2$:

1. (i)

there are $2^{h}-n$ leaves, all showing value $1$, at the level $h-1$, 2. (ii)

there are $n-2^{h-1}$ non-leaves, all showing value $2$, at the level $h-1$, and 3. (iii)

there are $2n-2^{h}$ 404040This value shows in the lower right corner of Figure 2 page 2 of a sketch of the recursion tree $T_{n}$; it was not need needed for the derivation of the main result (6) page 6, included for the sake of completeness only. nodes, all leaves showing value $1$, at the level $h$

of the recursion tree $T_{n}$, where $h$ is the depth414141The level number of the last non-empty level of $T_{n}$. of $T_{n}$.

Proof in [9]. $\Box$

7 A derivation of $W(n)$ without references to the recursion tree

In order to formally prove Theorem 4.1 without any reference to the recursion tree, I use here the well-known424242For instance, derived in [1] and [2]. recurrence relation

[TABLE]

[TABLE]

that easily follows from the description (Algorithm 3.1 page 3.1) of ${\tt MergeSort}$, steps 2a, 2c and Theorem 3.3. I am going to prove, by direct inspection, that the function $W(n)$ defined by (6) satisfies equations (25) and (26).

The details of the proof are in [9].

8 Other work

Although some variants of parts of the formula (6) appear to have been known for quite some time now, even otherwise precise texts offer derivations that leave room for improvement. For instance, the recurrence relation for ${\tt MergeSort}$ analyzed in [4] asserts that the least number of comparisons of keys performed outside the recursive calls, if any, that suffice to sort an array of size $n$ is $n$ rather than $n-1$. This seemingly inconsequential variation results in a solution $W(n)=\sum_{i=1}^{n-1}(\lfloor\lg i\rfloor+2)$ 434343I saw $W(n)=\sum_{i=1}^{n-1}\lfloor\lg i\rfloor$ on slides that accompany [4]. on page 2, Exercise 1.4, rather than the correct formula (5) $W(n)=\sum_{i=1}^{n}\lceil\lg i\rceil$ derived in this paper. (Also, the relevant derivations presented in [4], although quite clever, are not nearly as precise and elementary as those presented in this paper.) As a result, the fact that ${\tt MergeSort}$ performs exactly the same number of comparisons of keys as does another classic, binary insertion sort, considered by H. Steinhaus and analyzed in [3], remains unnoticed.

Pages 176 – 177 of [2] contain an early sketch of proof of

[TABLE]

where $h$ is the depth of the recursion tree $T_{n}$, with remarkably close444444Although not 100 percent correct. bounds given by (28) page 28. It is similar454545The idea behind the sketch of the derivation in [2] was based on an observation that

$W(n)=\sum_{i=0}^{h-2}(n-2^{i})+\frac{n-B}{2},$

where $B$ was the number of leaves at the level $h-1$ of the decision tree $T_{n}$; it was sketchily derived from the recursion tree shown on Figure 5 and properties stated in the Corollary 6.9 page 6.9 (with only a sketch of proof in [2]) not needed for the derivation presented in Section 4. to a simpler derivation based on the equality (3), presented in this paper in Section 4 and outlined in (5) page 5 (except for the $\sum_{i=1}^{n}\lceil\lg i\rceil$ part), which it predates by several years.

The [2]’s version of the decision tree $T_{n}$ (Figure 4.14 page 177 of [2], shown here on Figure 5) was a re-use of a decision tree for the special case of $n=2^{\lfloor\lg n\rfloor}$, with an ambiguous, if at all correct464646It may be interpreted as to imply that for any level $k$, all the left-child sizes at level $k$ are the same and all the right-child sizes at level $k$ are the same, neither of which is a valid statement., comment in the caption that “[w]henever a node size parameter is odd, the left child size parameter is rounded up474747Should be: down, according to (25) page 25. and the right child size is rounded down484848Should be: up, according to (25) page 25..” The proof of the fact, needed for the derivation in [2], that $T_{n}$ had no leaves outside its last two levels (Corollary 6.8 page 6.8, not needed for the derivation presented in Section 4) was waved with a claim “[w]e can494949This I do not doubt. determine that […]”

Although $h$ was claimed in [2] to be equal to $\lceil\lg(n+1)\rceil$ 505050Which claim must have produced an incorrect formula $n\lceil\lg(n+1)\rceil-2^{\lceil\lg(n+1)\rceil}+1$ for $W(n)$ and precluded concluding the neat characterization $W(n)=\sum_{i=1}^{n}\lceil\lg i\rceil$. (and not to the correct $\lceil\lg n\rceil$ given by the equality (21) page 21, a fact not needed for the derivation presented in Section 4), somehow the mostly correct conclusion515151Almost identical with (19) page 19, except for the constant $0.914$. was inferred from it, however, with no details offered - except for a mention that a function $\alpha$ that satisfies $h=\lg n+\lg\alpha$, similar to function $\varepsilon$ shown on Figure 3 page 3, was used. It stated that (Theorem 4.6, page 177, in [2]):

[TABLE]

It follows from (20) page 20 that the constant $0.914$ that appears in (28) is incorrect. It was a rounding error525252Of $1-\delta$, where $\delta$ is given by (10) page 10., I suppose, that produced a false upper bound535353For instance, if $n=11$ then ${\tt MergeSort}$ performs 29 comparisons of keys while the value of the upper bound $\lceil n\lg n-.914n\rceil$ given in [2], Theorem 4.6. p. 177, is 28; this is a significant error as 28 or less comps while sorting any 11-element array beats the binary insertion sort that requires $\sum_{i=1}^{11}\lceil\lg i\rceil=29$ comps in the worst case..

9 Best-case analysis of ${\tt MergeSort}$

It turns out that derivation of minimum number $B(n)$ of comps performed by ${\tt MergeSort}$ on an $n$-element array is a bit more tricky. A formula

[TABLE]

where

[TABLE]

has been derived and thoroughly analyzed in [8]. It has been also demonstrated in [8] that there is no closed-form formula for $B(n)$.

Incidentally, as it was pointed out in [8] $,B(n)$ is equal to the sum $A(n,2)$ of bits in binary representations of all integers $<n$.

Appendix A A Java code of ${\tt MergeSort}$

Figure 6 shows a Java code of ${\tt MergeSort}$.

Appendix B Generating worst-case arrays for ${\tt MergeSort}$

Figure 7 shows a self-explanatory Java code of recursive method $\tt unSort$ that given a sorted array ${\tt A}$ reshuffles it, in a way resembling $\tt InsertionSort$545454Although not with $\tt InsertionSort$’s sluggishness; the number of moves of keys it performs is only slightly more than the minimum number (29) of comps performed by ${\tt MergeSort}$ on any $n$-element array., onto a worst-case array for ${\tt MergeSort}$.

For instance, it produced this array of integers between 1 and 500:

1, 500, 2, 3, 4, 7, 5, 6, 8, 15, 9, 10, 11, 14, 12, 13, 16, 31, 17, 18, 19, 22, 20, 21, 23, 30, 24, 25, 26, 29, 27, 28, 32, 62, 33, 34, 35, 38, 36, 37, 39, 46, 40, 41, 42, 45, 43, 44, 47, 61, 48, 49, 50, 53, 51, 52, 54, 60, 55, 56, 57, 59, 58, 63, 124, 64, 65, 66, 69, 67, 68, 70, 77, 71, 72, 73, 76, 74, 75, 78, 92, 79, 80, 81, 84, 82, 83, 85, 91, 86, 87, 88, 90, 89, 93, 123, 94, 95, 96, 99, 97, 98, 100, 107, 101, 102, 103, 106, 104, 105, 108, 122, 109, 110, 111, 114, 112, 113, 115, 121, 116, 117, 118, 120, 119, 125, 249, 126, 127, 128, 131, 129, 130, 132, 139, 133, 134, 135, 138, 136, 137, 140, 155, 141, 142, 143, 146, 144, 145, 147, 154, 148, 149, 150, 153, 151, 152, 156, 186, 157, 158, 159, 162, 160, 161, 163, 170, 164, 165, 166, 169, 167, 168, 171, 185, 172, 173, 174, 177, 175, 176, 178, 184, 179, 180, 181, 183, 182, 187, 248, 188, 189, 190, 193, 191, 192, 194, 201, 195, 196, 197, 200, 198, 199, 202, 216, 203, 204, 205, 208, 206, 207, 209, 215, 210, 211, 212, 214, 213, 217, 247, 218, 219, 220, 223, 221, 222, 224, 231, 225, 226, 227, 230, 228, 229, 232, 246, 233, 234, 235, 238, 236, 237, 239, 245, 240, 241, 242, 244, 243, 250, 499, 251, 252, 253, 256, 254, 255, 257, 264, 258, 259, 260, 263, 261, 262, 265, 280, 266, 267, 268, 271, 269, 270, 272, 279, 273, 274, 275, 278, 276, 277, 281, 311, 282, 283, 284, 287, 285, 286, 288, 295, 289, 290, 291, 294, 292, 293, 296, 310, 297, 298, 299, 302, 300, 301, 303, 309, 304, 305, 306, 308, 307, 312, 373, 313, 314, 315, 318, 316, 317, 319, 326, 320, 321, 322, 325, 323, 324, 327, 341, 328, 329, 330, 333, 331, 332, 334, 340, 335, 336, 337, 339, 338, 342, 372, 343, 344, 345, 348, 346, 347, 349, 356, 350, 351, 352, 355, 353, 354, 357, 371, 358, 359, 360, 363, 361, 362, 364, 370, 365, 366, 367, 369, 368, 374, 498, 375, 376, 377, 380, 378, 379, 381, 388, 382, 383, 384, 387, 385, 386, 389, 404, 390, 391, 392, 395, 393, 394, 396, 403, 397, 398, 399, 402, 400, 401, 405, 435, 406, 407, 408, 411, 409, 410, 412, 419, 413, 414, 415, 418, 416, 417, 420, 434, 421, 422, 423, 426, 424, 425, 427, 433, 428, 429, 430, 432, 431, 436, 497, 437, 438, 439, 442, 440, 441, 443, 450, 444, 445, 446, 449, 447, 448, 451, 465, 452, 453, 454, 457, 455, 456, 458, 464, 459, 460, 461, 463, 462, 466, 496, 467, 468, 469, 472, 470, 471, 473, 480, 474, 475, 476, 479, 477, 478, 481, 495, 482, 483, 484, 487, 485, 486, 488, 494, 489, 490, 491, 493, 492.

It took my ${\tt MergeSort}$ 3,989 comps to sort it. Of course,

[TABLE]

Appendix C Notes from my Analysis of Algorithms lecture

Below are some of the class digital notes I wrote while lecturing Analysis of Algorithms in Spring 2012, with some comments added after class. Figure 4.14 (decision tree) is from the course textbook [2], page 177, showing a decision tree for ${\tt MergeSort}$. Note: This figure is copyrighted by Addison Wesley Longman (2000). I used it transformatively in my class for nonprofit education, criticism, and comment purposes only, and not for any other purpose, as prescribed by U.S. Code Tittle 17 Chapter 1 para 107 that established the “fair use” exception of copyrighted material.

Below is the improved recursion tree (of the Figure 4.14 page page 177 of [2]) that I used in class in Spring 2012.

In Spring 2010 and before, I was deriving the equality (3) on page 3 during my lectures directly from the recurrence relation (25), (26) on page 25.