归并排序 - Algorithms, Part I, week 3 MERGESORTS

前言

本周讲解两个50多年前发明，但今天仍然很重要的经典算法 (归并排序和快速排序) 之一 -- 归并排序，几乎每一个软件系统中均可以找到其中一个或两个的实现，并研究这些经典方法的新变革。咱们的涉及范围从数学模型中解释为何这些方法有效到使这些算法适应现代系统的实际应用的细节。

Mergesort。咱们研究 mergesort 算法，并证实它保证对 n 项的任何数组进行排序，最多只能进行 nlgn 次的比较。咱们还考虑一个非递归的自下而上版本。咱们证实，在最坏的状况下，任何基于比较的排序算法必须至少进行 ~nlgn 的比较。咱们讨论对咱们正在排序的对象使用不一样的排序以及相关的稳定性概念。

上一篇：基本数据类型
下一篇：快速排序

这章咱们讨论归并排序，这是计算基础中的两个重要排序算法之一
咱们已经对一些算法有了科学全面的认知，这些算法被大量运用在系统排序和应用内排序超过50多年，咱们以后所要看到的快速排序更是被在科学和工程中被誉为20世纪10大算法之一

归并排序

概貌

因此归并排序究竟是什么样的?

基本计划流程：

• 将阵列分红两半
• 递归排序每一半
• 合并两半

它的思想其实很简单, 只要把数组一分为二, 而后再不断将小数组递归地一分为二下去, 通过一些排序再将它们合并起来, 这就是归并排序的大体思想, 这是人们在计算机上实现的最先的算法之一.
(EDVAC 计算机是最先的通用型计算机之一, 冯诺依曼认为在他的 EDVAC 中须要一种排序算法, 因而他提出了归并排序, 所以他被公认为是归并排序之父)

归并排序的核心就是“并”。因此要理解如何归并，先考虑一种抽象的“原位归并”。

原位归并

也叫 Top-down mergesort. 下边还有归并的另外一种实现，叫 Bottom-up mergesort.

目标 给定一个数组，它的前一半(a[lo]-[mid]) 和 后一半([mid + 1]-[hi]) 已经是排好序的，咱们所要作的就是将这两个子数组合并成一个大的排好序的数组

看一个抽象原位归并演示

1.在排序以前咱们须要一个辅助数组，用于记录数据，这是实现归并的最简单的方式

2.首先将原数组中全部东西拷贝进辅助数组，以后咱们就要以排好的顺序将它们拷贝回原数组
这时咱们须要三个下标：i 用于指向左边子数组；j 指向右边子数组；k指向原数组即排好序的数组。

3.首先取 i 和 j 所指数字中取其中小的放入原数组k的位置，当一个被拿走以后，拿走位置的指针 (此次是 j) 和 k 递增

4.一样取 i 和 j 中小的那个移向 k 的位置，再同时增长移动位置的指针(此次仍是 j 和 k)

以此类推。完整演示地址：在此
这就是一种归并方式： 用了一个辅助数组，将它们移出来又排好序放回去。
这就是归并部分的代码，彻底依着以前的演示

Java 实现

public class Merge {

    private static void merge(Comparable[] a, Comparable[] aux, int lo, int mid, int hi) {
/**
 * assertion功能: 方便咱们找出漏洞而且肯定算法的正确
 * 想肯定a[lo] 到 a[mid] 和 a[mid+1] 到 a[hi] 是否已经是排好序的
 */
        assert isSorted(a, lo, mid);
        assert isSorted(a, mid + 1, hi);

        //拷贝全部东西进辅助数组
        for (int k = lo; k <= hi; k++)
            aux[k] = a[k];
        /**
         * 完成归并
         * 初始化 i 在左半边的最左端
         * j 在右半边最左端
         * 指针 k 从 lo 开始
         * 比较辅助数组中 i 和 j 谁更小，并将小的那个的值移向 k
         **/
        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++) {
            //若是 i 走到边界了，就只将 j 的值都移上去
            if (i > mid) a[k] = aux[j++];
            //若是 j 走到边界了，就只将 i 的值都移上去
            else if (j > hi) a[k] = aux[i++];
            else if (less(aux[j], aux[i])) a[k] = aux[j++];
            else a[k] = aux[i++];
        }
        //最后再检查最终合并后的时候排好序
        assert isSorted(a, lo, hi);
    }

    // 递归的 sort 方法
    private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi) {
        if (hi <= lo) return;
        int mid = lo + (hi - lo) / 2;
        sort(a, aux, lo, mid);
        sort(a, aux, mid + 1, hi);
        merge(a, aux, lo, mid, hi);
    }

    // 对外提供接口中 sort 函数
    public static void sort(Comparable[] a) {
        //建立辅助数组
        Comparable[] aux = new Comparable[a.length];
        sort(a, aux, 0, a.length - 1);
    }
}

