摘要：
2.3.22快速三向切分。（J.Bently,D.McIlroy)用将重复元素放置于子数组两端的方式实现一个信息量最优的排序算法。使用两个索引p和q，使得a[lo..p-1]和a[q+1..hi]的元素都和a[lo]相等。使用另外两个索引i和j,使用a[p..i-1]小于a[lo],a[j+1..q 阅读全文
posted @ 2018-10-27 10:03
修电脑的龙生
阅读(847)
评论(1)
推荐(0)
摘要：
2.3.21重复元素排序的比较次数下界。完成命题M的证明的第一部分。参考命题I的证明并注意当有k个主键值时所有元素存在N!/f1!f2!...fk!种不同的排列，其中第i个主键值出现的频率为fi(即NPi,按照命题M的记法),且f1+...fk=N。答：命题M。不存在任何基于比较的排序算法能够保证在 阅读全文
posted @ 2018-10-27 10:02
修电脑的龙生
阅读(385)
评论(0)
推荐(0)
摘要：
2.3.20非递归的快速排序。实现一个非递归的快速排序，使用一个循环来将弹出栈的子数组切分并将结果子数组重新压入栈。注意：先将较大的子数组压入栈，这样就可以保证栈最多只会有lgN个元素。public class E2d3d20{ //一个用记录子数组开始与结束索引的类 private class A 阅读全文
posted @ 2018-10-27 10:00
修电脑的龙生
阅读(276)
评论(0)
推荐(0)
摘要：
2.3.19附加题：找到一种对于任意输入都只需要少于7次比较的五取样算法。答：设有5个数,a,b,c,d,e，若这5个数有序，那么中位数为c,c的特点是它只大于两个数。设a,b,c,d,e为任意排列情况，按下面的步骤可以在6次比较时得到中位数1）用d与e比较，当d>e时，交换d,e得到d<e。2) 阅读全文
posted @ 2018-10-27 09:59
修电脑的龙生
阅读(371)
评论(0)
推荐(0)
摘要：
2.3.19五取样切分。实现一种基于随机抽取子数组中5个元素并取中位数进行切分的快速排序。将取样元素放在数组的一侧以保证只有中位数元素参与了切分。运行双倍测试来确定这样改动的效果，并和标准的快速排序以及三取样切分的快速排序(请见上一道练习)进行比较。附加题：找到一种对于任意输入都只需要少于7次比较的 阅读全文
posted @ 2018-10-27 09:56
修电脑的龙生
阅读(394)
评论(0)
推荐(0)
摘要：
2.3.18三取样切分。为快速排序实现正文所述的三取样切分(参见2.3.3.2节)。运行双倍测试来确认这项改动的效果。public class E2d3d18{ public static void sort(Comparable[] a) { StdRandom.shuffle(a); sort( 阅读全文
posted @ 2018-10-27 09:55
修电脑的龙生
阅读(851)
评论(0)
推荐(1)
摘要：
2.3.17哨兵。修改算法2.5，去掉内循环while中的边界检查。由于切分元素本身就是一个哨兵(v不可能小于a[lo]),左侧边界的检查是多余的。要去掉另一个检查，可以在打乱数组后将数组的最大元素放在a[length-1]中。该元素永远不会移动(除非和相等的元素交换），可以在所有包含它的子数组中成 阅读全文
posted @ 2018-10-27 09:54
修电脑的龙生
阅读(589)
评论(0)
推荐(0)
摘要：
2.3.16最佳情况。编写一段程序来生成使算法2.5中的sort()方法表现最佳的数组(无重复无素）:数组大小为N且不包含重复元素，每次切分后两个子数组的大小最多差1(子数组的大小与含有N个相同元素数组的切分情况相同)。(对于这道练习，我们不需要在排序开始时打乱数组。）以下练习描述了快速排序的几个变 阅读全文
posted @ 2018-10-27 09:52
修电脑的龙生
阅读(430)
评论(0)
推荐(0)
摘要：
2.3.15螺丝和螺帽。(G.J.E.Rawlins)假设有N个螺丝和N个螺帽混在一堆，你需要快速将它们配对。一个螺丝只会匹配一个螺帽，一个螺帽也只会匹配一个螺丝。你可以试着把一个螺丝和一个螺帽拧在一起看看谁大，但不能直接比较两个螺丝或者两个螺帽。给出一个解决这个问题的有效方法。1) 将螺丝与螺帽分 阅读全文
posted @ 2018-10-27 09:50
修电脑的龙生
阅读(496)
评论(0)
推荐(0)
摘要：
2.3.14证明在用快速排序处理大小为N的不重复数组时，比较第i大和第j大元素的概率为2/(j-i),并用该结论证明命题K。 证：设数组子集Zij={Zi,Zi+1,Zi+2,....Zj}并且Zi<Zi+1<Zi+2<...<Zj。 由于元素只与切分元素进行对比 1)当切分元素V为Zi+1...至 阅读全文
posted @ 2018-10-27 09:49
修电脑的龙生
阅读(429)
评论(0)
推荐(0)
摘要：
2.3.12按照代码所示轨迹的格式给出信息量最佳的快速排序第一次是如何切分数组BABABABACADABRA的。答：即为Dijkstra三向切分快速排序的轨迹， 这种方式在大交换时可能会出现大值与大值交换的情况，这样又会多一次交换。 2.3.12按照代码所示轨迹的格式给出信息量最佳的快速排序第一次是 阅读全文
posted @ 2018-10-27 09:46
修电脑的龙生
阅读(233)
评论(0)
推荐(0)
摘要：
2.3.13在最佳、平均和最坏情况下，快速排序的递归深度分别是多少？这决定了系统为了追踪递归调用所需的栈的大小。在最坏情况下保证递归深度为数组大小的对数级的方法请见练习2.3.20。答：令排序数组长度为n1)最佳情况下，每次切分都能使左右子数组长度相同，递归深度为lgN。2)平均情况下，递归深度为l 阅读全文
posted @ 2018-10-27 09:46
修电脑的龙生
阅读(1366)
评论(0)
推荐(0)
摘要：
2.3.11假如在遇到和切分元素重复的元素时我们继续扫描数组而不是停下来，证明使用这种方法的快速排序在处理只有若干种元素值的数组时的运行时间是平方级别的。答：在有重复元素的情况下，一轮比较与交换后，与切分元素同值的元素仍就保持在原有位置，切分元素移动到分界位置，得到的排序结果为左子数组<=切分元素< 阅读全文
posted @ 2018-10-27 09:45
修电脑的龙生
阅读(477)
评论(0)
推荐(0)
摘要：
2.3.10Chebyshev不等式表明，一个随机变量的标准差距离均值大于k的概率小于1/k^2。对于N=100万，用Chebyshev不等式计算快速排序所使用的比较次数大于1000亿次的概率(0.1N^2)。答：4.225*10^-9切比雪夫不等式：P(|X-E(X)|>=r)<=V(X)/r^2 阅读全文
posted @ 2018-10-27 09:43
修电脑的龙生
阅读(237)
评论(0)
推荐(0)
摘要：
2.3.9请说明Quick.sort()在处理只有两种主键值的数组时的行为，以及在处理只有三种主键值的数组时的行为。1）两种主键值时1.1)小元素作为分界元素，子数组剩余的元素两端也是小元素时，会进行一次交换，这是不必要的交换,这个在有重复值时也会出现这种不必要的交换。1.2)大元素作为分界元素，子 阅读全文
posted @ 2018-10-27 09:40
修电脑的龙生
阅读(431)
评论(0)
推荐(0)
摘要：
2.3.8Quick.sort()在处理N个全部重复的元素时大约需要多少次比较？答：N(lgN-1)-lgN，一个更精确试验数据是：N(lgN-1)+2,目前没法分析出这个结果。1）对于每个元素个数大于1的子数组，数组的第一个元素作为分界元素，然后从第二个元素和最后一个元素开始向中间移动，当左右两指 阅读全文
posted @ 2018-10-27 09:39
修电脑的龙生
阅读(646)
评论(0)
推荐(0)
摘要：
2.3.6编写一段代码来计算Cn的准确值，在N=100、1000和1000的情况下比较准确值和估计值2NlnN的差距。public class E2d3d6{ static int Cn=0; public static void sort(Comparable[] a) { Cn=0; StdRa 阅读全文
posted @ 2018-10-27 09:38
修电脑的龙生
阅读(390)
评论(0)
推荐(0)
摘要：
2.3.7在使用快速排序将N个不重复的元素排序时,计算大小为0、1和2的子数组的数量。如果你喜欢数学，请推导;如果你不喜欢，请做一些实验并提出猜想。答：设使用快速排序的数组长度为N。将数组一分为二时之前的分界元素不在这两个子数组中，所以两个子数组的总长度为N-1。归纳得出第i层的所有子数组中的元素总 阅读全文
posted @ 2018-10-27 09:38
修电脑的龙生
阅读(297)
评论(0)
推荐(0)
摘要：
2.3.4假如跳过开头打乱数组的操作，给出六个含有10个元素的数组，使得Quck.sort()所需的比较次数到达最坏情况。答：有最多次比较，就要求每次切分后的左子数组 或 右子数组最长，也就是左子数组为空 或 右子数组为空。这样的排列满足关系式V1<V2<V3…<Vn 或 V1>V2>V3…>Vn 阅读全文
posted @ 2018-10-27 09:36
修电脑的龙生
阅读(615)
评论(0)
推荐(0)
摘要：
1）从数组两端向中间找到第一对不同的值，然后将大值作为分界值。2）从数组两端向中间找，左端找到等于大值时停止找，右端找到小于大值时停止找。3）交换上面找到的两个值。4）如此反复第2、第3步，直到中间相遇时结束。注意：如果数据只有一种值时，代码不能正确运行。public class E2d3d5{ p 阅读全文
posted @ 2018-10-27 09:36
修电脑的龙生
阅读(719)
评论(0)
推荐(0)
摘要：
2.3.3对于长度为N的数组，在Quick.sort()执行时，其最大的元素最多会被交换多少次?答：1）上取整((N-1)/2)次。2）为便于描述，令v为切分元素，M为最大元素。由于M在每一次切分时都将从参与切分的子数组的左边交换到右边，那么切分次数越多M被交换的次数也越多。要完成最多次的切分就需要 阅读全文
posted @ 2018-10-27 09:35
修电脑的龙生
阅读(1515)
评论(0)
推荐(0)
摘要：
2.3.2按照本节中快速排序所示轨迹的格式给出快速排序是如何将数组E A S Y Q U E S T I O N排序的(出于练习的目的，可以忽略开头打乱数组的部分)。 阅读全文
posted @ 2018-10-27 09:34
修电脑的龙生
阅读(485)
评论(0)
推荐(0)
摘要：
黄色单元格表示元素交换。 黄色单元格表示元素交换。 黄色单元格表示元素交换。 阅读全文
posted @ 2018-10-27 09:33
修电脑的龙生
阅读(177)
评论(0)
推荐(0)
摘要：
2.3.1按照partition()方法的轨迹的格式给出该方法是如何切分数组E A S Y Q U E S T I O N的。 阅读全文
posted @ 2018-10-27 09:33
修电脑的龙生
阅读(506)
评论(0)
推荐(0)
摘要：
2.2.28自顶向下与自底向上。对于N=10^3、10^4、10^5和10^6，使用SortCompare比较自顶向下和自底向上的归并排序的性能。import java.util.Arrays;public class E2d2d28{ public static double time (Stri 阅读全文
posted @ 2018-10-27 09:32
修电脑的龙生
阅读(151)
评论(0)
推荐(0)
摘要：
2.2.29自然的归并排序。对于N=10^3、10^6和10^9，类型为Long的随机主键数组，根据经验给出自然的归并排序（请见练习2.2.16)所需要的遍数。提示：不需要实现这个排序（甚至不需要生成所有完整的64位主键)也能完成这道练习。 阅读全文
posted @ 2018-10-27 09:32
修电脑的龙生
阅读(126)
评论(0)
推荐(0)
摘要：
2.2.27子数组长度。用归并将大型随机数组排序，根据经验用N(某次归并时两个子数组的长度之和)的函数估计当一个子数组用尽时另一个子数组的平均长度。public class E2d2d27{ private static Comparable[] aux; public static long su 阅读全文
posted @ 2018-10-27 09:30
修电脑的龙生
阅读(195)
评论(0)
推荐(0)
摘要：
2.2.26创建数组。使用SortCompare粗略比较在你的计算机上在merge()中和在sort()中创建aux[]的性能差异。public class E2d2d26d3{ public static double time (String alg,Double[] a) { Stopwatc 阅读全文
posted @ 2018-10-27 09:29
修电脑的龙生
阅读(182)
评论(0)
推荐(0)
摘要：
2.2.25多向归并排序。实现一个k向(相对双向而言)归并排序程序。分析你的算法，估计最佳的k值并通过实验验证猜想。试验50万至5百万个随机double试验后，得出最佳k值为：4~9的数。代码可进一步改进的地方是在k个值中找出最小数的部分，目前采用遍历k个值，第二轮时仍就遍历k个值，没能利用到上一轮 阅读全文
posted @ 2018-10-27 09:24
修电脑的龙生
阅读(304)
评论(0)
推荐(0)
摘要：
2.2.25多向归并排序。实现一个k向(相对双向而言)归并排序程序。分析你的算法，估计最佳的k值并通过实验验证猜想。第一版代码:public class E2d2d25{ private static Comparable[] aux; public static void sort(Compara 阅读全文
posted @ 2018-10-27 09:23
修电脑的龙生
阅读(188)
评论(0)
推荐(0)
摘要：
2.2.25多向归并排序。实现一个k向(相对双向而言)归并排序程序。分析你的算法，估计最佳的k值并通过实验验证猜想。在第一版的基础上为减少检查子数组是否已结束时的对比，做的微小改进。public class E2d2d25d2{ private static Comparable[] aux; pu 阅读全文
posted @ 2018-10-27 09:23
修电脑的龙生
阅读(258)
评论(0)
推荐(0)
摘要：
2.2.24改进的有序测试。在实现中用大型随机数组评估练习2.2.8所做的修改的效果。根据经验用N(被排序的原始数组的大小)的函数描述条件语句(a[mid]<=a[mid+1])成立(无论数组是否有序)的平均次数。约：0.288N。public class E2d2d24{ private stat 阅读全文
posted @ 2018-10-27 09:22
修电脑的龙生
阅读(176)
评论(0)
推荐(0)
摘要：
2.2.23改进。用实验评估正文中所提到的归并排序的三项改进(请见练习2.2.11)的效果，并比较正文中实现的归并和练习2.2.10所实现的归并之间的性能。根据经验给出应该在何时为子数组切换到插入排序。2)比较正文中实现的归并和反向复制辅助数组归并之间的性能(练习2.2.10)public clas 阅读全文
posted @ 2018-10-27 09:21
修电脑的龙生
阅读(141)
评论(0)
推荐(0)
摘要：
2.2.23改进。用实验评估正文中所提到的归并排序的三项改进(请见练习2.2.11)的效果，并比较正文中实现的归并和练习2.2.10所实现的归并之间的性能。根据经验给出应该在何时为子数组切换到插入排序。3)根据经验给出应该在何时为子数组切换到插入排序。依据下图的试验结果，得出子数组长度在16至18时 阅读全文
posted @ 2018-10-27 09:21
修电脑的龙生
阅读(161)
评论(0)
推荐(0)
摘要：
2.2.23改进。用实验评估正文中所提到的归并排序的三项改进(请见练习2.2.11)的效果，并比较正文中实现的归并和练习2.2.10所实现的归并之间的性能。根据经验给出应该在何时为子数组切换到插入排序。1)用实验评估正文中所提到的归并排序与三项改进(请见练习2.2.11)的效果。通过以下实验得出，三 阅读全文
posted @ 2018-10-27 09:20
修电脑的龙生
阅读(204)
评论(0)
推荐(0)
摘要：
2.2.22三向归并排序。假设每次我们是把数组分成三个部分而不是两个部分并将它们分别排序，然后进行三向归并。这种算法的运行时间的增长数量级是多少？运算时间增长数量级是O(Nlg3N)。public class E2d2d22{ public static void sort(Comparable[] 阅读全文
posted @ 2018-10-27 09:19
修电脑的龙生
阅读(359)
评论(0)
推荐(0)
摘要：
2.2.21一式三份。给定三个列表，每个列表中包含N个名字，编写一个线性对数级别的算法来判定三份列表中是否含有公共的名字，如果有，返回第一个被找到了这种名字。算法：1)先将三个列表使用归并排序方法排序，形成小元素在前，大元素在后的排列。排序需要O(NlgN)时间复杂度。2)当三个列表的最顶元素相同时 阅读全文
posted @ 2018-10-27 09:18
修电脑的龙生
阅读(297)
评论(0)
推荐(0)
摘要：
2.2.19倒置。编写一个线性对数级别的算法统计给定数组中的"倒置"数量(即插入排序所需的交换次数,请见2.1节)。这个数量和Kendall tau距离有关，请见2.5节。答：参考资料：https://en.wikipedia.org/wiki/Kendall_tau_distance1)Kenda 阅读全文
posted @ 2018-10-27 09:17
修电脑的龙生
阅读(232)
评论(0)
推荐(0)
摘要：
2.2.20间接排序。编写一个不改变数组的归并排序，它返回一个int[]数组perm,其中perm[i]的值是原数组中第i小的元素的位置。public class E2d2d20{ private static int subArrayLenTrunONInsertionSort=15; publi 阅读全文
posted @ 2018-10-27 09:17
修电脑的龙生
阅读(221)
评论(0)
推荐(0)
摘要：
2.2.18打乱链表。实现一个分治算法，使用线性对数级别的时间和对数级别的额外空间随机打乱一条链表。2.2.18 Shuffling a linked list. Develop and implement a divide-and-conquer algorithmthat randomly sh 阅读全文
posted @ 2018-10-27 09:16
修电脑的龙生
阅读(443)
评论(0)
推荐(0)
摘要：
2.2.16自然的归并排序。编写一个自底向上的归并排序，当需要将两个子数组排序时能够利用数组中已经有序的部分。首先找到一个有序的子数组(移动指针直到当前元素比上一个元素小为止)，然后再找出另一个并将它们归并。根据数组大小和数组中递增子数组的最大长度分析算法的运行时间。import java.util 阅读全文
posted @ 2018-10-27 09:15
修电脑的龙生
阅读(326)
评论(0)
推荐(0)
摘要：
2.2.17链表排序。实现对链表的自然排序(这是将链表排序的最佳方法，因为它不需要额外的空间，且运行时间是线性对数级别的)。线性单链表自底向上自然归并排序算法:1)如果链表长度为0或1时排序完成。2)链表长度大于1时需要进行归并排序。2.1)最开始将first作为开始结点查找出sp,hi结点.2.2 阅读全文
posted @ 2018-10-27 09:15
修电脑的龙生
阅读(429)
评论(0)
推荐(0)
摘要：
2.2.15自底向上的有序队列归并排序。用下面的方法编写一个自底向上的归并排序：给定N个元素，创建N个队列，每个队列包含其中一个元素。创建一个由这N个队列组成的队列，然后不断用练习2.2.14中的方法将队列的头两个元素归并，并将幸福空间要重新加入到队列结尾，直到队列的队列只剩下一个元素为止。impo 阅读全文
posted @ 2018-10-27 09:13
修电脑的龙生
阅读(303)
评论(0)
推荐(0)
摘要：
2.2.14归并有序的队列。编写一个静态方法，将两个有序的队列作为参数，返回一个归并后的有序队列。答：1)队1,队2均为0长队列时返回一个0长队列.2)队1长度大于0,队2为0时返回队1.3)队1长度为0,队2长度大于0时返回队2.4)队1,队2长度均大于0时 4.1)队1,队2分别出列q1Item 阅读全文
posted @ 2018-10-27 09:12
修电脑的龙生
阅读(327)
评论(0)
推荐(0)
摘要：
2.2.13平均情况的下限。请证明任意基于比较的排序算法的预期比较次数至少为~NlgN(假设输入元素的所有排列的出现概率是均等的)。提示：比较次数至少是比较树的外部路径的长度(根结点到所有叶子结点的路径长度之和)，当树平衡时该值最小。答：1)平均比较次数=总的比较次数/排列数2)N个输入元素，排列数 阅读全文
posted @ 2018-10-27 09:11
修电脑的龙生
阅读(238)
评论(0)
推荐(0)
摘要：
2.2.11改进。实现2.2.2节所述的对归并排序的三项改进：加快小数组的排序速度，检测数组是否已经有序以及通过在递归中交换参数来避免数组复制。答：归并排序的本质是由两部分组成，一是排序，二是归并。1）对小数组的排序均发生在a数组中，如果连续对两个小数组进行排序，那么只可能归并到aux，属于a+a- 阅读全文
posted @ 2018-10-27 09:10
修电脑的龙生
阅读(360)
评论(0)
推荐(0)
摘要：
2.2.12次线性的额外空间。用大小M将数组分为N/M块(简单起见，设M是N的约数)。实现一个归并方法，使之所需的额外空间减少到max(M,N/M):(i)可以先将一个块看做一个元素，将块的第一个元素作为块的主键，用选择排序将块排序;(ii)遍历数组，将第一块和第二块归并，完成后将第二块和第三块归并 阅读全文
posted @ 2018-10-27 09:10
修电脑的龙生
阅读(509)
评论(0)
推荐(0)
摘要：
2.2.11改进。实现2.2.2节所述的对归并排序的三项改进：加快小数组的排序速度，检测数组是否已经有序以及通过在递归中交换参数来避免数组复制。public class Merge5{ private static int subArrayLenTrunONInsertionSort=15; pub 阅读全文
posted @ 2018-10-27 09:09
修电脑的龙生
阅读(406)
评论(0)
推荐(0)
摘要：
2.2.9在库函数中使用aux[]这样的静态数组是不妥当的，因为可能会有多个程序同时使用这个类。实现一个不用静态数组的Merge类，但也不要将aux[]变为merge()的局部变量(请见本节的答疑部分)。提示：可以将辅助数组作为参数传递给递归的sort()方法。import java.util.Ar 阅读全文
posted @ 2018-10-27 09:08
修电脑的龙生
阅读(320)
评论(0)
推荐(0)
摘要：
2.2.10快速归并。实现一个merge()方法，按降序将a[]的后半部分复制到aux[]，然后将其归并回a[]中。这样就可以去掉内循环中检测某半边是否用尽的代码。注意：这样的排序产生的结果是不稳定的(请见2.5.1.8节)。public class Merge2{ private static C 阅读全文
posted @ 2018-10-27 09:08
修电脑的龙生
阅读(291)
评论(0)
推荐(0)
摘要：
2.2.7证明归并排序的比较次数是单调递增的(即对于N>0,C(N+1)>C(N))。证：由命题F得出数组长度为N时比较次数为C(N)=NlgN,当数组长度为N+1时比较次数为C(N+1)=NlgN，由于N+1>N,所以有lg(N+1)>lg(N),所以有C(N+1)=(N+1)lg(N+1)>Nl 阅读全文
posted @ 2018-10-27 09:07
修电脑的龙生
阅读(353)
评论(0)
推荐(0)
摘要：
2.2.8假设将算法2.4修改为：只要a[mid]<=a[mid+1]就不调用merge()方法，请证明用归并排序处理一个已经有序的数组所需的比较次数是线性级别的。public static void sort(Comparable[] a,int lo,int hi) { if (hi<=lo) 阅读全文
posted @ 2018-10-27 09:07
修电脑的龙生
阅读(271)
评论(0)
推荐(0)
摘要：
2.2.5当输入数组的大小N=39时，给出自顶向下和自底向上的归并排序中各次归并子数组的大小及顺序。1)自顶向下归并排序时归并的子数组的开始索引，结束索引，子数组长度如下:0,1,20,2,33,4,20,4,55,6,25,7,38,9,25,9,50,9,1010,11,210,12,313,1 阅读全文
posted @ 2018-10-27 09:06
修电脑的龙生
阅读(546)
评论(0)
推荐(0)
摘要：
2.2.6编写一个程序来计算自顶向下和自底向上的归并排序访问数组的准确次数。使用这个程序将N=1至512的结果绘制成曲线图，并将其和上限6NlgN比较。说明：Red线是6NlgN 、Green线是自顶向下、Blue线是自底向上。public class Merge{ private static C 阅读全文
posted @ 2018-10-27 09:06
修电脑的龙生
阅读(402)
评论(0)
推荐(0)
摘要：
2.2.3用自底向上的归并排序解答练习2.2.2。 阅读全文
posted @ 2018-10-27 09:05
修电脑的龙生
阅读(271)
评论(0)
推荐(0)
摘要：
2.2.4是否当且仅当两个输入的子数组都有序时原地归并的抽象方法才能得到正确的结果?证明你的结论，或者给出一个反例。答：是的。证明：归并前一个输入子数组中的元素索引前后相对位置在归并后不会发生改变，例如归并前子数组1中的元素次序为a1,a2,a3...an,那么在归并后仍就会是a1...a2...a 阅读全文
posted @ 2018-10-27 09:05
修电脑的龙生
阅读(468)
评论(0)
推荐(0)
摘要：
2.2.1按照本节开头所示轨迹的格式给出原地归并的抽象merge()方法是如何将数组A E Q S U Y E I N O S T排序的。 阅读全文
posted @ 2018-10-27 09:04
修电脑的龙生
阅读(312)
评论(0)
推荐(0)
摘要：
2.2.2按照算法2.4所示轨迹的格式给出自顶向下的归并排序是如何将数组E A S Y Q U E S T I O N排序的。 阅读全文
posted @ 2018-10-27 09:04
修电脑的龙生
阅读(345)
评论(0)
推荐(0)
摘要：
2.1.38不同类型的元素。编写一个测试用例，生成由多种数据类型元素组成的数组，元素的主键值随机，包括：1)每个元素的主键均为String类型(至少长10个字符),并含一个double值;2)每个元素的主键均为double类型,并含有10个String值(每个都至少长10个字符);3)每个元素的主键 阅读全文
posted @ 2018-10-27 09:03
修电脑的龙生
阅读(210)
评论(0)
推荐(0)
摘要：
2.1.36不均匀的数据。编写一个测试用例，生成不均匀的测试数据，包括：1)一半数据是0,一半是1;2)一半数据是0,1/4是1,1/4是2,以此类推;3)一半数据是0,一半是随机int值。评估并验证这些输入数据对本节讨论的算法的性能的影响。1)打乱次序后的结果：一百万个数10次运行的平均时间。选择 阅读全文
posted @ 2018-10-27 09:02
修电脑的龙生
阅读(162)
评论(0)
推荐(0)
摘要：
2.1.37部分有序。编写一个测试用例 ，生成部分有序的数组，包括：1)95%有序，其余部分为随机值;2)所有元素和它们的正确位置的距离都不超过10;3)5%的元素随机分布在整个数组中，剩下的数据都是有序的。评估并验证这些输入数据对本节讨论的算法的性能的影响。插入排序在左边有序，右边随机的情况下排序 阅读全文
posted @ 2018-10-27 09:02
修电脑的龙生
阅读(185)
评论(0)
推荐(0)
摘要：
2.1.35不均匀的概率分布。编写一个测试用例，使用非均匀分布的概率来生成随机排列数据，包括：1)高斯分布;2)泊松分布;3)几何分布;4)离散分布（一种特殊情况请见练习2.1.28)。评估并验证这些输入数据对本节讨论的算法的性能的影响。插入排序时高斯分布时间两倍于泊松分布、几何分布、离散分布。选择 阅读全文
posted @ 2018-10-27 09:01
修电脑的龙生
阅读(371)
评论(0)
推荐(0)
摘要：
2.1.34罕见情况。编写一个测试用例，调用sort()方法对实际应用中可能出现困难或极端情况的数组进行排序。比如，数组可能已经有序的，或是逆序的，数组的所有主键相同，数组的主键只有两种值，大小为0或是1的数组。从以下运行结果可以看出：插入排序时：有序时用时会很少，反序时用时比随机排列和有序要多， 阅读全文
posted @ 2018-10-27 09:00
修电脑的龙生
阅读(213)
评论(0)
推荐(0)
摘要：
2.1.32运行时间曲线图。编写一个测试用例，使用StdDraw在各种不同规模的随机输入下将算法的平均运行时间绘制成一张曲线图。可能需要添加一两个命令行参数，请尽量设计一个实用的工具。1）插入排序2)选择排序3)Shell排序public class E2d1d32{ public static d 阅读全文
posted @ 2018-10-27 08:59
修电脑的龙生
阅读(276)
评论(0)
推荐(0)
摘要：
2.1.33分布图。对于你为练习2.1.33给出的测试用例，在一个无穷循环中调用sort()方法将由第三个命令行参数指定大小的数组排序，记录每次排序的用时并使用StdDraw在图上画出所有平均运行时间，应该能够得到一张运行时间的分布图。1）插入排序1000个元素2)插入排序10000个元素3)选择排 阅读全文
posted @ 2018-10-27 08:59
修电脑的龙生
阅读(189)
评论(0)
推荐(0)
摘要：
2.1.31双倍测试。编写一个能够对排序算法进行双倍测试的用例。数组规模N的起始值为1000,排序后打印N、估计排序用时、实际排序用时以及在N增倍之后两次用时的比例。用这段程序验证在随机输入模型下插入排序和选择排序的运行时间都是平方级别的。对希尔排序的性能作出猜想并验证你的猜想。public cla 阅读全文
posted @ 2018-10-27 08:58
修电脑的龙生
阅读(289)
评论(0)
推荐(0)
摘要：
2.1.29希尔排序的递增序列。通过实验比较算法2.3中所使用的递增序列和递增序列1,5,19,41,109,209,505,929,2161,3905,8929,16001,36289,64769,146305,260609（这是通过序列9*4^k-9*2^k+1和4^k-3*2^k+1综合得到的 阅读全文
posted @ 2018-10-27 08:57
修电脑的龙生
阅读(379)
评论(0)
推荐(0)
摘要：
2.1.30几何级数递增序列。通过实验找到一个t,使得对于大小为N=10^6的任意随机数组，使用递增序列1,下取整(t),下取整(t^2),下取整（t^3),下取整(t^4),...的希尔排序的运行时间最短。给出你能找到的三个最佳t值以及相应的递增序列。t=5.31,递增序列：28 149 795 阅读全文
posted @ 2018-10-27 08:57
修电脑的龙生
阅读(383)
评论(0)
推荐(0)
摘要：
2.1.27希尔排序的用时是次平方级的。在你的计算机上用SortCompare比较希尔排序和插入排序以及选择排序。测试数组的大小按照2的幂次递增，从128开始。shell排序的倍率是2.5，选择和插入都是在4.public class SortCompare{ public static doubl 阅读全文
posted @ 2018-10-27 08:56
修电脑的龙生
阅读(247)
评论(0)
推荐(0)
摘要：
2.1.28相等的主键。对于主键仅可能取两种值的数组，评估和验证插入排序和选择排序的性能，假设两种主键值出现的概率相同。试验结果：插入排序用时只需选择排序的1/4,主要原因是插入排序在将元素放入到合适的位置时与有序元素不需要进行全部的比较，而选择排序会需要将元素与所有未排序的元素全部比较。1）使用相 阅读全文
posted @ 2018-10-27 08:56
修电脑的龙生
阅读(320)
评论(0)
推荐(0)
摘要：
2.1.26原始数据类型。编写一个能够处理int值的插入排序的新版本，比较它和正文中所给出的实现(能够隐式地用自动装箱和拆箱转换Integer值并排序)的性能。答：原始数据类型相对对象类型约有15%以上的性能提升。public class Insertion{ public static void 阅读全文
posted @ 2018-10-27 08:55
修电脑的龙生
阅读(229)
评论(0)
推荐(0)
摘要：
2.1.25不需要交换的插入排序。在插入排序的实现中使较大元素右移一位只需访问一次数组(而不用使用exch())。使用SortCompare来评估这种做法的效果。答：交换的成本较大，所以不交换方式性能提升10%public class Insertion{ public static void so 阅读全文
posted @ 2018-10-27 08:54
修电脑的龙生
阅读(751)
评论(0)
推荐(0)
摘要：
2.1.23纸牌排序。请见位朋友分别将一副扑克牌排序(见练习2.1.13)。仔细观察并记录他们所使用的方法。答：实际玩牌过程中的排序并不会按照2.1.13设定那些规则。说一说可以看到牌面的情况下的排序。1）从桌上每次拿一张牌，一边插到手上时采用插入排序较多。2）从桌上每次拿一张但不看牌，直到所有的牌 阅读全文
posted @ 2018-10-27 08:53
修电脑的龙生
阅读(192)
评论(0)
推荐(0)
摘要：
2.1.24插入排序的哨兵。在插入排序的实现中先找出最小的元素并将其置于数组的最左边，这样就能去掉内循环的判断条件j>0。使用SortCompare来评估这种方法的效果。注意：这是一种常见的规避边界测试的方法，能够省略判断条件的元素通常被称为哨兵。答：数组的长度达100万后这种哨兵在性能上才略有改进 阅读全文
posted @ 2018-10-27 08:53
修电脑的龙生
阅读(301)
评论(0)
推荐(0)
摘要：
2.1.21可比较的交易。用我们的Date类(请见2.1.1.4节)作为模板扩展你的Transaction类(请见练习1.2.13)，实现Comparable接口，使交易能够按照金额排序。解答：public class Transaction implements Comparable<Transa 阅读全文
posted @ 2018-10-27 08:52
修电脑的龙生
阅读(152)
评论(0)
推荐(0)
摘要：
2.1.22事务排序测试用例。编写一个SortTransaction类，在静态方法main()中从标准输入读取一系列事务，将它们排序并在标准输出中打印结果(请见练习1.3.17)解答：public class SortTransactions{ public static Transaction[] 阅读全文
posted @ 2018-10-27 08:52
修电脑的龙生
阅读(171)
评论(0)
推荐(0)
摘要：
2.1.19希尔排序的最坏情况。用1到100构造一个含有100个元素的数组并用希尔排序和递增序列1、4 、13 、40对其排序，使比较的次数尽可能多。非常困难的问题。下面只是目前找到的一个比较次数最多的排列。由于没有严格的数学证明，所以不能算是最后的结果。只是阶段性结果的记录。100,92,84,7 阅读全文
posted @ 2018-10-27 08:51
修电脑的龙生
阅读(843)
评论(0)
推荐(0)
摘要：
2.1.20希尔排序的最好情况。最好情况是什么？证明你的结论。答：最好情况就是已排好序的情况。因为无论h为何值，h子数组均已有序，都不需要交换元素。 阅读全文
posted @ 2018-10-27 08:51
修电脑的龙生
阅读(784)
评论(0)
推荐(0)
摘要：
2.1.18可视轨迹。修改你为上一题给出的解答，为插入排序和选择排序生成和正文中类似的可视轨迹。提示：使用setYscale()函数是一个明智的选择。附加题：添加必要的代码，与正文中的图片一样用红色和灰色强调不同角色的元素。/************************************* 阅读全文
posted @ 2018-10-27 08:50
修电脑的龙生
阅读(265)
评论(0)
推荐(0)
摘要：
2.1.18可视轨迹。修改你为上一题给出的解答，为插入排序和选择排序生成和正文中类似的可视轨迹。提示：使用setYscale()函数是一个明智的选择。附加题：添加必要的代码，与正文中的图片一样用红色和灰色强调不同角色的元素。 /************************************ 阅读全文
posted @ 2018-10-27 08:50
修电脑的龙生
阅读(334)
评论(0)
推荐(0)
摘要：
2.1.17动画。修改插入排序和选择排序的代码，使之将数组内容绘制成正文中所示的棒状图。在每一轮排序后重绘图片来产生动画效果，并以一张“有序”的图片作为结束，即所有圆棒均已按照高度有序排列。提示：使用类似于正文中的用例来随机生成Double值，在排序代码的适当位置调用show()方法，并在show( 阅读全文
posted @ 2018-10-27 08:49
修电脑的龙生
阅读(376)
评论(0)
推荐(0)
摘要：
2.1.17动画。修改插入排序和选择排序的代码，使之将数组内容绘制成正文中所示的棒状图。在每一轮排序后重绘图片来产生动画效果，并以一张“有序”的图片作为结束，即所有圆棒均已按照高度有序排列。提示：使用类似于正文中的用例来随机生成Double值，在排序代码的适当位置调用show()方法，并在show( 阅读全文
posted @ 2018-10-27 08:49
修电脑的龙生
阅读(274)
评论(0)
推荐(0)
摘要：
2.1.16验证。编写一个check()方法，调用sort()对任意数组排序。如果排序成功而且数组中的所有对象均没有被修改则返回true,否则返回false。不要假设sort()只能通过exch()来移动数据，可以信任并使用Array.sort()。答：在check中将原数组复制一份，然后用sort 阅读全文
posted @ 2018-10-27 08:48
修电脑的龙生
阅读(411)
评论(0)
推荐(0)
摘要：
2.1.15昂贵的交换。一家货运公司的一位职员得到了一项任务，需要将若干大货箱按照发货时间摆放。比较发货时间很容易（对照标签即可），但将两个货箱交换位置则很困难（移动麻烦）。仓库已经快满了，只有一个空闲的仓位。这位职员应该使用哪种排序算法呢？答：选择排序算法是多比较，少交换的算法。所以采用选择排序算 阅读全文
posted @ 2018-10-27 08:47
修电脑的龙生
阅读(561)
评论(0)
推荐(0)
摘要：
2.1.14出列排序。说说你会如何将一副扑克牌排序，限制条件是只能查看最上面的两张牌，交换最上面的两张牌，或是将最上面的一张牌放到这摞牌的最下面。答：1)一开始有一叠牌，称为第一叠牌2)翻开第一叠顶上的两张牌3)如果上面的牌小于下面的牌，交换两张牌的位置4)将第一叠最上的牌放到第二叠牌的最下面5)如 阅读全文
posted @ 2018-10-27 08:45
修电脑的龙生
阅读(432)
评论(0)
推荐(0)
摘要：
2.1.13纸牌排序。说说你会如何将一副扑克牌按花色排序(花色顺序是黑桃、红桃、梅花和方片），限制条件是所有牌都是背面朝上排成一列，而你一次只能翻看两张牌或者交换两张牌(保持背面朝上)。算法具体描述如下：1）翻看第一张、第二张牌2）如果第二张牌的花色小于第一张牌的花色，那么交换这两张牌3）翻看第一张 阅读全文
posted @ 2018-10-27 08:44
修电脑的龙生
阅读(1940)
评论(0)
推荐(0)
摘要：
2.1.12令希尔排序打印出递增序列的每个元素所带来的比较次数和数组大小的比值。编写一个测试用例对随机Double数组进行希尔排序，验证该值是一个小常数，数组大小按照10的冪次递增，不小于100。public class E2d1d12{ public static int compareTimes 阅读全文
posted @ 2018-10-27 08:43
修电脑的龙生
阅读(472)
评论(0)
推荐(0)
摘要：
2.1.10在希尔排序中为什么实现h有序时不使用选择排序？答：由于选择排序不能利用元素现有次序来减少排序的时间复杂度，当希尔排序中采用选择排序时，h=1时的排序不能利用之前h>1时的排序结果，所以希尔排序不采用选择排序来实现。 阅读全文
posted @ 2018-10-27 08:42
修电脑的龙生
阅读(464)
评论(0)
推荐(0)
摘要：
2.1.11将希尔排序中实时计算递增序列改为预先计算并存储在一个数组中。public class Shell2{ public static void sort(Comparable[] a) { int N=a.length; int h=1; int[] SN=new int[20]; int 阅读全文
posted @ 2018-10-27 08:42
修电脑的龙生
阅读(332)
评论(0)
推荐(0)
摘要：
2.1.9按照算法2.3所示轨迹的格式给出希尔排序是如何将数组 E A S Y S H E L L S O R T Q U E S T I O N排序的。答：灰底色表示相关元素未互换，黄底色表示相关元素互换。1-sort省略，与插入排序相同。public class Shell{ public st 阅读全文
posted @ 2018-10-27 08:41
修电脑的龙生
阅读(312)
评论(0)
推荐(0)
摘要：
2.1.8假设元素只可能有三种值，使用插入排序处理这样一个随机数组的运行时间是线性的还是平方级别的？或是介于两者之间？答：介于两者之间。( 猜出来的并非分析出来了的）暂时无法给出完整的分析。一个不太严谨的分析。 设有N个元素需要排序，三种元素值分别为1,2,3,各类元素的个数分别为N/3。 插入排序 阅读全文
posted @ 2018-10-27 08:40
修电脑的龙生
阅读(500)
评论(0)
推荐(0)
摘要：
2.1.5构造一个含有N个元素的数组，使插入排序(算法2.2)运行过程中内循环(for)的两个判断结果总是假。答：已排序的数组即可达到这个效果。如元素： 1 2 3 4 5 阅读全文
posted @ 2018-10-27 08:39
修电脑的龙生
阅读(283)
评论(0)
推荐(0)
摘要：
2.1.6在所有的主键都相同时，选择排序和插入排序谁更快？ 答：插入排序。因为主键相同时选择排序需要进行N(N-1)/2次比较，0次交换。插入排序需要N-1次比较，0次交换。 阅读全文
posted @ 2018-10-27 08:39
修电脑的龙生
阅读(311)
评论(0)
推荐(0)
摘要：
2.1.7对于逆序数组，选择排序和插入排序谁更快？答：选择排序。因为选择排序需要进行N(N-1)/2次比较,N次交换。插入排序需要N(N-1)/2次比较，N(N-1)/2次交换。 阅读全文
posted @ 2018-10-27 08:39
修电脑的龙生
阅读(325)
评论(0)
推荐(0)
摘要：
2.1.4按照算法2.2所示轨迹的格式给出插入排序是如何将数组 E A S Y Q U E S T I ON排序的。 阅读全文
posted @ 2018-10-27 08:38
修电脑的龙生
阅读(244)
评论(0)
推荐(0)
摘要：
2.1.2在选择排序中,一个元素最多可能会被交换多少次?平均可能会被交换多少次？答：1）设对N个元素进行排序，那么有N个位置用来摆放这N个元素。一个元素无论在排序前还是在交换后所处的位置只可能在1至N的某一个位置上，而排序后这个元素也一定在1至N的某个位置k上，当排序前和交换后这个元素没有在排序后的 阅读全文
posted @ 2018-10-27 08:37
修电脑的龙生
阅读(1346)
评论(0)
推荐(0)
摘要：
2.1.3构造一个含有N个元素的数组，使用选择排序(算法2.1)运行过程中a[j]<a[min](由此min会不断更新)成功的次数最大。答：逆序数组，例如： 5 4 3 2 1 阅读全文
posted @ 2018-10-27 08:37
修电脑的龙生
阅读(279)
评论(0)
推荐(0)
摘要：
1.5.26Erdos-Renyi模型的均摊成本图像。开发一个用例，从命令行接受一个int值N,在0到N-1之间产生随机整数对，调用connected()判断它们是否相连，如果不是则调用union()方法(和我们的开发用例一样)。不断循环直到所有触点均相互连通。按照正文的样式将所有操作的均摊成本绘制 阅读全文
posted @ 2018-10-27 08:36
修电脑的龙生
阅读(159)
评论(0)
推荐(0)
摘要：
2.1.1按照算法2.1所示轨迹的格式给出选择排序是如何将数组E A S Y Q U E S T I O N排序的。答： 阅读全文
posted @ 2018-10-27 08:36
修电脑的龙生
阅读(185)
评论(0)
推荐(0)
摘要：
1.5.25随机网格的倍率测试。开发一个性能测试用例，从命令行接受一个int值T并进行T次以下实验：使用练习1.5.18的用例生成一个NXN的随机网络，所有连接的方向随机且排列随机。和我们的开发用例一样使用UnionFind来检查触点的连通性，不断循环直到所有触点均相互连通。对于每个N，打印出N值和 阅读全文
posted @ 2018-10-27 08:35
修电脑的龙生
阅读(170)
评论(0)
推荐(0)
浙公网安备 33010602011771号