写在前面
整个项目都托管在了 Github 上：https://github.com/ikesnowy/Algorithms-4th-Edition-in-Csharp
这一节内容可能会用到的库文件有 Merge，同样在 Github 上可以找到。
善用 Ctrl + F 查找题目。
习题&题解
2.2.1
题目
按照本书开头所示轨迹的格式给出原地归并排序的抽象 merge() 方法是如何将数组 A E Q S U Y E I N O S T 排序的。
解答
2.2.2
题目
按照算法 2.4 所示轨迹的格式给出自顶向下的归并排序是如何将数组 E A S Y Q U E S T I O N 排序的。
解答
2.2.3
题目
用自底向上的归并排序解答练习 2.2.2
解答
2.2.4
题目
是否当且仅当两个输入的子数组都有序时原地归并的抽象方法才能得到正确的结果？
证明你的结论，或者给出一个反例。
解答
是的，必须要两个子数组都有序时归并才能得到正确结果。
如果说数组不有序的话，那么最后只能得到两个数组的混合。
合并后的数组中，属于原有数组的元素的相对顺序不会被改变。
例如子数组 1 3 1 和 2 8 5 原地归并。
结果是 1 2 3 1 8 5，其中 1 3 1 和 2 8 5 的相对顺序不变。
2.2.5
题目
当输入数组的大小 N=39 时，给出自顶向下和自底向上的归并排序中各次归并子数组的大小及顺序。
解答
每次归并子数组的大小和顺序如下：
自顶向下
2, 3, 2, 5, 2, 3, 2, 5, 10, 2, 3, 2, 5, 2, 3, 2, 5, 10, 20, 2, 3, 2, 5, 2, 3, 2, 5, 10, 2, 3, 2, 5, 2, 2, 4, 9, 19, 39
自底向上
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 8, 8, 8, 8, 7, 16, 16, 32, 39
2.2.6
题目
编写一个程序来计算自顶向下和自底向上的归并排序访问数组的准确次数。
使用这个程序将 N=1 至 512 的结果绘成曲线图，并将其和上限 6NlgN 相比较。
解答
灰色是上限，蓝点是自顶向下，红点是自底向上。
由于两种排序访问数组的次数是一样的，因此蓝点和红点重合。
代码
给出绘图部分的代码：
using System; using System.Windows.Forms; using System.Drawing; using Merge; namespace _2._2._6 { /* * 2.2.6 * * 编写一个程序来计算自顶向下和自底向上的归并排序访问数组的准确次数。 * 使用这个程序将 N=1 至 512 的结果绘成曲线图， * 并将其和上限 6NlgN 相比较。 * */ static class Program { /// <summary> /// 应用程序的主入口点。 /// </summary> [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Compute(); Application.Run(new Form1()); } static void Compute() { MergeSort mergeSort = new MergeSort(); MergeSortBU mergeSortBU = new MergeSortBU(); int[] mergeResult = new int[10]; int[] mergeResultBU = new int[10]; int[] upperBound = new int[10]; // 进行计算 int dataSize = 1; for (int i = 0; i < 10; i++) { int[] dataMerge = SortCompare.GetRandomArrayInt(dataSize); int[] dataMergeBU = new int[dataSize]; dataMerge.CopyTo(dataMergeBU, 0); mergeSort.ClearArrayVisitCount(); mergeSortBU.ClearArrayVisitCount(); mergeSort.Sort(dataMerge); mergeSortBU.Sort(dataMergeBU); mergeResult[i] = mergeSort.GetArrayVisitCount(); mergeResultBU[i] = mergeSortBU.GetArrayVisitCount(); upperBound[i] = (int)(6 * dataSize * Math.Log(dataSize, 2)); dataSize *= 2; } // 绘图 Form2 plot = new Form2(); plot.Show(); Graphics graphics = plot.CreateGraphics(); // 获得绘图区矩形。 RectangleF rect = plot.ClientRectangle; float unitX = rect.Width / 10; float unitY = rect.Width / 10; // 添加 10% 边距作为文字区域。 RectangleF center = new RectangleF (rect.X + unitX, rect.Y + unitY, rect.Width - 2 * unitX, rect.Height - 2 * unitY); // 绘制坐标系。 graphics.DrawLine(Pens.Black, center.Left, center.Top, center.Left, center.Bottom); graphics.DrawLine(Pens.Black, center.Left, center.Bottom, center.Right, center.Bottom); graphics.DrawString("28000", plot.Font, Brushes.Black, rect.Location); graphics.DrawString("1024", plot.Font, Brushes.Black, center.Right, center.Bottom); graphics.DrawString("0", plot.Font, Brushes.Black, rect.Left, center.Bottom); // 初始化点。 PointF[] grayPoints = new PointF[10]; // 上限 PointF[] redPoints = new PointF[10]; // 自顶向下 PointF[] bluePoints = new PointF[10]; // 自底向上 unitX = center.Width / 11.0f; unitY = center.Height / 28000.0f; for (int i = 0; i < 10; i++) { grayPoints[i] = new PointF(center.Left + unitX * (i + 1), center.Bottom - (upperBound[i] * unitY) - 10); redPoints[i] = new PointF(center.Left + unitX * (i + 1), center.Bottom - (mergeResult[i] * unitY) - 10); bluePoints[i] = new PointF(center.Left + unitX * (i + 1), center.Bottom - (mergeResultBU[i] * unitY) - 10); } // 绘制点。 for (int i = 0; i < 10; i++) { graphics.FillEllipse(Brushes.Gray, new RectangleF(grayPoints[i], new SizeF(10, 10))); graphics.FillEllipse(Brushes.Red, new RectangleF(redPoints[i], new SizeF(10, 10))); graphics.FillEllipse(Brushes.Blue, new RectangleF(bluePoints[i], new Size(10, 10))); } graphics.Dispose(); } } }
2.2.7
题目
证明归并排序的比较次数是单调递增的（即对于 N>0，C(N+1)>C(N)）。
解答
根据书本给出的命题 G 和命题 H（中文版 P173/176，英文版 P275/279），
比较次数的下限 C(N) = 1/2 * NlgN
N 和 lgN 都是单调递增且大于零的(N>1)，因此 C(N) 也是单调递增的
2.2.8
题目
假设将算法 2.4 修改为：
只要 a[mid] <= a[mid+1] 就不调用 merge() 方法，
请证明用归并排序处理一个已经有序的数组所需的比较次数是线性级别的。
解答
修改后的算法对已经有序的情况做了优化
数组对半切分并排序后，
如果 a[mid] < a[mid + 1]（左半部分的最后一个元素小于右半部分的第一个元素）
那么我们可以直接合并数组，不需要再做多余的操作
现在的输入是一个已经排序的数组
算法唯一的比较发生在判断 a[mid] < a[mid + 1] 这个条件时
假定数组有 N 个元素
比较次数满足 T(N) = 2 * T(N / 2) + 1, T(1) = 0
转化为非递归形式即为：T(N) = cN / 2 + N - 1
其中 c 为任意正整数
2.2.9
题目
在库函数中使用 aux[] 这样的静态数组时不妥当的，
因为可能会有多个程序同时使用这个类。
实现一个不用静态数组的 Merge 类，
但也不要将 aux[] 变为 merge() 的局部变量（请见本书的答疑部分）。
提示：可以将辅助数组作为参数传递给递归的 sort() 方法。
解答
官方给出的归并排序实现中在 Sort 方法里初始化了 aux 数组。
源码见：https://algs4.cs.princeton.edu/22mergesort/Merge.java.html
C#实现和官方的实现非常类似，
首先定义只接受一个参数的公开 Sort 方法，在这个方法里面初始化 aux 数组
/// <summary> /// 利用归并排序将数组按升序排序。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">待排序的数组。</param> public override void Sort<T>(T[] a) { T[] aux = new T[a.Length]; Sort(a, aux, 0, a.Length - 1); }
然后建立一个私有的递归 Sort 方法做实际的排序操作。
/// <summary> /// 自顶向下地对数组指定范围内进行归并排序，需要辅助数组。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">排序范围起点。</param> /// <param name="hi">排序范围终点。</param> private void Sort<T>(T[] a, T[] aux, int lo, int hi) where T : IComparable<T> { 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); }
代码
using System; namespace Merge { /// <summary> /// 归并排序类。 /// </summary> public class MergeSort : BaseSort { /// <summary> /// 默认构造函数。 /// </summary> public MergeSort() { } /// <summary> /// 利用归并排序将数组按升序排序。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">待排序的数组。</param> public override void Sort<T>(T[] a) { T[] aux = new T[a.Length]; Sort(a, aux, 0, a.Length - 1); } /// <summary> /// 自顶向下地对数组指定范围内进行归并排序，需要辅助数组。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">排序范围起点。</param> /// <param name="hi">排序范围终点。</param> private void Sort<T>(T[] a, T[] aux, int lo, int hi) where T : IComparable<T> { 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); } /// <summary> /// 将指定范围内的元素归并。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">范围起点。</param> /// <param name="mid">范围中点。</param> /// <param name="hi">范围终点。</param> private void Merge<T>(T[] a, T[] aux, int lo, int mid, int hi) where T : IComparable<T> { 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]; j++; } else if (j > hi) { a[k] = aux[i]; i++; } else if (Less(aux[j], aux[i])) { a[k] = aux[j]; j++; } else { a[k] = aux[i]; i++; } } } } }
2.2.10
题目
快速归并。
实现一个 merge() 方法，按降序将 a[] 的后半部分复制到 aux[]，
然后将其归并回 a[] 中。这样就可以去掉内循环中检测某半边是否用尽的代码。
注意：这样的排序产生的结果是不稳定的（请见 2.5.1.8 节）。
解答
官方同样给出了 java 实现，如下：
private static void merge(Comparable[] a, int lo, int mid, int hi) { for (int i = lo; i <= mid; i++) aux[i] = a[i]; for (int j = mid+1; j <= hi; j++) aux[j] = a[hi-j+mid+1]; int i = lo, j = hi; for (int k = lo; k <= hi; k++) if (less(aux[j], aux[i])) a[k] = aux[j--]; else a[k] = aux[i++]; }
C# 实现见代码部分。
代码
using System; using Merge; namespace _2._2._10 { /// <summary> /// 归并排序类。 /// </summary> public class MergeSort : BaseSort { /// <summary> /// 默认构造函数。 /// </summary> public MergeSort() { } /// <summary> /// 利用归并排序将数组按升序排序。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">待排序的数组。</param> public override void Sort<T>(T[] a) { T[] aux = new T[a.Length]; Sort(a, aux, 0, a.Length - 1); } /// <summary> /// 自顶向下地对数组指定范围内进行归并排序，需要辅助数组。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">排序范围起点。</param> /// <param name="hi">排序范围终点。</param> private void Sort<T>(T[] a, T[] aux, int lo, int hi) where T : IComparable<T> { 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); } /// <summary> /// 将指定范围内的元素归并。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">范围起点。</param> /// <param name="mid">范围中点。</param> /// <param name="hi">范围终点。</param> private void Merge<T>(T[] a, T[] aux, int lo, int mid, int hi) where T : IComparable<T> { // 前半部分升序复制 for (int k = lo; k <= mid; k++) { aux[k] = a[k]; } // 后半部分降序复制 for (int k = mid + 1; k <= hi; k++) { aux[k] = a[hi - k + mid + 1]; } // i 指向最左端，j 指向最右端 int i = lo, j = hi; for (int k = lo; k <= hi; k++) { if (Less(aux[j], aux[i])) { a[k] = aux[j]; j--; } else { a[k] = aux[i]; i++; } } } } }
2.2.11
题目
改进。
实现 2.2.2 节所述的对归并排序的三项改进：
加快小数组的排序速度，
检测数组是否已经有序以及通过在递归中交换参数来避免复制。
解答
官方实现见：https://algs4.cs.princeton.edu/22mergesort/MergeX.java.html
在 MergeSortX 类里添加一个 CUTOFF 字段，排序时如果数组长度小于它则直接调用插入排序进行排序。
在调用归并方法前判断第一个有序数组的最后一个元素是否大于第二个有序数组的第一个元素，
如果大于的话就不需要调用归并了，直接首尾相接即可。
每次归并都需要两个数组，一个用于存放归并结果，这个数组中的内容是无关紧要的；
另一个则保存了归并前的数组，用于实际的归并过程。
归并结束后，前一个数组变成归并后的有序结果（也就是下一次归并时的「归并前数组」），后一个数组中的内容则不再有用。
我们可以看到这两个数组的角色在下一次归并时正好可以互换。
要注意的是，归并次数总是一个奇数（左侧归并+右侧归并+总归并），因此在第一次调用 Sort 方法时应该把 aux 和 a 互换传入。
代码
using System; namespace Merge { /// <summary> /// 优化后的归并排序类。 /// </summary> public class MergeSortX : BaseSort { /// <summary> /// 对小于 CUTOFF 的数组使用插入排序。 /// </summary> private static int CUTOFF = 7; /// <summary> /// 默认构造函数。 /// </summary> public MergeSortX() { } /// <summary> /// 设置启用插入排序的阈值，小于该阈值的数组将采用插入排序。 /// </summary> /// <param name="cutoff">新的阈值。</param> public void SetCutOff(int cutoff) => CUTOFF = cutoff; /// <summary> /// 将指定范围内的元素归并。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="src">原始数组。</param> /// <param name="dst">目标数组。</param> /// <param name="lo">范围起点。</param> /// <param name="mid">范围中点。</param> /// <param name="hi">范围终点。</param> private void Merge<T>(T[] src, T[] dst, int lo, int mid, int hi) where T : IComparable<T> { int i = lo, j = mid + 1; for (int k = lo; k <= hi; k++) { if (i > mid) dst[k] = src[j++]; else if (j > hi) dst[k] = src[i++]; else if (Less(src[j], src[i])) dst[k] = src[j++]; else dst[k] = src[i++]; } } /// <summary> /// 自顶向下地对数组指定范围内进行归并排序，需要辅助数组。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="src">原数组。</param> /// <param name="dst">辅助数组。</param> /// <param name="lo">排序范围起点。</param> /// <param name="hi">排序范围终点。</param> private void Sort<T>(T[] src, T[] dst, int lo, int hi) where T : IComparable<T> { // 小于 CUTOFF 的数组调用插入排序 if (hi <= lo + CUTOFF) { InsertionSort insertion = new InsertionSort(); insertion.Sort(dst, lo, hi); return; } int mid = lo + (hi - lo) / 2; // 交换辅助数组和原数组 Sort(dst, src, lo, mid); Sort(dst, src, mid + 1, hi); // 已排序的数组直接合并 if (!Less(src[mid + 1], src[mid])) { Array.Copy(src, lo, dst, lo, hi - lo + 1); return; } Merge(src, dst, lo, mid, hi); } /// <summary> /// 利用优化后的归并排序对数组 a 排序。 /// </summary> /// <typeparam name="T">数组中的元素类型。</typeparam> /// <param name="a">需要排序的数组。</param> public override void Sort<T>(T[] a) { T[] aux = new T[a.Length]; a.CopyTo(aux, 0); // aux 和 a 需要交换 Sort(aux, a, 0, a.Length - 1); } } }
2.2.12
题目
次线性的额外空间。用大小 M 的数组分为 N/M 块（简单起见，设 M 是 N 的约数）。
实现一个归并方法，使之所需的额外空间减少到 max(M, N/M)：
（i）可以先将一个块看作一个元素，将块的第一个元素作为块的主键，用选择排序将块排序；
（ii）遍历数组，将第一块和第二块归并，完成后将第二块和第三块归并，等等。
解答
中文版的翻译比较难理解
实际上就是另一种归并排序的实现方式
先把数组分成若干个大小为 M 的块
对于每个块，用选择排序进行排序
随后遍历数组，将各个块归并起来
代码
using System; using Merge; namespace _2._2._12 { /// <summary> /// 归并排序类。 /// </summary> public class MergeSort : BaseSort { /// <summary> /// 默认构造函数。 /// </summary> public MergeSort() { } /// <summary> /// 利用归并排序将数组按升序排序。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">待排序的数组。</param> public override void Sort<T>(T[] a) { Sort(a, 1); } /// <summary> /// 利用分块法进行归并排序。 /// </summary> /// <typeparam name="T">待排序的数组内容。</typeparam> /// <param name="a">待排序的数组。</param> /// <param name="M">分块大小。</param> public void Sort<T>(T[] a, int M) where T : IComparable<T> { int blockNum = a.Length / M; SelectionSort selection = new SelectionSort(); // 对块进行选择排序。 for (int i = 0; i < blockNum; i++) { int lo = i * M; int hi = (i + 1) * M - 1; selection.Sort(a, lo, hi); } // 将各个块合并。 for (int i = 0; i < blockNum - 1; i++) { Merge(a, 0, (i + 1) * M - 1, (i + 2) * M - 1); } } /// <summary> /// 将指定范围内的元素归并。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="lo">范围起点。</param> /// <param name="mid">范围中点。</param> /// <param name="hi">范围终点。</param> private void Merge<T>(T[] a, int lo, int mid, int hi) where T : IComparable<T> { T[] aux = new T[hi - lo + 1]; 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]; j++; } else if (j > hi) { a[k] = aux[i]; i++; } else if (Less(aux[j], aux[i])) { a[k] = aux[j]; j++; } else { a[k] = aux[i]; i++; } } } } }
2.2.13
题目
平均情况的下限。请证明任意基于比较的排序算法的预期比较次数至少为 ~NlogN（假设输入元素的所有排列的出现概率是均等的）。
提示：比较次数至少是比较树的外部路径的长度（根结点到叶子结点的路径长度之和），当树平衡时该值最小。
解答
假设对三个数进行排序，这三个数是：35，10，17
三个数排序的决策树如下，结点代表比较对应位置上的数。
对于 35,10,17 来说，路径遵循左、右、左，最后得到的结果就是 2 3 1（10,17,35）。
我们可以发现决策树上的每一个叶子节点都代表一种排列顺序，对于 N 个数，叶子节点就有 N! 个
根据二叉树的性质，高度为 h 的二叉树最多有 2^h 个叶子节点
那么，对于 N 个数，决策树的高度 h 的最小值可以通过下面这个式子得出来
2^h >= n!
h >= log(n!)
因此可以得到决策树高度 h 的最小值是 log(n!)
接下来我们来计算平均路径长度
我们令函数 H(k) 代表有 k 个叶子节点的平衡决策树的所有路径长度之和
上例中 H(6) = 2 + 2 + 3 + 3 + 3 + 3 = 16
由于平衡决策树的性质，H(k) = 2H(k / 2) + k
（加上 k 的原因：左右子树的高度比整个树的高度小 1，因此每条路径的长度都必须加 1，总共多加了 k 次）
因此 H(k) = klogk
现在令 k = n!
H(n!) = n!log(n!)
由于每次排序时我们只经过某一条路径（上例中我们只经过了左、右、左这条路径）
而且每种路径的出现概率相等
因此平均比较次数应该为 H(n!) / n! = log(n!) = nlog(n)
证明完毕
2.2.14
题目
归并有序的队列。
编写一个静态方法，将两个有序的队列作为参数，返回一个归并后的有序队列。
解答
比较两个有序队列的第一个元素，取较小的一个出队并放入额外建立的队列中。
重复上述步骤直到两个队列都为空。
代码
/// <summary> /// 归并两个有序队列。输入队列将被清空。 /// </summary> /// <typeparam name="T">有序队列的元素类型。</typeparam> /// <param name="a">需要归并的队列。</param> /// <param name="b">需要归并的队列。</param> /// <returns>归并后的新队列。</returns> static Queue<T> Merge<T>(Queue<T> a, Queue<T> b) where T : IComparable<T> { Queue<T> sortedQueue = new Queue<T>(); while (!a.IsEmpty() && !b.IsEmpty()) { if (a.Peek().CompareTo(b.Peek()) < 0) sortedQueue.Enqueue(a.Dequeue()); else sortedQueue.Enqueue(b.Dequeue()); } while (!a.IsEmpty()) sortedQueue.Enqueue(a.Dequeue()); while (!b.IsEmpty()) sortedQueue.Enqueue(b.Dequeue()); return sortedQueue; }
2.2.15
题目
自底向上的有序队列归并排序。
用下面的方法编写一个自底向上的归并排序：
给定 N 个元素，创建 N 个队列，每个队列包含其中一个元素。
创建一个由这 N 个队列组成的队列，然后不断用练习 2.2.14 中的方法将队列的头两个元素归并，
并将结果重新加入到队列结尾，直到队列的队列只剩下一个元素为止。
解答
程序思路题目已经给出，按照题意实现即可。
Merge 方法可以直接使用前一题的实现。
代码
using System; namespace _2._2._15 { /// <summary> /// 利用队列归并实现的自底向上的归并排序。 /// </summary> class MergeSortQueue { /// <summary> /// 默认构造函数。 /// </summary> public MergeSortQueue() { } /// <summary> /// 利用队列归并进行自底向上的归并排序。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="a">需要排序的数组。</param> public void Sort<T>(T[] a) where T : IComparable<T> { Queue<Queue<T>> queueList = new Queue<Queue<T>>(); for (int i = 0; i < a.Length; i++) { Queue<T> temp = new Queue<T>(); temp.Enqueue(a[i]); queueList.Enqueue(temp); } while (queueList.Size() != 1) { int times = queueList.Size() / 2; for (int i = 0; i < times; i++) { Queue<T> A = queueList.Dequeue(); Queue<T> B = queueList.Dequeue(); queueList.Enqueue(Merge(A, B)); } } Queue<T> result = queueList.Dequeue(); for (int i = 0; i < a.Length; i++) { a[i] = result.Dequeue(); } } /// <summary> /// 归并两个有序队列。输入队列将被清空。 /// </summary> /// <typeparam name="T">有序队列的元素类型。</typeparam> /// <param name="a">需要归并的队列。</param> /// <param name="b">需要归并的队列。</param> /// <returns>归并后的新队列。</returns> public static Queue<T> Merge<T>(Queue<T> a, Queue<T> b) where T : IComparable<T> { Queue<T> sortedQueue = new Queue<T>(); while (!a.IsEmpty() && !b.IsEmpty()) { if (a.Peek().CompareTo(b.Peek()) < 0) sortedQueue.Enqueue(a.Dequeue()); else sortedQueue.Enqueue(b.Dequeue()); } while (!a.IsEmpty()) sortedQueue.Enqueue(a.Dequeue()); while (!b.IsEmpty()) sortedQueue.Enqueue(b.Dequeue()); return sortedQueue; } } }
2.2.16
题目
自然的归并排序。
编写一个自底向上的归并排序，当需要将两个子数组排序时能够利用数组中已经有序的部分。
首先找到一个有序的子数组（移动指针直到当前元素比上一个元素小为止），
然后再找出另一个并将它们归并。
根据数组大小和数组中递增子数组的最大长度分析算法的运行时间。
解答
自然归并排序的一个示例如下图所示：
基本过程和自底向上的归并排序类似，只是每次归并的块大小不一定相同。
代码
using System; using System.Diagnostics; namespace Merge { /// <summary> /// 自然的归并排序。 /// </summary> public class MergeSortNatural : BaseSort { /// <summary> /// 默认构造函数。 /// </summary> public MergeSortNatural() { } /// <summary> /// 利用自然的归并排序进行自底向上的排序。 /// </summary> /// <typeparam name="T">用于排序的元素类型。</typeparam> /// <param name="a">需要排序的数组。</param> public override void Sort<T>(T[] a) { T[] aux = new T[a.Length]; while (true) { // 找到第一个块 int lo = 0; int mid = FindBlock(lo, a) - 1; if (mid == a.Length - 1) break; while (mid < a.Length - 1) { int hi = FindBlock(mid + 1, a) + mid; Merge(lo, mid, hi, a, aux); lo = hi + 1; mid = FindBlock(lo, a) + lo; } } Debug.Assert(IsSorted(a)); } /// <summary> /// 将两个块归并。 /// </summary> /// <typeparam name="T">数组的元素类型。</typeparam> /// <param name="lo">第一个块的开始下标。</param> /// <param name="mid">第一个块的结束下标（第二个块的开始下标 - 1）。</param> /// <param name="hi">第二个块的结束下标。</param> /// <param name="a">需要归并的数组。</param> /// <param name="aux">辅助数组。</param> private void Merge<T>(int lo, int mid, int hi, T[] a, T[] aux) where T : IComparable<T> { 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]; j++; } else if (j > hi) { a[k] = aux[i]; i++; } else if (Less(aux[j], aux[i])) { a[k] = aux[j]; j++; } else { a[k] = aux[i]; i++; } } } /// <summary> /// 获取下一个有序块。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="lo">查找起点。</param> /// <param name="a">用于查找的数组。</param> /// <returns>块的大小。</returns> private int FindBlock<T>(int lo, T[] a) where T : IComparable<T> { int size = 1; for (int i = lo; i < a.Length - 1; i++) { if (Less(a[i], a[i + 1]) || a[i].Equals(a[i + 1])) size++; else break; } return size; } } }
2.2.17
题目
链表排序。
实现对链表的自然排序
（这是将链表排序的最好方法，因为它不需要额外的空间且运行时间是线性对数级别的）。
解答
排序方式和 2.2.16 十分类似，不再赘述，这里介绍一下归并方法。
如 gif 图所示，先把要归并的两个链表拆出来，随后确定表头位置，然后进行归并即可。
归并结束后返回 first。
结果分析如下图所示：
随着有序部分的增加，对于相同大小的数组自然归并排序的耗时会缩短。
对于有序部分相同的情况，随着数组大小的倍增，耗时呈现了O(nlogn)的趋势。
代码
using System; using System.Diagnostics; using Merge; namespace _2._2._17 { /// <summary> /// 自然的归并排序。 /// </summary> public class MergeSortNatural : BaseSort { /// <summary> /// 默认构造函数。 /// </summary> public MergeSortNatural() { } /// <summary> /// 利用自然的归并排序进行自底向上的排序。 /// </summary> /// <typeparam name="T">用于排序的元素类型。</typeparam> /// <param name="a">需要排序的数组。</param> public override void Sort<T>(T[] a) { T[] aux = new T[a.Length]; while (true) { // 找到第一个块 int lo = 0; int mid = FindBlock(lo, a) - 1; if (mid == a.Length - 1) break; while (mid < a.Length - 1) { int hi = FindBlock(mid + 1, a) + mid; Merge(lo, mid, hi, a, aux); lo = hi + 1; mid = FindBlock(lo, a) + lo; } } Debug.Assert(IsSorted(a)); } /// <summary> /// 利用自然的归并排序将链表排序。 /// </summary> /// <typeparam name="T">链表元素类型。</typeparam> /// <param name="a">等待排序的链表。</param> public void Sort<T>(LinkedList<T> a) where T : IComparable<T> { while (true) { // 找到第一个块 Node<T> lo = a.GetFirst(); Node<T> mid = FindBlock(lo); if (mid.next == null) break; while (mid.next != null) { Node<T> hi = FindBlock(mid.next); if (lo == a.GetFirst()) a.SetFirst(Merge(lo, mid, hi)); else lo.next = Merge(lo.next, mid, hi); // 跳到表尾 if (Less(hi.item, mid.item)) lo = mid; else lo = hi; if (lo.next != null) mid = FindBlock(lo.next); } } } /// <summary> /// 将两个块归并。 /// </summary> /// <typeparam name="T">数组的元素类型。</typeparam> /// <param name="lo">第一个块的开始下标。</param> /// <param name="mid">第一个块的结束下标（第二个块的开始下标 - 1）。</param> /// <param name="hi">第二个块的结束下标。</param> /// <param name="a">需要归并的数组。</param> /// <param name="aux">辅助数组。</param> private void Merge<T>(int lo, int mid, int hi, T[] a, T[] aux) where T : IComparable<T> { 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]; j++; } else if (j > hi) { a[k] = aux[i]; i++; } else if (Less(aux[j], aux[i])) { a[k] = aux[j]; j++; } else { a[k] = aux[i]; i++; } } } /// <summary> /// 将两个有序链表块归并，返回新的表头。 /// </summary> /// <typeparam name="T">链表元素类型。</typeparam> /// <param name="lo">第一个有序块起点。</param> /// <param name="mid">第一个有序块终点（第二个有序块起点的前驱）。</param> /// <param name="hi">第二个有序块的终点。</param> /// <returns>新的表头。</returns> private Node<T> Merge<T>(Node<T> lo, Node<T> mid, Node<T> hi) where T : IComparable<T> { Node<T> after = hi.next; // 要合并的两个块之后的元素 Node<T> first = null; Node<T> i = lo; // 链表1 Node<T> j = mid.next; // 链表2 // 切割链表 mid.next = null; hi.next = null; Node<T> current = null; // 决定新的表头 if (Less(i.item, j.item)) { current = i; i = i.next; } else { current = j; j = j.next; } first = current; // 归并表 while (i != null && j != null) { if (Less(i.item, j.item)) { current.next = i; i = i.next; current = current.next; } else { current.next = j; j = j.next; current = current.next; } } if (i == null) current.next = j; else current.next = i; // 连接表尾（链表 1 的尾部或者链表 2 的尾部） if (mid.next == null) mid.next = after; else hi.next = after; return first; } /// <summary> /// 获取下一个有序块。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="lo">查找起点。</param> /// <param name="a">用于查找的数组。</param> /// <returns>块的大小。</returns> private int FindBlock<T>(int lo, T[] a) where T : IComparable<T> { int size = 1; for (int i = lo; i < a.Length - 1; i++) { if (Less(a[i], a[i + 1]) || a[i].Equals(a[i + 1])) size++; else break; } return size; } /// <summary> /// 获取链表的下一个有序块。 /// </summary> /// <typeparam name="T">链表的元素类型。</typeparam> /// <param name="lo">查找的起始结点。</param> /// <returns>有序块的最后一个元素结点。</returns> private Node<T> FindBlock<T>(Node<T> lo) where T : IComparable<T> { Node<T> hi = lo; while (hi.next != null) { if (Less(hi.item, hi.next.item) || hi.item.Equals(hi.next.item)) hi = hi.next; else break; } return hi; } } }
2.2.18
题目
打乱链表。
实现一个分治算法，使用线性对数级别的时间和对数级别的额外空间随机打乱一条链表。
解答
可以在用归并排序的方法做。
将归并时取两边较小的元素改为随机取一侧的值，即可实现打乱的效果。
算法的分析和普通归并排序一致，满足题目要求。
代码
分治法打乱链表的实现。
using System; namespace _2._2._18 { /// <summary> /// 分治法打乱链表。
/// </summary> public class MergeShuffle { /// <summary> /// 默认构造函数。 /// </summary> public MergeShuffle() { } /// <summary> /// 利用分治法打乱链表。 /// </summary> /// <typeparam name="T">链表元素类型。</typeparam> /// <param name="a">等待打乱的链表。</param> public void Shuffle<T>(LinkedList<T> a) { int blockLen = 1; Random random = new Random(); while (blockLen <= a.Size()) { // 找到第一个块 Node<T> lo = a.GetFirst(); Node<T> mid = FindBlock(lo, blockLen); if (mid.next == null) break; while (mid.next != null) { Node<T> hi = FindBlock(mid.next, blockLen); Node<T>[] result; if (lo == a.GetFirst()) { result = Merge(lo, mid, hi, random); a.SetFirst(result[0]); } else { result = Merge(lo.next, mid, hi, random); lo.next = result[0]; } // 跳到表尾 lo = result[1]; if (lo.next != null) mid = FindBlock(lo.next, blockLen); else mid = lo; } blockLen *= 2; } } /// <summary> /// 将两个有序链表块随机归并，返回新的表头。 /// </summary> /// <typeparam name="T">链表元素类型。</typeparam> /// <param name="lo">第一个块起点。</param> /// <param name="mid">第一个块终点（第二个块起点的前驱）。</param> /// <param name="hi">第二个块的终点。</param> /// <returns>新的表头。</returns> private Node<T>[] Merge<T>(Node<T> lo, Node<T> mid, Node<T> hi, Random random) { Node<T> after = hi.next; // 要合并的两个块之后的元素 Node<T> first = null; Node<T>[] result = new Node<T>[2]; Node<T> i = lo; // 链表1 Node<T> j = mid.next; // 链表2 // 切割链表 mid.next = null; hi.next = null; Node<T> current = null; // 决定新的表头 if (random.NextDouble() >= 0.5) { current = i; i = i.next; } else { current = j; j = j.next; } first = current; // 归并表 while (i != null && j != null) { if (random.NextDouble() >= 0.5) { current.next = i; i = i.next; current = current.next; } else { current.next = j; j = j.next; current = current.next; } } if (i == null) current.next = j; else current.next = i; // 连接表尾（链表 1 的尾部或者链表 2 的尾部） if (mid.next == null) { mid.next = after; result[1] = mid; } else { hi.next = after; result[1] = hi; } result[0] = first; return result; } /// <summary> /// 获取从指定位置开始定长的链表。 /// </summary> /// <typeparam name="T">链表的元素类型。</typeparam> /// <param name="lo">链表的起始结点。</param> /// <param name="length">需要获取的链表长度。</param> /// <returns>结果链表的最后一个元素结点。</returns> private Node<T> FindBlock<T>(Node<T> lo, int length) { Node<T> hi = lo; for (int i = 0; i < length - 1 && hi.next != null; i++) { hi = hi.next; } return hi; } } }
2.2.19
题目
倒置。
编写一个线性对数级别的算法统计给定数组中“倒置”数量
（即插入排序所需的交换次数，请见 2.1 节）。
这个数量和 Kendall tau 距离有关，请见 2.5 节。
解答
官方实现：https://algs4.cs.princeton.edu/22mergesort/Inversions.java.html
事实上只要在归并排序的时候统计 Less(aux[j], aux[i]) 满足的次数即可，这个次数就是我们要的值。
代码
using System; using Merge; namespace _2._2._19 { /// <summary> /// 归并排序类。 /// </summary> public class MergeSort : BaseSort { public int Counter = 0; /// <summary> /// 默认构造函数。 /// </summary> public MergeSort() { } /// <summary> /// 利用归并排序将数组按升序排序。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">待排序的数组。</param> public override void Sort<T>(T[] a) { T[] aux = new T[a.Length]; Sort(a, aux, 0, a.Length - 1); } /// <summary> /// 自顶向下地对数组指定范围内进行归并排序，需要辅助数组。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">排序范围起点。</param> /// <param name="hi">排序范围终点。</param> private void Sort<T>(T[] a, T[] aux, int lo, int hi) where T : IComparable<T> { 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); } /// <summary> /// 将指定范围内的元素归并。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">范围起点。</param> /// <param name="mid">范围中点。</param> /// <param name="hi">范围终点。</param> private void Merge<T>(T[] a, T[] aux, int lo, int mid, int hi) where T : IComparable<T> { 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]; j++; } else if (j > hi) { a[k] = aux[i]; i++; } else if (Less(aux[j], aux[i])) { a[k] = aux[j]; this.Counter += mid - i + 1; // 统计逆序对数 j++; } else { a[k] = aux[i]; i++; } } } } }
2.2.20
题目
间接排序。
编写一个不改变数组的归并排序，
它返回一个 int[] 数组 perm，其中 perm[i] 的值是原数组中第 i 小的元素的位置。
解答
官方实现：https://algs4.cs.princeton.edu/22mergesort/Merge.java.html
把 Sort 方法中传入的 a 数组换成一个 index 数组，将 Merge 方法中的判断改为 Less(a[aux[j]], a[aux[i]]) 即可。
代码
using System; using Merge; namespace _2._2._20 { /// <summary> /// 归并排序类。 /// </summary> public class MergeSort : BaseSort { /// <summary> /// 默认构造函数。 /// </summary> public MergeSort() { } /// <summary> /// 利用归并排序将数组按升序排序。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">待排序的数组。</param> public int[] IndexSort<T>(T[] a) where T : IComparable<T> { int[] aux = new int[a.Length]; int[] index = new int[a.Length]; for (int i = 0; i < a.Length; i++) { index[i] = i; } Sort(a, index, aux, 0, a.Length - 1); return index; } /// <summary> /// 自顶向下地对数组指定范围内进行归并排序，需要辅助数组。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">排序范围起点。</param> /// <param name="hi">排序范围终点。</param> private void Sort<T>(T[] a, int[] index, int[] aux, int lo, int hi) where T : IComparable<T> { if (hi <= lo) return; int mid = lo + (hi - lo) / 2; Sort(a, index, aux, lo, mid); Sort(a, index, aux, mid + 1, hi); Merge(a, index, aux, lo, mid, hi); } /// <summary> /// 将指定范围内的元素归并。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">范围起点。</param> /// <param name="mid">范围中点。</param> /// <param name="hi">范围终点。</param> private void Merge<T>(T[] a, int[] index, int[] aux, int lo, int mid, int hi) where T : IComparable<T> { for (int k = lo; k <= hi; k++) { aux[k] = index[k]; } int i = lo, j = mid + 1; for (int k = lo; k <= hi; k++) { if (i > mid) { index[k] = aux[j]; j++; } else if (j > hi) { index[k] = aux[i]; i++; } else if (Less(a[aux[j]], a[aux[i]])) { index[k] = aux[j]; j++; } else { index[k] = aux[i]; i++; } } } public override void Sort<T>(T[] a) { throw new NotImplementedException(); } } }
2.2.21
题目
一式三份。
给定三个列表，每个列表中包含 N 个名字，
编写一个线性对数级别的算法来判定三分列表中是否含有公共的名字，
如果有，返回第一个被找到的这种名字。
解答
对三份列表进行归并排序（O(nlogn)），随后遍历一遍其中的一份表，
用二分查找检查在其余两个表中是否存在相同的姓名（O(nlogn)）
代码
using System; using Merge; namespace _2._2._21 { /* * 2.2.21 * * 一式三份。 * 给定三个列表， * 每个列表中包含 N 个名字， * 编写一个线性对数级别的算法来判定三份列表中是否含有公共的名字， * 如果有，返回第一个被找到的这种名字。 * */ class Program { static void Main(string[] args) { string[] name1 = new string[] { "Noah", "Liam", "Jacob", "Mason" }; string[] name2 = new string[] { "Sophia", "Emma", "Mason", "Ava" }; string[] name3 = new string[] { "Mason", "Marcus", "Alexander", "Ava" }; MergeSort mergeSort = new MergeSort(); mergeSort.Sort(name1); mergeSort.Sort(name2); mergeSort.Sort(name3); for (int i = 0; i < name1.Length; i++) { if (BinarySearch(name1[i], name2, 0, name1.Length) != -1 && BinarySearch(name1[i], name3, 0, name1.Length) != -1) { Console.WriteLine(name1[i]); break; } } } /// <summary> /// 二分查找，返回目标元素的下标，没有结果则返回 -1。 /// </summary> /// <typeparam name="T">查找的元素类型。</typeparam> /// <param name="key">要查找的目标值。</param> /// <param name="array">用于查找的目标范围。</param> /// <param name="lo">查找的起始下标。</param> /// <param name="hi">查找的终止下标。</param> /// <returns>找到则返回元素下标，否则返回 -1。</returns> static int BinarySearch<T>(T key, T[] array, int lo, int hi) where T : IComparable<T> { while (lo <= hi) { int mid = lo + (hi - lo) / 2; if (array[mid].Equals(key)) return mid; else if (array[mid].CompareTo(key) < 0) lo = mid + 1; else hi = mid - 1; } return -1; } } }
2.2.22
题目
三向归并排序。
假设每次我们是把数组分成三个部分而不是两个部分并将它们分别排序。
然后进行三向归并。
这种算法的运行时间的增长数量级是多少。
解答
增长数量级为O(nlogn)。
代码
using System; using System.Diagnostics; namespace Merge { /// <summary> /// 三向归并排序。 /// </summary> public class MergeSortThreeWay : BaseSort { /// <summary> /// 默认构造函数。 /// </summary> public MergeSortThreeWay() { } /// <summary> /// 利用三项归并排序将数组按升序排序。 /// </summary> /// <typeparam name="T">数组中的元素类型。</typeparam> /// <param name="a">待排序的数组。</param> public override void Sort<T>(T[] a) { T[] aux = new T[a.Length]; Sort(a, aux, 0, a.Length - 1); Debug.Assert(IsSorted(a)); } /// <summary> /// 自顶向下地对数组指定范围内进行三向归并排序，需要辅助数组。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">排序范围起点。</param> /// <param name="hi">排序范围终点。</param> private void Sort<T>(T[] a, T[] aux, int lo, int hi) where T : IComparable<T> { if (hi <= lo) // 小于或等于一个元素 return; int lmid = lo + (hi - lo) / 3; int rmid = hi - (hi - lo) / 3; Sort(a, aux, lo, lmid); Sort(a, aux, lmid + 1, rmid); Sort(a, aux, rmid + 1, hi); Merge(a, aux, lo, lmid, rmid, hi); } /// <summary> /// 返回两个元素中较小的那个。 /// </summary> /// <typeparam name="T">比较的元素类型。</typeparam> /// <param name="a">用于比较的元素。</param> /// <param name="b">用于比较的元素。</param> /// <returns>较小的元素。</returns> private T Min<T>(T a, T b) where T : IComparable<T> { if (Less(a, b)) return a; return b; } /// <summary> /// 将指定范围内的元素归并。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">范围起点。</param> /// <param name="lmid">范围三分之一点。</param> /// <param name="rmid">范围三分之二点。</param> /// <param name="hi">范围终点。</param> private void Merge<T>(T[] a, T[] aux, int lo, int lmid, int rmid, int hi) where T : IComparable<T> { for (int l = lo; l <= hi; l++) { aux[l] = a[l]; } int i = lo, j = lmid + 1, k = rmid + 1; for (int l = lo; l <= hi; l++) { int flag = 0; if (i > lmid) flag += 1; if (j > rmid) flag += 10; if (k > hi) flag += 100; switch (flag) { case 0: // 三个数组都还没有取完 T min = Min(aux[i], Min(aux[j], aux[k])); if (min.Equals(aux[i])) a[l] = aux[i++]; else if (min.Equals(aux[j])) a[l] = aux[j++]; else a[l] = aux[k++]; break; case 1: // 只有第一个数组取完了 if (Less(aux[j], aux[k])) a[l] = aux[j++]; else a[l] = aux[k++]; break; case 10: // 只有第二个数组取完了 if (Less(aux[i], aux[k])) a[l] = aux[i++]; else a[l] = aux[k++]; break; case 100: // 只有第三个数组取完了 if (Less(aux[i], aux[j])) a[l] = aux[i++]; else a[l] = aux[j++]; break; case 11: // 第一、二个数组取完了 a[l] = aux[k++]; break; case 101: // 第一、三个数组取完了 a[l] = aux[j++]; break; case 110: // 第二、三个数组取完了 a[l] = aux[i++]; break; } } } } }
2.2.23
题目
改进。
用实验评估正文中所提到的归并排序的三项改进（请见练习 2.2.11）的效果，
并比较正文中实现的归并排序和练习 2.2.10 所实现的归并排序之间的性能。
根据经验给出应该在何时为子数组切换到插入排序。
解答
阈值合适时，大约会有10%的性能提升。
阈值在 10 以下都是比较合适的。
代码
using System; using Merge; namespace _2._2._23 { /* * 2.2.23 * * 改进。 * 用实验评估正文中所提到的归并排序的三项改进（请见练习 2.2.11）的效果， * 并比较正文中实现的归并排序和练习 2.2.10 所实现的归并排序之间的性能。 * 根据经验给出应该在何时为子数组切换到插入排序。 * */ class Program { static void Main(string[] args) { MergeSort mergeSort = new MergeSort(); MergeSortX mergeSortX = new MergeSortX(); MergeSortUnstable mergeSortUnstable = new MergeSortUnstable(); int n = 1000000; int cutoff = 2; int trialTime = 4; Console.WriteLine("归并排序改进前与改进后的比较："); Console.WriteLine("数组\t耗时1\t耗时2\t阈值\t比率"); for (int i = 0; i < 20; i++) { double mergeSortTime = 0; double mergeSortXTime = 0; mergeSortX.SetCutOff(cutoff); for (int j = 0; j < trialTime; j++) { int[] a = SortCompare.GetRandomArrayInt(n); int[] b = new int[a.Length]; a.CopyTo(b, 0); mergeSortTime += SortCompare.Time(mergeSort, a); mergeSortXTime += SortCompare.Time(mergeSortX, b); } mergeSortTime /= trialTime; mergeSortXTime /= trialTime; Console.WriteLine(n + "\t" + mergeSortTime + "\t" + mergeSortXTime + "\t" + cutoff + "\t" + mergeSortTime / mergeSortXTime); cutoff++; } n = 100000; Console.WriteLine("稳定归并排序与不稳定版本的比较："); Console.WriteLine("数组\t耗时1\t耗时2\t比率"); for (int i = 0; i < 6; i++) { double mergeSortTime = 0; double mergeSortUnstableTime = 0; for (int j = 0; j < trialTime; j++) { int[] a = SortCompare.GetRandomArrayInt(n); int[] b = new int[a.Length]; a.CopyTo(b, 0); mergeSortTime += SortCompare.Time(mergeSort, a); mergeSortUnstableTime += SortCompare.Time(mergeSortUnstable, b); } mergeSortTime /= trialTime; mergeSortUnstableTime /= trialTime; Console.WriteLine(n + "\t" + mergeSortTime + "\t" + mergeSortUnstableTime + "\t" + mergeSortTime / mergeSortUnstableTime); n *= 2; } } } }
2.2.24
题目
改进的有序测试。
在实验中用大型随机数组评估练习 2.2.8 所做的修改的效果。
根据经验用 N（被排序的原始数组的大小）的函数描述条件语句（a[mid] <= a[mid + 1]）成立（无论数组是否有序）的次数。
解答
约为 lgN 次
代码
using System; using Merge; namespace _2._2._24 { /* * 2.2.24 * * 改进的有序测试。 * 在实验中用大型随机数组评估练习 2.2.8 所做的修改的效果。 * 根据经验用 N（被排序的原始数组的大小）的函数描述条件语句 * （a[mid] <= a[mid + 1]）成立（无论数组是否有序）的次数。 * */ class Program { static void Main(string[] args) { MergeSortX mergeSortX = new MergeSortX(); int n = 10000; int trialTimes = 10; Console.WriteLine("数组\t平均命中次数"); for (int i = 0; i < 4; i++) { int avgHit = 0; for (int j = 0; j < trialTimes; j++) { mergeSortX.ResetHitTime(); int[] a = SortCompare.GetRandomArrayInt(n); mergeSortX.Sort(a); avgHit += mergeSortX.GetHitTime(); } Console.WriteLine(n + "\t" + avgHit / trialTimes); n *= 10; } } } }
2.2.25
题目
多向归并排序。
实现一个 k 向（相对双向而言）归并排序程序。
分析你的算法，估计最佳的 k 值并通过实验验证猜想。
解答
事实上 k 的取值无关紧要，实验也证明了这一点。
算法大致可以分为以下几个步骤
首先将数组划为 k 份，用一个数组 mids 记录这 k 个子数组的分割位置
随后递归的调用 Sort 方法，将这 k 个子数组排序
随后将这 k 个子数组归并，
每次归并时遍历取 k 个子数组中值最小的一个，然后对应子数组的指示器 + 1
上面这一步是 O(k) 的，可以用堆或者败者树优化为对数级别
代码
using System; using System.Diagnostics; namespace Merge { /// <summary> /// k 路归并排序。 /// </summary> public class MergeSortKWay : BaseSort { /// <summary> /// 同时归并的数组数目。 /// </summary> public int K { get; set; } /// <summary> /// 默认构造函数。 /// </summary> public MergeSortKWay() { this.K = 2; } /// <summary> /// 用 k 向归并排序对数组 a 进行排序。 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="a"></param> /// <exception cref="ArgumentOutOfRangeException">数组长度小于 K 值时抛出异常。</exception> public override void Sort<T>(T[] a) { if (this.K > a.Length) throw new ArgumentOutOfRangeException("数组长度不能小于 K 值！"); T[] aux = new T[a.Length]; Sort(a, aux, 0, a.Length - 1); Debug.Assert(IsSorted(a)); } /// <summary> /// 自顶向下地对数组指定范围内进行 k 向归并排序，需要辅助数组。 /// </summary> /// <typeparam name="T">需要排序的元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">排序范围起点。</param> /// <param name="hi">排序范围终点。</param> private void Sort<T>(T[] a, T[] aux, int lo, int hi) where T : IComparable<T> { if (hi <= lo) // 小于或等于一个元素 return; int[] mids = new int[this.K - 1]; int steps = (hi - lo) / this.K; mids[0] = lo + steps; for (int i = 1; i < this.K - 1; i++) { mids[i] = mids[i - 1] + steps; if (mids[i] > hi) // 防止溢出 mids[i] = hi; } Sort(a, aux, lo, mids[0]); for (int i = 1; i < this.K - 1; i++) { Sort(a, aux, mids[i - 1] + 1, mids[i]); } Sort(a, aux, mids[this.K - 2] + 1, hi); Merge(a, aux, lo, mids, hi); } /// <summary> /// 将指定范围内的元素归并。 /// </summary> /// <typeparam name="T">数组元素类型。</typeparam> /// <param name="a">原数组。</param> /// <param name="aux">辅助数组。</param> /// <param name="lo">范围起点。</param> /// <param name="mids">范围中间点。</param> /// <param name="hi">范围终点。</param> private void Merge<T>(T[] a, T[] aux, int lo, int[] mids, int hi) where T : IComparable<T> { for (int l = lo; l <= hi; l++) { aux[l] = a[l]; } int[] pointers = new int[this.K]; // 标记每个数组的当前归并位置 pointers[0] = lo; // 开始时归并位置处于每个子数组的起始 for (int i = 1; i < this.K; i++) { pointers[i] = mids[i - 1] + 1; } // 开始归并 for (int i = lo; i <= hi; i++) { // 找到最小值 T min; int minPointerIndex = 0; bool isInit = true; if (pointers[this.K - 1] > hi) { min = default(T); // 初始化以避免编译错误 } else { min = aux[pointers[this.K - 1]]; minPointerIndex = this.K - 1; isInit = false; } for (int j = 0; j < this.K - 1; j++) { if (pointers[j] > mids[j]) // 当前数组已经用完 continue; if (isInit) // 第一次赋值 { isInit = false; min = aux[pointers[j]]; minPointerIndex = j; continue; } if (Less(aux[pointers[j]], min)) { min = aux[pointers[j]]; minPointerIndex = j; } } // 将最小值赋给归并数组，对应子数组的归并位置+1 a[i] = min; pointers[minPointerIndex]++; } } } }
2.2.26
题目
创建数组。使用 SortCompare 粗略比较在你的计算机上在 merge() 中和在 sort() 中创建 aux[] 的性能差异。
解答
差距还是比较明显的，由于 Merge 会调用多次，而用于启动递归的 Sort 方法只会调用一次。
代码
using System; using Merge; namespace _2._2._26 { /* * 2.2.26 * * 创建数组。 * 使用 SortCompare 粗略比较在你的计算机上 * 在 merge() 中和在 sort() 中创建 aux[] 的性能差异。 * */ class Program { static void Main(string[] args) { AuxInSortMergeSort auxInSort = new AuxInSortMergeSort(); AuxInMergeMergeSort auxInMerge = new AuxInMergeMergeSort(); int[] data1 = SortCompare.GetRandomArrayInt(100000); int[] data2 = new int[data1.Length]; data1.CopyTo(data2, 0); Console.WriteLine("在Sort中创建aux[]\t" + SortCompare.Time(auxInSort, data1) + "ms"); Console.WriteLine("在Merge中创建aux[]\t" + SortCompare.Time(auxInMerge, data2) + "ms"); } } }
2.2.27
题目
子数组长度。
用归并将大型随机数组排序，
根据经验用 N （某次归并时两个子数组的长度之和）的函数估计当一个子数组用尽时另一个子数组的平均长度。
解答
大致上会是一个对数函数，用 Excel 做了简单的拟合。
代码
using System; using Merge; namespace _2._2._27 { /* * 2.2.27 * * 子数组长度。 * 用归并将大型随机数组排序， * 根据经验用 N （某次归并时两个子数组的长度之和） * 的函数估计当一个子数组用尽时另一个子数组的平均长度。 * */ class Program { static void Main(string[] args) { int arraySize = 1000000; NotifiedMergeSort sort = new NotifiedMergeSort(arraySize); for (int i = 0; i < 100; i++) { int[] data = SortCompare.GetRandomArrayInt(arraySize); sort.Sort(data); } Console.WriteLine("n\trest\ttimes"); for (int i = 0; i < sort.NArraySize.Length; i++) { if (sort.NArraySize[i] != 0) Console.WriteLine(i + "\t" + sort.NArraySize[i] / sort.NArraySizeTime[i] + "\t" + sort.NArraySizeTime[i]); } // 大致上是一个对数函数 } } }
2.2.28
题目
自顶向下和自底向上。
对于 N=10^3、10^4、10^5 和 10^6，
使用 SortCompare 比较自顶向下和自底向上的归并排序的性能。
解答
自底向上会快一些，省去了递归过程中函数重复调用的时间。
代码
using System; using Merge; namespace _2._2._28 { /* * 2.2.28 * * 自顶向下和自底向上。 * 对于 N=10^3、10^4、10^5 和 10^6， * 使用 SortCompare 比较自顶向下和自底向上的归并排序的性能。 * */ class Program { static void Main(string[] args) { int n = 1000; MergeSort topBottomMergeSort = new MergeSort(); MergeSortBU bottomUpMergeSort = new MergeSortBU(); int trialTimes = 100; for (int i = 0; i < 4; i++) { Console.Write("数组大小：" + n + "\t"); int time1 = 0, time2 = 0; for (int j = 0; j < trialTimes; j++) { double[] data1 = SortCompare.GetRandomArrayDouble(n); double[] data2 = new double[n]; data1.CopyTo(data2, 0); time1 += (int)SortCompare.Time(topBottomMergeSort, data1); time2 += (int)SortCompare.Time(bottomUpMergeSort, data2); } Console.WriteLine("自顶向下：" + time1 / trialTimes + "ms\t自底向上：" + time2 / trialTimes + "ms"); n *= 10; } } } }
2.2.29
题目
自然的归并排序。对于 N=10^3、10^6 和 10^9，类型为 Long 的随机主键数组，根据经验给出自然的归并排序（请见练习 2.2.16）所需要的遍数。
提示：不需要实现这个排序（甚至不需要生成所有完整的 64 位主键）也能完成这道练习。
解答
完全有序时只需要一次归并（直接输出），
逆序时需要 n - 1 次归并（退化为插入排序），
平均需要 n/2 次归并。
所以分别需要 500，500000，500000000 次归并。