完整“原位”归并代码：在此

在这个简单的实现中传入了 Comparable 类型的原数组 a[] 和 辅助数组 aux[], 还有三个参数 lo, mid, and hi.
lo指向的是两个将要合并的子数组的头部 mid指向前一个子数组的末端 因此咱们的前提是lo到mid时排好的 从mid+1到hi也是排好的

有了归并，排序中递归的就简单多了。
sort() 在递归调用前先检查下标，而后像二分查找那样计算中点值。sort前半部分，再sort后半部分，而后merge
对外提供接口中 sort 函数只接收一个参数，建立辅助数组的任务就交给这个 sort()

这里关键在于不要将辅助数组在递归的 sort() 中建立, 由于那会多出许多额外的小数组的花费, 若是一个归并排序效率很低一般都是由这引发 这是一个很直接的实现方式。也是依据了咱们看到屡次的一个思想--分治法：即解决问题时将其一分为二，分别解决两个小问题，再将它们合并起来

Assertion

通常来讲Java程序员，认为加入这些 assert 是有益的：

• 帮助咱们发现漏洞
• 同时也提示了之间的代码的功能

这个归并代码就是很好的例子，如此以代码的形式加入 assert 语句代表了接下来你想作什么，在代码最后加上 assert 语句代表了你作了什么。
你不只肯定了代码的正确，也告诉阅读代码的人你所干的事情。

Java 中 asset 语句接受一个 boolean 值。isSorted 函数前面已经写过了(请回复 -- 基本排序)，若是排好序返回 true，反之返回 false. assert 在验证到没正确排序时会抛出异常.

assert 能够在运行时禁用.
这颇有用由于你能够把 asset 语句一直放在代码中, 编程时供本身所需, 禁用后在最终上线程序中不会有额外代码。所以 assertion 默认是禁用的。出错的时候人们还能够启用assertion而后找到错误所在。

java -ea MyProgram //启用 assertions
java -da MyProgram //禁用 assertions(默认)

因此平时最好像以前的例子那样加入assert语句，而且不让他们出如今产品代码中，并且不要用额外的参数来作检查。

轨迹图

这幅图显示了每次调用 merge 时的操做。
咱们将一个大的问题对半分，再将其中的一半对半分，对于那些分到不能再分单个元素，咱们作的就是两两间的比较。
两个单元素数组的合并实际就是对这两个数进行了排序，即 M-E 变为 E-M，一样再对后一组的两个数归并排序，即 R-G 变为 G-R，再将两单元数组归并成四单元数组,即 E-M 和 G-R 归并为 E-G-M-R。
一样再对后两对归并(E-S,O-R)，这样就获得两个四单元数组(E-G-M-R 和 E-O-R-S), 再归并获得八单元组(E-E-G-M-O-R-R-S).
右边的一半也是同理,最终两个八单元合并,获得最终的结果.
观察这个轨迹图对于学习递归算法是颇有帮助的.

Q. 如下哪一种子数组长度会在对长度为 12 的数组进行归并排序时出现？
A. { 1, 2, 3, 4, 6, 8, 12 }
B. { 1, 2, 3, 6, 12 }
C. { 1, 2, 4, 8, 12 }
D. { 1, 3, 6, 9, 12 }

算法分析

实证分析

运行时间估计：

能够将归并排序用在大量数据中，这是个很是高效的算法。如表中所示，若是要对大量数据进行插入排序，假设有十亿个元素，用家里的电脑要花几个世纪。就算目前的超级计算机也要花费一个星期或更多。
可是拥有一个高效的算法，你对十亿个元素排序，家用电脑也只需半小时，超级计算机更是一瞬间便可完成，一些小型的问题PC也可迅速完成。所以要么你有不少钱和时间，要么你要有一个好的算法。这是咱们在这门课中的核心主题，即一个好的算法远比差的算法所花时间和金钱高效得多。

