3回答
如果我有这个JS对象文字：
var foo = {
Sussy: 4,
Billy: 5,
Jimmy: 2,
Sally: 1
};
如何创建新的排序对象文本：
var bar = {
Sally: 1,
Jimmy: 2,
Sussy: 4,
Billy: 5
};
浏览 1提问于2011-06-07得票数 11
回答已采纳
2回答
我正在构建一个React组件，它在订单摘要屏幕上显示数据，以完成我的应用程序的订单过程。
我正在收到这样的信息：
警告:列表中的每个孩子都应该有一个唯一的“键”支柱。%s%s见.
以下是供参考的完全错误：
Check the render method of `SummaryOrder`., ,
in RCTView (at SummaryOrder.js:24)
in SummaryOrder (at PreOrderScreen.js:111)
in ScrollView (at PreOrderScreen.js:105)
in RCTView (at
浏览 3提问于2021-09-16得票数 0
回答已采纳
当传递一个简单的比较函数时，我非常努力地“查看”对Array.sort()的调用中发生了什么。我已经走到了这一步，但这些数字似乎从未加起来，我想知道JavaScript是如何得出结论的。也许我漏掉了其中的一些基本点。
var nums = new Array(40,20,230,65);
var b = a.sort(function(a,b){
return a-b;
});
所以，我就这样想出来了：
40-20 = 20 = (>0) so，a或20,40
230-65 = 165 (>0) so b，a或230,65
40-65 = -25 (<0)
浏览 4提问于2011-02-13得票数 0
1回答
问题：
我用Java编写了一个快速排序算法。当我尝试这样的情况：{4，3，1，2，2，0}，我得到{0,2,1,3,4}
因此，我开始遍历调试器来查看哪里出了问题，并注意到当我到达代码中的某个部分时，数组值的重新分配被完全忽略(用红色圈起来)：
此时，它应该取intArray 1并使其等于2，然后使intArray 3等于枢轴值。但是，它完全忽略了这两行代码。
我尝试了其他几种情况(如下所示)，以确保这不是我传递变量或类似的方式(但它们在相同的代码中工作得很好)：
private final static int[] intArray = new int[]{4, 8, 1,
浏览 0提问于2015-12-05得票数 0
回答已采纳
1回答
在阅读了快速排序算法之后，我决定在查看任何代码之前编写自己的实现。下面的代码是我想出来的。通过将我的代码与其他实现进行比较，我注意到，与从快速排序函数返回排序数组不同，其他实现倾向于利用列表的可变性，只需在未排序的数组上运行该函数，这反过来将对数组进行排序，而不必引用函数调用。我很好奇与我的代码和我正在使用的书中的代码的时空比较，这是我在下面提供的。我假设算法执行的时间相当相似，也许我正在执行的级联操作会产生负面影响？在空间方面，由于我没有直接修改输入数组，所以假设我正在创建/返回一个显然效率低下且重要的新数组，因为与合并排序相比，快速排序的主要优点是节省了空间。总的来说，我只是在寻找一些额外
浏览 0提问于2016-05-16得票数 0
回答已采纳
我希望在用Rust编写的排序算法上运行一些基准测试(基准测试是使用Criterion和cargo bench)。当我将编译后的版本与内置的sort()进行比较时，我发现速度上有一个数量级的差异。 我的问题是:切片上的“开箱即用”排序怎么会比作为库编译的完全相同的代码快这么多。 为了尝试和比较苹果与苹果，我采用了Rust源代码(https://github.com/rust-lang/rust/blob/stable/src/libcore/slice/sort.rs)中的快速排序算法。当我将其与现成提供的sort()函数进行直接比较时，我注意到x16在速度上的差异。我也尝试过在Cargo.t
浏览 9提问于2019-09-13得票数 0
1回答
快取是怎么回事？
、、、
在中，作者认为快速排序并不是非常有效的缓存排序算法。正如作者所提到的
然而，快速排序的一些缺点仍然是对present.Each字符进行多次检查，直到每次检查其中的字符时都会重新访问它所处的枢轴partition.Each字符串，并且在第一次分区之后，这些访问实际上是随机的。对于大量的字符串，缓存丢失率很可能很高。
我还发现了，它说快速排序和合并排序是缓存遗忘的算法，但是维基百科和声称快速排序非常高效。
我无法理解在哪些情况下，快速排序除了整数data.Can的强制丢失之外，还有其他人详细解释快速排序缓存丢失的情况？
浏览 4提问于2016-01-07得票数 5
在快速排序中，如果始终选择关键元素作为中间元素，那么它是否与合并排序相同？
浏览 1提问于2022-04-11得票数 0
我知道Java的Arrays.sort方法使用MergeSort对对象数组(或对象集合)进行排序，因为它是稳定的，而Java使用QuickSort来处理原语数组，因为我们不需要稳定性，因为两个相同的ints是无法区分的，也就是说，它们的标识并不重要。
我的问题是，对于原语，为什么Java不使用MergeSort的保证O(n log n)时间，而是使用QuickSort的平均O(n log n)时间？在其中一个相关答案的最后一段中，解释说：
对于引用类型，引用对象通常比引用数组占用更多的内存，这通常并不重要。但是对于原始类型，克隆数组会使内存使用翻番。
这是什么意思？克隆引用仍然是--至
浏览 8提问于2017-03-13得票数 8
2回答
我必须通过每次将数组的大小递增100来对快速排序执行运行时分析。但是，当我使用System.nanoTime测量运行时时，结果并不像我期望的那样(我的图看起来更像O(2^n))。每当数组达到800左右时，时间就会迅速增加。有人能告诉我我的代码哪里出错了吗？
另外，count部分目前有点无关紧要，因为我只想在每个数组大小下运行一次快速排序。
import java.util.Random;
public class Quickworking {
public static void main(String[] args) {
Random rand = new Random();
浏览 2提问于2012-12-09得票数 2
回答已采纳
1回答
，通常认为quicksort比mergesort更好地利用了缓存的局部性(引用的局部性)。
由于这两种方法都遵循分而治之的方法，我不明白quicksort如何更容易使用缓存。有人能提供更多有关这方面的洞察力吗？
此外，还有关于的注释。如果这是实际的(我不知道是否是)，合并排序也是缓存友好吗？
浏览 1提问于2018-01-30得票数 7
回答已采纳
我不知道这个算法是堆排序还是快速排序.
假设我有一个没有源代码的算法--它是不稳定的，在大型数据集上性能很好，对于有序和无序的集合，运行时间类似。
如果没有更多的信息，是否可以判断这个算法是堆排序还是快速排序？
浏览 5提问于2016-06-21得票数 2
回答已采纳
1回答
我认为合并排序是分而治之，
Divide -数组实际上被划分为没有任何处理的子数组(比较/交换)，问题的大小是减半/分割/.
processing(compare/swap) Conquer --对这些子数组进行merge()
代码给人的印象是分而治之，
如果(hi <= lo)返回；int = lo + (hi-lo)/2；//No (比较/交换)在对元素进行除法排序(a，aux，lo，mid )之前；//问题被减半(划分)排序(a，aux，mid+1，hi)；合并(a，aux，lo，mid)；// (比较/交换)发生在合并-征服过程中。
合并排序跟踪显示，这个问题是颗粒化
浏览 2提问于2016-12-28得票数 4
根据的说法：
在Java中，Arrays.sort()方法根据数据类型使用合并排序或优化的快速排序，当排序不到7个数组元素时，实现效率切换为插入排序
但是为什么呢？合并排序和快速排序都是O(n log )。
浏览 10提问于2013-05-16得票数 9
1回答
目前，我正在学习C，并选择实现快速排序作为练习。
我的代码是正确的排序，但之后，我看了一些教程关于快速排序在线。他们用不同的方式实现它。
我不知道，是我误解了快速排序，还是简单地以不同的方式实现了它。
我是如何理解快速排序的：
选择枢轴
根据其大小(比枢轴大/小)
重复直到数组被排序
我使用中间元素作为枢轴，以避免标准的最坏情况。
我的代码：
#include <stdio.h>
#include <math.h>
void quicksort(unsigned int* array, unsigned int length)
{
if (length &l
浏览 0提问于2020-04-20得票数 1
回答已采纳
我正在寻找一种有效的算法，在n个元素的未排序数组中找到k‘’th最小元素，其中1 <= k <= n。显而易见的是，首先对数组进行排序，然后选择k‘The元素，这将导致O(n * log(n))的运行时间，但我想可以以更有效的方式完成，因为排序数组似乎“做得太多了”。例如，对于k=1，任务是找到数组的最小值，这可以在O(n)中完成。
有谁知道更好的k>=2算法吗？
浏览 0提问于2015-12-24得票数 0
2回答
Matlab排序算法
、、、
在Matlab中，我一直在研究各种排序算法，如合并、冒泡、快速和桶式排序，并提出了一些问题。它指出插入排序、冒泡排序和快速排序的运行时间为O(n^2)，而合并和桶的运行时间为O(nlog(n))。我想知道，如果最后两个更快，为什么使用前三个中的任何一个。如果列表排序更多/排序更少、更大/更小等等，它们会更快吗?还是还有其他原因？
浏览 1提问于2016-05-28得票数 0
回答已采纳
2回答
在随机快速排序中，我应该先将输入数据随机化，然后使用第一个元素作为枢轴，还是不应该改变输入数据，而是选择一个随机枢轴？
我有点不明白什么是需要随机分配的。
浏览 4提问于2013-11-10得票数 1
回答已采纳
1回答
这里的第一张海报。
我在“古朗”里练习一些排序算法。我试着写一个快速排序算法。代码如下所示。
func DivideAndConquerSort(newArr []int,descending bool) []int {
if len(newArr) == 1 || len(newArr) == 0{
return newArr
}
pivotIndex := 0
leftPivot := []int{}
rightPivot := []int{}
centerPivot := []int{}
for idx1 := 0
浏览 9提问于2022-06-16得票数 2
1回答
如果我选择一个随机的枢轴与在无序的集合/列表中选择第一个枢轴有什么不同呢？
如果集合是无序的，它本身不是随机地选择集合中的第一个值吗？因此，从本质上讲，我试图了解如何/如果随机化可以提供更好的最坏情况运行时。
浏览 4提问于2017-01-06得票数 8
回答已采纳
2回答
我试图在Java中实现一种高效的排序算法。出于这个原因，我还实现了快速排序，并使用了以下代码：
public class Sorting {
private static Random prng;
private static Random getPrng() {
if (prng == null) {
prng = new Random();
}
return prng;
}
public static void sort(int[] array) {
sortInte
浏览 1提问于2016-04-04得票数 1
回答已采纳
可能重复：
因此，我正在读取各种排序实现上的数组。我注意到的是，一些实现使用了调优的快速排序，而另一些则使用了修改后的合并。为什么会有差异？
谢谢!
浏览 1提问于2012-04-20得票数 12
回答已采纳
我需要参考一些排序算法/想法，以便最有效地将数组元素分成两部分。例如，如果e= 1E10-3，那么我希望所有大于数组顶部元素的元素(它们不需要进一步排序，它们只需要在顶部)，而那些较小的元素需要在底部。
因此，如果数组中的元素是0.0001，0.0002，0.7，0.3，0.5，0.0005，那么我希望以尽可能快的方式对其进行排序，例如，它以0.7，0.3，0.5，0.0001，，0.0005，0.0002结束
浏览 0提问于2014-08-10得票数 0
3回答
插入排序与气泡排序与快速排序算法
、、、、
我正在研究我测试过的气泡排序和插入排序和快速排序，我做了随机数的测试。结果表明，插入排序比气泡排序更快，而快速排序是最慢的。
所以我在时间上有下面的排名
插入排序(最快)
气泡排序(二分)
快速排序(最慢的)
考虑到插入和气泡排序具有O(n2)的复杂性，而快速排序O(n log )和O (n log )应该更快！
有人能和我分享解释吗？
谢谢
(NSMutableArray *)quickSort:(NSMutableArray *)a
{
// Log the contents of the incoming array
NSLog(@"%@
浏览 1提问于2012-10-16得票数 1
回答已采纳
1回答
方法1
C.A.R . Hoare介绍了分区逻辑(如下所示)，这是在学校教的，
low = pivot = 0;
i = 1;
j = high = listSize-1;
while (true) {
while (a[i] <= a[pivot] && (i < high)) {
i = i + 1;
}
while (a[j] >= a[pivot] && (j > low)) {
j = j - 1;
}
if (i >= j)
b
浏览 0提问于2017-01-18得票数 2
2回答
我写了一个可以工作的快速排序程序。我需要包含一个计数器来计算迭代次数。在课堂上，我们讨论了算法，并得出结论，元素比较是基本操作。然而，我不知道应该把计数器放在哪里。我似乎不能得到正确的输出。我已经包含了我的代码，谢谢！
void partition( vector<int> & S, int low, int high, int & pivotpoint )
{
vector<int> U;
int pivotitem = S.at(low);
int j = low;
int i;
for( i = low + 1; i <= high; i++
浏览 2提问于2013-02-18得票数 1
3回答
快速排序和优化的快速排序之间的根本区别是什么？快速排序的改进是什么？Java是如何决定使用这种排序而不是合并排序的？
浏览 2提问于2010-05-06得票数 5
回答已采纳
当将快速排序与其他类型进行比较时，我听到了这样的说法：“快速排序对于少量的数据很有效”。
这个评论的一个例子是：
合并排序可以很好地工作在任何类型的数据集上，而不管其大小(大小)。然而，快速排序不能很好地处理大型数据集。
具体来说，我正在研究mergesort与quicksort之间的关系，并多次听说过“快速排序更适合于少量数据，而合并更适合大量数据”。
我知道，与合并排序相比，快速排序具有更大数据量的优点(引用的局部性，不需要额外的空间等等)。
然而，我很难理解为什么较小数据量的快速排序会比合并更好/更好。
我的工作：
从我自己的一个快速程序(它远远没有优化运行每种类型的基本版本)来看，
浏览 1提问于2021-06-08得票数 0
回答已采纳
在许多快速排序算法中，编程涉及将每个数组中的元素放入三个组：(less、pivot、more)，有时将这些组重新放在一起。如果我不想用这个呢？是否有更简单的方法来手动对列表进行快速排序？
基本上，我计划将数组保持为一体，并根据分区交换所有元素(例如，给定一个list x和pivot r，我们可以得到[0:r]和[r:len(x)]的引用列表。但是，随着排序的继续，我如何继续引用每个较小的“子数组”？
这是我的代码，但我不知道如何继续：
x = [4,7,4,2,4,6,5]
#r is pivot POSITION
r = len(x)-1
i = -1
for a in range(0,r+
浏览 8提问于2015-09-04得票数 0
回答已采纳
稳定的排序算法比不稳定的排序慢。例如，使用O(n*log(n)*log(n))调用来交换元素。
如果我们的目标是保持元素的原始顺序，为什么不直接对所有元素进行编号(O(n))，然后使用原始索引执行不稳定排序(O(n*log(n)))来解决比较相等的实例。
这看起来更快。
即O(n) + O(n*log(n)) < O(n*log(n)*log(n))
这是正确的吗？有什么理由更喜欢稳定的类型吗？
浏览 3提问于2019-10-23得票数 2
我正在比较插入排序和快速排序。我已经弄明白了为什么在几乎已排序的数组上qsort更慢，但我不明白为什么插入排序要快得多，当然它仍然需要比较数组中几乎相同数量的元素。
浏览 2提问于2012-04-22得票数 4
1回答
合并排序的最坏情况复杂性为O(logN)和Quick有O(N^2)，因此理论上合并排序应该比快速排序更好。但我听说，由于一些复制开销，大多数情况下，快速排序优于合并排序。。
然后我决定实现和测试，下面是我用C语言编写的完整源代码，
来源
#include <stdio.h>
#include <time.h>
#define SZ 10000000
#define MOD 10000007
#define i64 long long int
i64 nums[SZ];
i64 L[SZ], R[SZ];
i64 seed = 0xff;
i64 srand(){
浏览 2提问于2018-10-02得票数 3
回答已采纳
2回答
有人能建议一下在.NET中实现像IComparable这样的东西时，.NET使用什么排序算法来对底层数据进行实际排序吗？另外，所使用的算法是可定制的还是可选择的？
浏览 3提问于2011-05-11得票数 11
回答已采纳
3回答
人们普遍认为，快速排序的最佳情况是O(nlogn)，因为每次都会将数组划分为大约一半。也有人说，假设数组是排序的，最坏的情况是n^2。
难道我们不能通过设置一个名为swap的布尔值来修改快速排序吗？例如，如果第一次传递没有初始交换位置，那么我们可以假设数组已经排序，因此不再对数据进行进一步分区。
我知道修改后的冒泡排序通过检查交换来使用这一点，允许最好的情况是O(n)而不是O(n^2)。这种方法可以应用于快速排序吗？为什么或者为什么不？
浏览 0提问于2011-12-23得票数 3
回答已采纳
2回答
为什么在对列表进行排序时，mergesort被认为是“最佳选择”，而不是快速排序？我在网上看到的一次演讲中听到了这一点，并在几个网站上看到了它。
浏览 2提问于2011-10-03得票数 11
回答已采纳
1回答
无迹就地选择排序
、、、、
您将看到一个长度为n的数组A1..n，每个单元格包含apair。所有的高度值都是不同的，所有的权重值也是不同的。对数组按高度升序排序的任务是设计一种递归分治算法，即给定一个整数k values.Your 1，n，找到权值最小的第k个条目。在每一级递归中，你只能使用O(1)个额外的空间。尽管允许您的算法在需要时对A的条目进行重新排序，但它必须在终止之前恢复条目的原始顺序。您的算法必须在Θ(n)时间内运行。 我能想到的算法是选择排序，但我不能在所要求的时间和空间复杂度上做到这一点。任何帮助或指导都将不胜感激。
浏览 7提问于2019-10-15得票数 0
4回答
3-快速排序，问题
、、、
我正在尝试理解3向基数快速排序，我不明白为什么那里有截断变量？那插入的方法呢？
public class Quick3string {
private static final int CUTOFF = 15; // cutoff to insertion sort
// sort the array a[] of strings
public static void sort(String[] a) {
// StdRandom.shuffle(a);
sort(a, 0, a.length-1, 0);
as
浏览 1提问于2010-06-11得票数 4
回答已采纳
_radixSort_0 = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,
浏览 4提问于2011-11-10得票数 35
回答已采纳
我正在尝试编写一个程序，它将接受输入数组作为输入，并对其进行排序。排序方式如下：
程序将开始使用下面提到的任何排序算法对数组的前20%进行排序。如果在20%之后，程序发现排序算法花费了最坏情况的时间，程序将切换到其他排序算法，并继续使用该排序算法对数组进行排序。我在这里面临的问题是如何知道排序算法是否在最坏情况下花费时间？
我将使用的排序算法是：
快速排序、合并排序、存储桶排序
任何形式的帮助都会非常感谢。
浏览 2提问于2016-10-04得票数 1
2回答
在哪种情况下可以使用堆排序？如我们所知，堆排序具有n×lg(n).的复杂性。但是它的使用要比快速合并排序少得多。那么，我们什么时候才能准确地使用这种堆类型?它的缺点是什么？
浏览 2提问于2013-08-10得票数 0
我只是做了一个数组问题，那里的解决方案使用了快速排序，但是我使用了Arrays.sort() method.Now，我认为Arrays.sort()使用了带基本类型的快速排序，对于对象类型使用了mergesort。那么，使用
Arrays.sort()
方法直接在java中执行，而不是为Quick sort.Or执行整个实现，如果两者相同，为什么不使用Arrays.sort()方法执行冗长的实现？
浏览 0提问于2016-04-17得票数 1
回答已采纳
1回答
我看到类似的问题曾被问过，但我已经寻找了一段时间，似乎找不到答案。
我现在的任务是使用快速排序算法来排序一个由7个字母组成的简单数组。我们需要显示这类的每一步，每一次都在支点上下划线。我们的导师要求我们使用最右边的值作为每个步骤的枢轴。基于这段视频，，这是我到目前为止所拥有的(以粗体为支点)：
GACEFBD
一个GCEFBD
交流-GEFBD-
D
ACBD|FGE
但我不知道从这里往哪里走。在分区的左边，D是枢轴，但是没有大于D的值，那么这个支点到哪里去了？我看过的每一本教程都使用3的中间值作为枢轴，或者是最左边的，而我在算法方面并不是最好的。
B部分给我们展示了ABCDEFG分类的每一步
浏览 1提问于2014-10-23得票数 2
回答已采纳
5回答
我们有两个数组(未排序)，容量为n和n+m。第一个数组具有n元素。第二个数组具有m元素(另外n places为更多元素保留)。
目标是合并这两个数组，并以排序的方式将结果存储在第二个数组中，而不需要使用额外的空间。
目前，我使用快速排序对两个数组进行排序，然后使用合并排序将它们合并.有没有更有效的方法来实现这一点？
浏览 3提问于2013-04-23得票数 1
1回答
一个测试要求我实现一个排序算法，它对一个数组进行排序，当大小为N>1000时，通过合并排序，否则通过快速排序和透视随机选择。然后假设要比较的关键字由1，M上随机分布的整数组成，M应该是多少才能使上述算法运行得最好？ 如果大小为<=1000，我让Quick Sort处理合并排序的递归调用。在我看来，由于随机键、随机枢轴和Hoare的分区方案不会因为重复的元素而减慢，如果M比N小得多，Quick sort将以最佳状态运行，而Merge sort对于特定的数组大小运行相同，而不管键分布如何，那么M在这里的用途是什么？
浏览 48提问于2020-01-07得票数 1
3回答
这些排序算法在实际应用中有什么用处吗？
还是仅仅是n^2复杂度排序算法的一个基本例子？
有人能举个例子说明一下它的用法吗？
浏览 6提问于2016-02-05得票数 2
回答已采纳
1回答
我正在编写一个c程序，在这个程序中，我需要创建不同大小的数组(在512个元素和16384元素之间)，这些数组总是为快速排序生成最好的情况。我知道支点应该总是在中间，但是我如何制作一个算法，在这种情况下创建一个数字数组呢？在我的分区函数中，我选择最后一个元素作为枢轴。
我试图根据我在中找到的答复来创建一个函数，但是排序这些数组所获得的运行时间比我从一般情况中得到的要大。
浏览 8提问于2022-11-17得票数 1
当我试图在JS中实现快速排序时，有什么问题呢？我得到一个调用堆栈大小超过错误。
function quicksort(arr) {
if (arr.length <= 1)
return arr;
let pivot = Math.floor(arr.length / 2);
const left = [], right = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
}
else {
浏览 4提问于2020-02-23得票数 0
回答已采纳
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频
腾讯云开发者