效率分析

这些数学的东西才能展现出分治法的强大 展现出归并算法如何在 nlogn 时间中解决了选择排序和插入排序须要 N^2 时间才能解决的问题。

比较次数

命题：对于大小为 n 的数组，归并排序须要最多 nlogn 次比较 和 6nlogn 次数组访问

证实：证实这个结论就是须要从以前的代码中得出递推关系式, 这即是代码所反映的数学问题。
若是对 n 个元素排序，用关于 n 的函数 C(n) 来表示须要比较的次数

归并时左半部分和右半部分元素个数就用 n/2 上取整 和 n/2 下取整来表示, 这就是两个子数组的大小. 由于咱们递归地调用函数, 因此括号里就是每次递归时分割后子数组的大小, 因而整个一项就是子数组中这些数排序须要的比较次数.
对于左半部分比较次数, 就是关于 n/2 上取整的函数 C(n/2); 对于右边同理. 二合并时咱们须要至多 n-1 次比较
由于若是左右没有一边提早排完,就须要 n-1 次比较. 这也只是 n 大于等于 1 的状况. 若是只有一个单元, 是不须要任何比较的, C(1) = 0.
因而这个从代码中考查得来的公式就能精确计算所须要的比较次数上界.

关于这些求这些复杂公式的通项，具体能够回顾离散数学

咱们能够看一下当 n 为 2 的幂时的状况(但结论是对 n 为任意数都成立的, 咱们能够经过数学概括法来证实)

D(n) = 2 D(n / 2) + n, for n > 1, with D(1) = 0.

和前面类似的递推关系式, 咱们将展现一种证实方法.

分治递归
都假设 n 为 2 的幂次，那 n^2 除以二也是 2 的幂, 这是显然的。
命题： 当 n 是 2 的幂次时的状况, 即，若是 D(n) 知足 D(n) = 2 D(n / 2) + n，当 n > 1, 当且仅当 n=1 时 D(1)=0，通项 D(n) = nlogn.

图示法

!

能够看到每次归并，对于一整层的比较次数都是 N 次，因此共有多少层? 将 N 不断除 2 一直到等于2，一共有 logN 层(以2为底), 因此总共有 NlogN 次比较。归并的所有开销就在于比较次数, 也就是 NlogN. 这就是用图示法来计算递推式.

数组访问

命题：对于大小为 n 的数组，归并排序使用 ≤ 6nlgn 个数组访问来排序数组

对于数组访问次数的计算类似, 只是在归并的时候后面加上的是 6n

• 将 a 数组复制到 aux 数组：数组访问 2 n 次; 若是 less() 方法运行了 2 n 次，若是每次 less() 都返回 true, 那么又须要 2 * n 次来将辅助数组中的值储存回原数组，因此总共 6n 次

A(n) ≤ A(⎡n / 2⎤) + A(⎣n / 2⎦) + 6n for n > 1, with A(1) = 0.

Key point. 任何具备如下结构的算法都须要 nlogn 时间

内存占用

命题: Mergesort 使用与 n 成比例的额外空间
归并排序的一大特色就是它须要随 n 增大而增大的额外空间, 由于有那个额外的辅助数组.

证实： 对于最后一次合并，数组aux []的长度必须为n。
咱们将两个子数组看似原地排序, 但实际上并非真正的“原地”, 由于咱们用到了额外的数组。

若是使用 ≤ clogn 的额外内存，则排序算法就是原地排序，例如：
插入排序，选择排序，和 希尔排序

这些排序算法不须要额外空间，但归并排序你只能放一半，另外一半要留给辅助数组。

算法改进

若是你以为如今所学的太简单，而在思考一种真正的原地归，其实人们已经有一些方法来完成，但只是理论上可行，实践太过繁琐，而没有能被运用，也许存有简单的方式实现原地归并，这就有待咱们去发现。
不过如今有些切实可行的改进，能让归并算法变得高效，这就来看一下由于这种技巧也能用于其余算法：

• 使用数组长度为 ~ ½ n 的额外数组 aux[] 代替长度为 n 的额外数组
  首先对特别小的数组运用归并排序太过复杂，好比大小为二三四的数组，归并它们时调用函数也会有开销，更糟糕的是不断地递归会分出不少不少小数组，因此第一个改进就是进行切分，对小于某个数值的小数组采用插入排序，这样能更加有效。 因此加入这一行能让归并更快，快大约20%。

private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi)
{
 //Cutoff to insertion sort for ≈ 7 items.
 if (hi <= lo + CUTOFF - 1)
 {
     Insertion.sort(a, lo, hi);
     return;
 }
     int mid = lo + (hi - lo) / 2;
     sort (a, aux, lo, mid);
     sort (a, aux, mid+1, hi);
     merge(a, aux, lo, mid, hi);
}

• 第二个对算法的改进能够是当(merge以前)两个子数组间若是已经是有序，即可跳过此轮归并。判断这种状况只需判断前一半最大的数是否小于后一半最小的数，仅此而已，So easy. 所以咱们就在归并前加一句判断，检测子数组是否有序，这样只要在每一个归并前检测一下，也只需线性复杂度的时间便可完成，这至少在一些状况下是有帮助的

private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi)
{
     if (hi <= lo) return;
     int mid = lo + (hi - lo) / 2;
     sort (a, aux, lo, mid);
     sort (a, aux, mid+1, hi);
     //are subarrays sorted?
     if (!less(a[mid+1], a[mid])) return;
     merge(a, aux, lo, mid, hi);
}

另外一个能够改进的比较费解, 因此只推荐于专业人士.改进在于节省下拷贝到辅助数组的时间(不是空间)。这种改进至关于每一轮递归时转换一下原数组和辅助数组的角色，不过仍是需那个辅助数组。代码以下：

将sort结果放入另外一数组，将merge结果合并回原数组，因此递归函数同时也完成了交换两个数组角色的任务，这就意味着不用花时间拷贝元素进辅助数组，就节省下了一点时间。

完整代码：在此

稳定性

咱们上诉实现的归并排序是稳定的吗？是稳定的。
稳定性又是指什么。请查看前一章：基本排序

归并排序是稳定的，只要 merge() 操做是稳定的，它就是稳定的。

public class Merge
{
 private static void merge(...)
 { /* as before */ }

 private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi)
 {
     if (hi <= lo) return;
     int mid = lo + (hi - lo) / 2;
     sort(a, aux, lo, mid);
     sort(a, aux, mid+1, hi);
     //这个操做是稳定的
     merge(a, aux, lo, mid, hi);
 }
 public static void sort(Comparable[] a)
 { /* as before */ }
}

这些操做是否稳定取决于咱们的代码怎么写。在咱们的代码中，

private static void merge(...)
{
 for (int k = lo; k <= hi; k++)
 aux[k] = a[k];
 int i = lo, j = mid+1;
 for (int k = lo; k <= hi; k++)
 {
     if (i > mid) a[k] = aux[j++];
     else if (j > hi) a[k] = aux[i++];
     else if (less(aux[j], aux[i])) a[k] = aux[j++];
     // 若是两个键是相等(或左边子数组的值小),将辅助数组左边的值放到原数组中
     else a[k] = aux[i++];
 }
}

若是两个键是相等的，它取来自左边子数组的值，那么这意味着若是有两组相等的键，它将老是保留它们的相对顺序，先左再右，这就足够表示归并操做是稳定的了，所以归并排序是稳定的。稳定性是排序算法中一个重要的性质。归并算法不只高效并且也是稳定的。

bottom-up 归并排序

这是一种简单，没有递归的，归并排序的实现方法

归并规则

接下来，咱们将看从下往上方式的归并排序。
归并排序做为递归程序是简单易理解的。虽然这个从下往上的方式不是递归，但也比较容易理解。
其基本方法为：

• 把开始未排序的每个元素视为已排序的序列，该序列长度为 1
• 接下来此方法将遍历并合并 1 对长度为 1 的子序列，成为一组长度为二的子序列
• 而后对长度为 2 的子序列进行合并再排序，这样咱们就有一组长度为 4 的已排序的子序列
• 而后合并长度为 8 以此类推

• 从这个例子中咱们能够看出，从长度为 1 的子序列开始，合并排序成长度为 2 的子序列 E-M，而后不断重复这一过程，直到咱们从 16 个长度为 1 的子序列变为两组长度为八的子序列
• 在第二轮中，咱们将 E-M 与另外一组 G-R 合并排序为E-G-M-R，以及 E-S 与 O-R 合并为 E-O-R-S，以此类推，咱们有四组长度为四的子序列
• 第三轮咱们将每两组合并，获得两组长度为八的子序列，最后一轮的到一个彻底排序的序列。

这样作的好处是这一操做遍历整个序列而且不须要递归。

Java 实现

public class MergeBU
{
 private static void merge(...)
 { /* as before */ }

 public static void sort(Comparable[] a)
 {
     int n = a.length;
     Comparable[] aux = new Comparable[n];
     for (int sz = 1; sz < n; sz = sz+sz)
         for (int lo = 0; lo < n-sz; lo += sz+sz)
             merge(a, aux, lo, lo+sz-1, Math.min(lo+sz+sz-1, n-1));
     }
}

完整代码：在此

从以上代码能够看出它很是容易编写，

• 采用一样的合并代码并运用嵌套循环(两个 for 循环)，sz 子序列的大小，第一层循环是 logn 时间复杂度，由于每次咱们合并序列为两倍长，即 sz = sz+sz，直到长度为 n。
• 而后咱们从 low 到 low+size-1 排序

这就是一个彻底达到业界标准的排序代码，相对普通归并排序，它的惟一负面影响在于须要额外存储空间，大小与序列长度有关。
除了这点外这是一个很好的归并排序方法。
以上是从下往上的归并排序。不管大小，从下往上的归并排序 时间复杂度为 logN。而每一轮须要进行N次比较，所以总复杂度为 NlogN

排序复杂度

学习归并排序能很好的来帮助理解排序问题自身存在的困难性，如今把这个困难度称为复杂度，接下来咱们将会看关于复杂度的问题。

计算复杂性

计算复杂性: 研究解决特定问题 X 的(全部)算法效率的框架.

而为了使其易于理解，咱们须要创建所谓的计算模型，即
计算模型： 算法容许执行的操做

对于那种直截了当的排序，咱们要作的是创建一个成本模型来计算比较次数。
成本模型： 操做计数。

如今，在问题复杂度的框架内咱们只有两样东西：
上限： 算法所用开销/成本的保证，它是由一些(!!)为了解决问题而设计的算法提供。这个上限就表示解决这个问题有多难，咱们有个算法能够解决它，而且这是最简单的。
下限：下限，这是对全部算法的成本/开销保证的限制。 没有算法的下限比这个下线作得更好了。
而后咱们寻求所谓的最优的算法，就是解决问题“最优的”算法。
最优算法：待解问题的最佳成本保证的算法。也能够说是算法的上限和下限是几乎相同的(upper bound ~ lower bound),这是解决任何问题的最理想目标

所以，对于排序，让咱们看看这各部分分别是什么。
假设咱们访问数据的惟一方式是经过比较操做，咱们全部能使用的只有比较操做，那么一下就是用于分析排序复杂度的框架：

举例：排序问题

计算复杂性(框架)

• 计算模型 model of computation：comparison tree (旧版本的讲义decision tree)

  • comparison tree 意味着只能在进行比较的时候访问数组(e.g., Java Comparable framework)

• 成本模型 cost model：比较的次数

  • 用 #compares 表示

• 上界upper bound：~ n lg n from mergesort.

  • 归并排序提供了一个上界，它是一个保证排序完成的时间与 nlogn 成正比的算法.
• 下界lower bound：?
• 最优算法optimal algorithm：?

如下是证实排序下界的基本思想

比较树

比方说，咱们有3个不一样的项，a, b 和 c。不论使用什么算法咱们首先要作的是比较三项中的两项。

分解
好比说，这里是a 和 b。比较以后，有两种状况 b < c / a < c, 也就是说，它们是有区别的, 在比较中间会有一些代码，但无论怎样接下来里有不一样的比较。

在这种状况下，若是你从树的顶部到尾部使用至多三次比较你就能够肯定三个不一样元素的顺序。
用下限的观点归纳就是你须要找到一个最小的比较次数来肯定N个元素的顺序。

如今，树的高度，树的高度，正如我刚刚提到的，是最差状况下比较的次数。
在全部排序中即便是考虑最差状况下的树，不管输入是什么，这棵树告诉咱们一个边界，以及算法的比较次数。

在每个可能的顺序中都至少有一个顺序，若是有一个顺序没有出如今针对特定算法的树中，那么这个算法就不能排序，不能告诉你两种不一样顺序中间的差异。

做为命题的下界，使用比较树来证实任何基于排序算法的比较在最差状况下不得不使用至少 log2(N) 因子的比较次数

而且，经过斯特林近似公式，咱们知道 lg(N!) 与 Nlg(N) 成正比。

基于比较的排序算法下界

命题：任何基于比较的排序算法,在最坏的状况下, 必须至少作出 lg（n!）~nlgn 次比较。
证实：

• 假设数组由 n 个不一样的值 a1 到 an 组成
• 由比较树的高度h决定最坏状况下排序须要比较的次数
• 高度为 h 的二叉树具备 ≤2^h 的叶子
• N! 个不一样的顺序 ⇒ n! 个可到达的叶子

h 是最会状况下，也就是拥有最多叶子的状况下的高度

• 2^h大于等于叶子节点的数量
• 叶子节点的数量大于等于N！

这推导出：树的高度大于等于log2(N!)，根据斯特林公式，那是正比于 NlogN

这就是排序算法复杂度的下限。那么上限的话，根据上边排序问题的计算复杂性(框架)，已经知道上限是 NlogN, 那意味着归并排序就是一个最优算法（上限 = 下线）

算法设计的首要目标：尝试给咱们要解决的问题找到最优算法

经过复杂性分析得出的上下文结果：

咱们真正证实的是：
归并排序，就比较的次数而言，是最优的
可是它就空间使用并不是最优，归并排序使用多一倍的额外空间，正比于它要处理的数组的大小。而简单的算法，好比插入或其余排序，他们根本不适用任何额外的空间。

因此，当咱们关注实现并尝试解决实际问题时，咱们把这些理论结果用做一个指导。
在这个例子里，它告诉咱们的是：
好比，不要尝试设计一个排序算法保证大致上比归并排序，在比较次数上，更好的算法，比方说，1/2NlogN。有方法使用 1/2NlogN次比较的吗？下限说，没有；
再好比，也许有一个算法，使用 NlogN 次比较，同时也有最优的空间利用率。不只在时间上，也在空间上都是最优的。咱们即将看到在下面谈论这样的算法。

另外一件事是，特定模型下的下限是针对正在研究的特定计算模型得出的，在这个例子中是比较的次数。若是算法有关于键值的更多信息，它可能不成立。若是算法能够利用如下优点，则下限可能不成立：

• 输入数组的初始顺序

  • 例如：插入排序只须要对部分排序的数组进行线性数量的比较。又或者若是输入是几乎排序好的。咱们曾看到对于几乎排序好的文件，插入排序能够是线性时间的。

• 键值的分布

  • 若是有许多相等的键，咱们能够令它排序得比 NlogN 更快。还有 3-way quicksort 快速排序仅须要在具备恒定数量的不一样键的数组上进行线性数量的比较。(后续章节)

• 键的表示

  • 例如：基数排序不须要键值的比较 - 它们直接经过访问数据. 经过字符/数位(digit)比较。后续章节）
    咱们能够利用数字字符的比较，而不是整个键的比较，并对特定的实际应用获得一个更快地排序。

计算复杂度是一个很是有用的方法来帮助咱们理解算法的性质并帮助指导咱们的设计决策。

附录

Q. 如下哪一种子数组长度会在对长度为 12 的数组进行归并排序时出现？
B. { 1, 2, 3, 6, 12 }

对上下界理解的补充
到目前为止，咱们一直关注这个问题：“给定一些问题X，咱们可否构建一个在大小为n的输入上运行时间O(f(n))的算法？”
这一般被称为上限问题，由于咱们正在肯定问题X的固有难度的上界，咱们的目标是使f(n)尽量小。

下界问题, 这里，目标是证实任何算法必须花费时间 Ω(g(n))时间来解决问题，如今咱们的目标让 g(n)尽量大。
下限帮助咱们理解咱们与某个问题的最佳解决方案有多接近：
例如，若是咱们有一个在上界时间 O(n log^2 n) 和 下界Ω(n log n) 运行的算法，那么咱们的算法有log(n) 的 “差距”：咱们但愿经过改进算法缩小这个差距。

一般，咱们将在限制的计算模型中证实下限，指定能够对输入执行什么类型的操做以及执行什么开销。所以，这种模型的下限意味着若是咱们想要算法作得更好，咱们须要以某种方式在模型以外作一些事情。
今天咱们考虑基于比较的排序算法类。这些排序算法仅经过比较一对键值对输入数组进行操做，在比较的基础上移动元素。

面试问题

编程练习