为什么排序时间不是O(n log (n))
排序时间不是O(n log (n))的原因是因为排序算法的不同，不同的排序算法具有不同的时间复杂度。
常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。
冒泡排序和选择排序的时间复杂度都是O(n^2)，插入排序的时间复杂度是O(n^2)或者O(n log (n))，快速排序的时间复杂度是O(n log (n))，归并排序的时间复杂度是O(n log (n))，堆排序的时间复杂度是O(n log (n))。
所以，并不是所有的排序算法的时间复杂度都是O(n log (n))，具体的时间复杂度取决于所使用的排序算法。
排序算法的选择取决于具体的应用场景和需求。例如，如果需要稳定的排序结果，可以选择归并排序；如果需要原地排序，可以选择快速排序；如果需要对大规模数据进行排序，可以选择堆排序。
腾讯云提供了多种与排序相关的产品和服务，例如云服务器、云数据库、云存储等，可以根据具体的需求选择相应的产品和服务。具体的产品介绍和链接地址可以参考腾讯云官方网站。
相关·内容
4回答
我正在阅读二进制搜索树，并在想，我们到底为什么需要BST？据我所知，所有这些都可以使用简单的排序数组来实现。例如，为了构建具有n个元素的BST，我们需要n*O(log n)时间，即O(nlog n)，并且查找时间是O(log n)。但是这个东西也可以使用数组来实现。我们可以有一个排序数组(需要O(nlog n)时间)，其中的查找时间也是O(log n)，即二进制搜索算法。那么为什么我们还需要另一个数据结构呢？BST是否还有其他用途/应用，使它们如此特殊？
--Ravi
浏览 1提问于2010-10-14得票数 6
回答已采纳
来自redis医生：
ZPOPMIN密钥计数可从5.0.0开始。
时间复杂度: O(log(N)*M)，N是排序集中的元素数，M是弹出的元素数。
移除并返回存储在键处的排序集中得分最低的成员。
所以，我的问题是，如果列表是排序的，为什么要取log，为什么不是O(1)？
浏览 0提问于2019-01-26得票数 0
回答已采纳
据我所知，当比较函数为O(1)时，有效的排序算法的alg时间复杂度为O(N*log(N))。
如果比较函数不是O(1) (即O(M))，时间复杂度是多少？
是O(N*log(N*M))还是O(N*M*log(N))？
谢谢
浏览 10提问于2017-08-08得票数 0
回答已采纳
我知道Java的Arrays.sort方法使用MergeSort对对象数组(或对象集合)进行排序，因为它是稳定的，而Java使用QuickSort来处理原语数组，因为我们不需要稳定性，因为两个相同的ints是无法区分的，也就是说，它们的标识并不重要。
我的问题是，对于原语，为什么Java不使用MergeSort的保证O(n log n)时间，而是使用QuickSort的平均O(n log n)时间？在其中一个相关答案的最后一段中，解释说：
对于引用类型，引用对象通常比引用数组占用更多的内存，这通常并不重要。但是对于原始类型，克隆数组会使内存使用翻番。
这是什么意思？克隆引用仍然是--至
浏览 8提问于2017-03-13得票数 8
例如，如果合并排序的时间复杂度是O(n log n)，那么为什么它是大O而不是θ或ω。我知道这些的定义，但我不明白的是如何根据定义确定符号。
浏览 0提问于2014-06-15得票数 2
1回答
给定一个大小为N的数组(数组包含整数)，我希望对数组进行排序，但只对数组中log(n)的长度进行排序，因此到最后，数组将具有排序的n/logn序列(以logn每个序列的大小)。
我的思想是使用MergeSort算法，在时间复杂度最坏的情况下运行O(nlogn)。但是，由于我只是对数组中的logn长度进行排序，所以时间复杂度应该是O(log( N )*log(log(N)，因为我实际上没有遍历N的整个长度。
因此，在这种情况下，MergeSort是预先形成的，即n/logn时间。假设此操作的总体时间复杂度为(n/logn)*O(log(N)_log(log(N)，=> O(n_log(lo
浏览 3提问于2020-12-26得票数 0
回答已采纳
3回答
在上提到，这种方法在O(n log )时间内对数组进行排序，但它也是稳定的和就地的。这听起来是一种非常好的排序算法，因为没有其他排序算法同时执行所有排序算法(不是O(n log )，不稳定， (或Intro排序)既不到位也不稳定，不到位)。然而，在维基百科上，只提到了它的名字，而没有提及其他任何东西。作为参考，它将转到。通过O(n log n)比较和O(n)移动，使排序稳定、就位。计算系统理论40 (4)：327-353。然而，这并不能真正解释它是如何工作的，它更多地说明了它存在的原因。
我的问题是这个方法是如何工作的(它实际上做了什么步骤)，以及为什么与它相关的资源如此之少，考虑到没有其他已
浏览 4提问于2014-03-13得票数 12
回答已采纳
我在互联网上搜索，以找出哪种排序算法最适合非常大的数据集。我发现许多人认为合并排序是最好的，因为它是公平的，而且它确保了时间复杂度是O(n log n)，快速排序是不安全的:快速排序的变体也可能是不安全的，因为真实的数据集可以是任何东西。
如果交换这两个元素的时间开销可以忽略不计，那么为什么我们不能选择堆排序作为这种情况下的最佳排序算法，因为它是适当的，并且O(n log n)？
在合并排序的情况下，它需要另一个O(n)空间；如果数据非常大，那么我们就不能使用这个算法。
请告诉我:在这种情况下，哪种算法应该是最好的？
浏览 2提问于2015-08-27得票数 18
回答已采纳
4回答
合并排序算法困境
、、、
考虑合并排序的递归实现，它用于排序大小为n的数组。用于合并排序的递归调用数为
不是O(n)，不是Theta(n)
或Theta(n)
或者O(n log n)但不是Theta(n log n)
或Theta(n log n)
PS :我正在准备考试，我发现了这个问题，我想的是合并排序有一个Theta(n log n)的时间复杂性，但是我们没有考虑常量。所以，应该是O(n log n)，而不是Theta(n log n)。但这是一个错误的答案。正确的答案应该是什么?为什么？
浏览 1提问于2014-10-08得票数 2
回答已采纳
1回答
清理堆的时间复杂度是多少？
、、、、
我搜索了很多网站，他们都说“清除堆的时间复杂性是O(n log N)”。原因是：
交换尾节点的根代价为O(1)。
将“新根”交换到合适的位置需要花费O(level) = O(log )。
因此，删除一个节点(根)需要花费O(log )。
因此，删除所有n个节点的代价是O(n log )。
在我看来，答案是对的，但不是“紧”的，因为：
在删除过程中堆(或其级别)变得更小。
因此，“将新的根交换到合适的位置”的成本变得更小。
"O(n log n)“的上述原因没有体现这种变化。
在上证明了创建堆的时间复杂性是O(n)。
我倾向于认为清除堆的时间
浏览 2提问于2020-05-16得票数 0
回答已采纳
使用堆排序可以在Θ(log )时间内排序多少个元素？
当我们进行堆排序时，为了构建堆，我们需要Θ(n)复杂性，然后执行堆排序O(nlog n)。我理解这个概念。但是，当谈到这里的问题时，我们甚至不能在Θ(log )时间内构建一个n个元素的堆。那么，答案O(1)是否考虑输入大小n？
我还看到了一种不同的解释，它导出了考虑输入大小logn的Θ(logn/logn n)的复杂性。我也不太遵循这个方法。那么，哪个是正确的答案，为什么呢？
浏览 5提问于2014-01-16得票数 6
回答已采纳
3回答
这里有两个问题，我得到了错误的答案，但我不知道为什么。
1.假设您使用排序的数组(例如，从最大到最小)实现优先级队列的功能。插入和提取-Min的最坏运行时间分别是多少？(假设您有一个足够大的数组来容纳您所面临的插入。)
我的答案是O(log(n))和O(1)，因为我们可以二进制搜索和插入so O(log(n))
提取-min很容易。
但正确的答案是O(n)和O(1)。
2.假设使用未排序的数组实现优先级队列的功能。插入和提取-Min的最坏运行时间分别是多少？(假设您有一个足够大的数组来容纳您所面临的插入。)
我的答案是O(1)和O(log(n))，因为插入是任意的，并且提取-min，我们可以先
浏览 6提问于2015-03-02得票数 2
回答已采纳
2回答
存储桶排序是线性时间排序。
为什么我们要在其中使用插入排序？我们知道插入排序需要O(n2)时间。为什么我们不能在其中使用任何线性排序呢？正如我们所看到的，在每个存储桶中，我们使用插入排序O(n2)。桶排序的总复杂度是O(n)吗？为什么我们不使用O(nlogn)排序，如合并排序或快速排序？
浏览 3提问于2015-10-29得票数 2
如果列表是预先排序的(最好的情况)，我对shell排序的运行时间感到困惑。是O(n)还是O(n log n)？
for(k=n/2; k>0; k/=2)
for(i=k; i<n; i++)
for(j=i;j>k; j-=k)
if(a[j-k]>a[j]) swap
else break;
Shell排序是在插入排序的基础上进行的，对于预排序表，插入排序的运行时间为O(n)，但是通过引入间隙(最外层的循环)，不知道它是否使预排序表的执行时间为O(n log n)。
浏览 1提问于2012-02-17得票数 2
3回答
我有这样的代码，它以排序的顺序返回数组的平方，并试图确定它的时间复杂性。我在数据(O(n))中执行一个循环，然后使用合并排序(O(n log n))。我认为这意味着我在做n * n log n工作，所以这是n^2的复杂性。但是当我检查这个问题的答案时，这个函数的时间复杂度显然只是n log n。为什么会这样呢？
public int[] sortedSquares(int[] A) {
for(int i = 0; i < A.length; i++) {
A[i] = A[i] * A[i];
}
mergeSort(A);
浏览 4提问于2020-06-24得票数 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
4回答
O(nlogn)就地排序算法
、、、、
这个问题是在我的计算机科学入门期中考试准备的。
有一种算法可以在O(n)时间内找到列表中的kth元素，并假定它已经就位。使用该算法，编写一个在最坏情况下运行的就地排序算法O(n*log(n))，并证明了它的有效性。既然这个算法存在，为什么还会使用mergesort呢？
我假设我必须编写一些快速排序算法的替代形式，这是O(n^2)的最坏情况，因为合并排序不是就地算法。让我困惑的是在列表中找到kth元素的给定算法。通过数组的元素进行简单的循环迭代不是一个O(n)算法吗？
如果所提供的算法不改变执行时间内的任何内容，它如何能使排序算法的运行时间有任何不同？我不知道如何使用快速排序，插入排序或
浏览 3提问于2015-10-21得票数 2
我刚刚想到了一个问题，因为get(index)方法的linkedList方法的时间复杂度不是O(1)，而是O(N)，那么它会影响排序的时间复杂度吗？例如，下面的代码(气泡排序)：
public static void bubbleSort(int arr[])
{
int n = arr.length;
for (int i = 0; i < n-1; i++)
for (int j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1]) {
int tem
浏览 3提问于2020-12-04得票数 1
回答已采纳
1回答
如果我合并、排序一个数组并对其应用二进制搜索函数，时间复杂度会是多少？会是O(log n)吗？ 因为 o(log n) + o(n log n) = O(log n)
浏览 10提问于2020-07-16得票数 0
1回答
从零开始构建一个大小为n的平衡二叉树的复杂性是什么？
节点插入为O(log )。
然而，随着时间的推移，累积的时间是
O ( log 1) + (log 2) +.+ (log (n-1 ) ) + (log n) )
这“加起来”是什么意思？
它是o(n log(n))，小'o'，我不知道有多小。
浏览 5提问于2014-01-31得票数 0
回答已采纳
1回答
假设我有一个函数，将S、|S|=n划分为大小为subsetSize的S/subsetSize子集，并对每个子集进行排序：
partitionAndSort(Set s, int subsetSize) {
List partition = partitionList(s);
for(Set subset: partition) {
sort(subset);
}
}
这个功能的运行时间是多少？
partition显然采用了O(n)，因为我们一个接一个地遍历集合的元素。subsetSize被认为是一个常量，因此单个排序接受O(subsetSize*log(subse
浏览 3提问于2022-04-07得票数 0
回答已采纳
在sortedContainers中指定SortedList.add的时间复杂度大约为O(log(n))，但我们可以看到它在源代码中使用了insort()，即O(n)：
def add(self, value):
"""Add `value` to sorted list.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList()
>>> sl.add(3)
>
浏览 4提问于2021-06-09得票数 1
回答已采纳
我研究了二进制、二项式和斐波那契堆排序，我发现排序需要O(n log n)时间。如果有人能给我一个原因，为什么会这样，那就太好了。
浏览 35提问于2020-11-29得票数 2
6回答
我读过很多地方，对于像Merge-Sort和Quicksort这样的分而治之的排序算法，与其递归直到只剩下一个元素，不如在达到某个阈值时转移到Insertion-Sort，比如30个元素。这很好，但是为什么只有Insertion-Sort呢？为什么不是Bubble-Sort或Selection-Sort，它们都有类似的O(N^2)性能呢？Insertion-Sort只有在许多元素是预先排序的情况下才会派上用场(尽管Bubble-Sort也应该具有这种优势)，但除此之外，为什么它应该比其他两个更高效呢？
其次，在，在第二个答案和随附的评论中，它说O(N log N)的表现比O(N^2)差，直到某
浏览 1提问于2012-09-27得票数 6
回答已采纳
我正在试图理解如何从n个log^2，n个时间到n个日志n个时间的衣柜对算法。我得到以下部分(来自)
用l行将集合划分为两个相等大小的部分，并递归计算每个部分中的最小距离。
设d是这两个最小距离的最小值。
消除与l相距d以上的点
根据它们的y坐标对剩余的点进行排序。
按y顺序扫描其余的点，并计算每个点到其五个邻居的距离。
如果其中任何一个距离小于d，则更新d。
步骤4是一种占用O(n log n)时间的排序，它主导了所有其他步骤，为了使整个算法实现O(n log n)时间，需要将这一步骤降为O(n)。这是我很难理解的部分。作者提出
步骤1:将集合划分为.，递归计算
浏览 3提问于2016-12-30得票数 1
回答已采纳
谁能给我指出一些可靠的资源/文档，其中有一些关于不同复杂性类别的算法所花费的时间的真实讨论，例如O (log n), O (n), O(n log n), O(n^2), O(n^3)等。我特别对一些文档/站点感兴趣，它们可以回答以下问题：
给定机器配置(CPU、内存)，使用N个实例作为输入运行mergesort (或二进制搜索或其他标准算法)需要多少时间(以毫秒/秒为单位)，其中N可以从100到100万。
如果有人能给我一个文档，它不仅可以给我毫秒的时间，而且可以给我一个近似/启发式的能量成本，如果上面提到的一些算法在移动设备(智能手机)上运行，那就更好了。
浏览 0提问于2012-12-15得票数 0
3回答
我们知道，快速排序的性能平均为O(n*log(n))，但合并和堆排序的性能也平均为O(n*log(n))。所以问题是为什么快速排序的平均速度更快。
浏览 1提问于2010-11-27得票数 13
回答已采纳
2回答
二进制搜索与简单搜索
、、、
根据算法书，二进制搜索的性能为O(log )，而对于简单搜索则是O(n)。
但是，为什么我们不考虑排序所花费的时间，这是二进制搜索的先决条件？
浏览 0提问于2019-06-16得票数 2
回答已采纳
4回答
最坏情况时间复杂度列表
、、、、
我知道对于数组实现，二分查找的最佳、平均和最坏情况的时间复杂度分别为最佳O(1)；平均O(log )；最差O(log )；。同样，我知道对于数组实现，插入排序的最佳、平均和最坏情况的时间复杂度分别为最佳O(n)；平均O(n^2)；最差O(n^2)；。
然而，我该如何计算单链表、双链表和循环链表实现的二进制搜索和插入的时间复杂度呢？
浏览 1提问于2014-01-13得票数 0
研究大O表示法，我理解O(log n)作为二进制搜索和O(n log n)的快速排序的概念。
有人能把运行时与这两者之间的主要区别放在外行人的术语中吗？为什么是这样的呢？
从直觉上看，它们似乎是相似的。
浏览 4提问于2017-02-14得票数 23
回答已采纳
2回答
渐近符号有缺陷吗？
、、、
任何算法的最佳情况复杂度都是该算法完成其任务所需的最短时间。我们知道，合并排序、快速排序等算法的最佳情况复杂度是Ω(n log(n))，它定义了这些算法的下界。
我们知道，在渐近符号中-
O(n) + O(n log(n)) = O(n log(n))
还有，
Ω(n) +Ω(n log(n)) =Ω(n log(n))
因此，如果在这些排序算法中，我们首先在O(n)时间内遍历整个数组，以确定数组是否已经按升序或降序排序，则它们的平均情况和最坏情况的复杂性将保持不变。但它们的最佳情况复杂性现在将成为Ω(n)。
从逻辑上讲，在我理解这些渐近符号的方法上肯定有一个缺陷，否则，当渐近符号被开发或流行
浏览 2提问于2021-02-01得票数 2
1回答
什么时候对数组进行排序？
、、、
几年前，在一次求职面试中，我被问到:什么时候才能对数组进行排序？我记得我不能正确地回答，最近我上了一门算法课程，我得出的结论是，提供一个更“学术性”的回答可能会让我得到这份工作。无论如何，过去是不可能修复的，到目前为止，我正试图正式回答我自己，目前，这就是我所处的位置：
给定数组，搜索的时间将是
O(n)如果未排序
O(log(n))如果排序的话
考虑到O(n*log(n))中的快速排序
什么时候对数组进行排序？当然，这将取决于我们要搜索数组的次数。
排序数组中搜索x次的费用= O(n*log(n)) + O(log(n)) *x
未排序数组中搜索x次的费用= O(n)
浏览 3提问于2013-12-29得票数 8
我了解到，在Stream中，方法 sort ()可能使用合并排序(mergesort)。
然后将时间复杂度用于这类排序：
BigΘ (n (log n) )-最佳
BigΩ (n (log n) )-平均
大O (n (log n) )-最坏的
空间完备性-O (n) -最差
如果我们使用自定义对象的多个字段进行排序，使用then.comparing()构建比较链，那么时间复杂度是什么？
在这种情况下，你如何计算时间复杂度？
浏览 3提问于2021-04-20得票数 0
回答已采纳
2回答
基排序的时间复杂度为O(kn)，其中n是要排序的键数，k是键的长度。类似地，trie中插入、删除和查找操作的时间复杂度为O(k)。但是，假设所有元素都是不同的，难道不是k>=log(n)吗？如果是这样，则意味着基排序的渐近时间复杂度为O(nlogn)，等于快速排序，而trie操作的时间复杂度为O(logn)，等于平衡二叉树的时间复杂度。当然，常数因素可能有很大的不同，但渐近时间复杂性不会。这是真的吗?如果是这样的话，基数排序和尝试比其他算法和数据结构有其他优势吗？
编辑：
Quicksort和它的竞争对手执行O(nlogn)比较；在最坏的情况下，每个比较将花费O(k)时间(键只在最后检查
浏览 3提问于2011-07-31得票数 3
回答已采纳
1回答
对字形进行分组
、、
给定单词数组，对字谜IP:{tar，rat，banana，atr} OP:{tar，rat，atr，banana}进行分组
这个问题的一个解决方案是使用哈希表。考虑每个单词，对其排序，如果不存在则将其作为关键字添加到哈希表中。键的值将是具有相同键的所有字形的列表。我想知道时间复杂度，为了对数组中的字符进行排序，假设O(n log n)要存储在哈希表中，那么它将是O(n)，总共O(n*nlogn)。
有没有更好的算法？时间复杂度更低？
浏览 0提问于2013-07-30得票数 2
2回答
我在分析最小生成树，并想知道排序时间如何影响Kruskal算法的总体时间复杂度？
示例：
如果可以在O(n log log n)中进行排序
如果可以在O(n)中进行排序
对于这两种情况，答案仍然是O(e log n)，还是会改变？
浏览 1提问于2014-11-11得票数 2
在我的课本上，有人告诉我排序问题的时间复杂度是θ(n*log(n))。但是，很容易说明基数排序是O(n)。这不是与所说的相矛盾吗？排序问题的时间复杂度下限不是这样的θ(n)吗？
编辑: StackOverflow不允许我在标题中使用"problem“，所以"problemo”必须保留。
浏览 9提问于2017-12-13得票数 2
回答已采纳
归并排序的时间复杂度为O(n log n)，因此n在logn上占主导地位，归并排序的时间复杂度为O(N)
谢谢
浏览 0提问于2015-03-25得票数 0
1回答
这不是家庭作业问题。我正在为一次面试做准备，并且对这个上的链接做了很多研究。我根据一项建议编写了一个解决方案，但我不同意提议的时间复杂性。我想知道我的断言是否不正确。
下面是一个函数，用来吐出一组字谜。它对每个输入单词进行排序，并将排序后的输入单词放入字典中。我自己编写的代码是基于发布的一条提示编写的，提示如下：
使用排序:我们可以对字符串数组进行排序，以便所有的字谜集合在一起。然后通过线性遍历排序数组来打印所有的字谜。该解决方案的时间复杂度为O(mnLogn) (我们将在排序中进行O(nLogn)比较，而比较则需要O(m)时间)。其中n是字符串的数目，m是字符串的最大长度。
我不同意
浏览 1提问于2020-03-04得票数 0
回答已采纳
4回答
将流式数据读取到排序列表中
、、、、
我们知道，一般来说，“更智能”的比较是在最坏情况下复杂度为O(N * log(N))的任意数据上进行排序的。
我的问题是，如果我们被要求不对集合进行排序，而是对数据流进行排序，会发生什么。也就是说，值是一个接一个地给我们的，没有指示接下来会发生什么(除了数据是有效的/在范围内之外)。直观地说，人们可能会认为，在数据进入时对其进行排序(就像一个接一个地拿起扑克牌)要优于收集所有数据并稍后进行排序(在发完牌后对扑克牌进行排序)。真的是这样吗？
收集和排序将是O(N +N* log(N)) = O(N * log(N))。然而，如果我们对它进行排序，它是O(N * K)，其中K=找到适当索引的时间+
浏览 1提问于2011-07-04得票数 1
回答已采纳
6回答
使用红黑树进行排序
、、、
在red-black tree上插入的最坏情况运行时间是O(lg n)，如果我在树上执行in-order walk，实际上我访问每个节点，所以打印排序的集合的总最坏情况运行时间将是O(n lg n)
我很好奇，为什么在排序时red-black trees不比quick sort (它的平均运行时间是O(n lg n) )更受欢迎。
我看到这可能是因为red-black trees没有就地排序，但我不确定，所以也许有人可以帮助我。
浏览 0提问于2010-07-17得票数 14
回答已采纳
1回答
树排序性能
、、、
我有一个AVL树实现，其中插入方法的运行时间为O(log )，返回有序列表表示的方法的运行时间为O(n^2)。如果我有一个需要排序的列表。通过使用for循环，我可以遍历列表并将每个元素插入到AVL树中，该树的运行时间加起来为O(n log n)。那么整个排序算法(即遍历列表，插入每个元素，然后使用顺序遍历返回排序列表)的性能如何呢？
浏览 18提问于2021-05-07得票数 0
1回答
若要在n个字符的字符串上构建后缀数组，
我们首先生成n个后缀O(n)
然后对它们进行排序O(n log n)
总时间复杂度为O(n) + O(nlogn) = O(nlogn)。
但我读到它是O(n^2 log n)，我不明白它是怎么回事。谁能解释一下吗？
浏览 1提问于2014-02-23得票数 0
1回答
为什么选择排序的最佳时间复杂度是O(n)，而插入排序和冒泡排序的最佳时间复杂度是O(N)？它们的平均时间是相同的。我不明白为什么最好的情况时间是不同的。会很感谢你的帮助。
浏览 0提问于2017-04-09得票数 7
回答已采纳
1回答
我想实现至少两种不同的解决方案，用O(N*log(N))的平均时间复杂度在大O表示法中找到N-最大元素，其中N是列表中的元素数？
对于O(N*log(N))，我应该在java程序中使用哪种搜索算法来查找n个最大元素？
浏览 4提问于2014-01-02得票数 0
回答已采纳
4回答
根据，基于分区的选择算法(如quickselect )具有O(n)的运行时，但我对此并不信服。有人能解释一下为什么是O(n)吗
在通常的快速排序中，运行时是O(n log n)。每次我们将分支划分为两个分支(大于支点和小于支点)时，我们都需要在中继续处理两个分支，而quickselect只需要处理一个分支。我完全理解这些观点。但是，如果您在二进制搜索算法中考虑，在我们选择中间元素之后，我们也只搜索分支的一个一侧的。那么，这是否使算法O(1)呢？不，当然，二进制搜索算法仍然是O(log N)而不是O(1)。这与二进制搜索树中的搜索元素也是一样的。我们只搜索一个端，但我们仍然考虑O(log n)而
浏览 4提问于2012-01-09得票数 47
回答已采纳
我在学校被分配了一个排序算法，我们的任务是回顾几种排序算法。报告的其中一节与“何时简单排序更快”有关。
我所拥有的排序算法是：
气泡分类
选择排序
插入
均为O(n^2)平均
然后，我有以下O(n log )算法：
合并排序
快速排序
和基类O(kn)
我已经对未排序和排序的数据进行了几次测试，从10到100,000的n个条目不等，而且复杂排序O(n log )总是在更快的时间内执行。
我还尝试使用包含n个元素的排序数据集，其中n= 10到100,000。
但是，O(n log )算法仍然更快。
所以我的问题是，什么时候简单的排序比复杂的快。
谢谢克里斯。
浏览 8提问于2014-02-26得票数 1
回答已采纳
在说“这是以前问过的”或“找一本算法书”之前，请继续阅读并告诉我我的推理中哪一部分出了问题？
假设你有n个中间包，你把它们分成k个箱子，这需要O(n)时间。但是，需要对每个k桶进行排序，如果对每个桶使用快速排序--这是一个O((n/k)_log(n/k))操作，那么这个步骤将采用O(n_log(n/k)+k)。最后，需要组装这个数组，这需要O(n+k)，(参见)，所以总的操作将是O(n+n_log(n/k)+k)。现在，这个n_log(n/k)是怎么消失的，我一点也不明白。我猜想有一些数学在进行，它消除了这个n*log(n/k)。有人能帮忙吗？
浏览 7提问于2011-11-07得票数 5
2回答
快速排序算法可分为以下步骤
1)确定枢轴。
2)基于枢轴的链表划分。
3)递归地将链表划分为两部分。
现在，如果我总是选择最后一个元素作为枢轴，那么识别pivot元素(第一步)需要O(n)时间。
在识别了pivot元素之后，我们可以存储它的数据并将其与所有其他元素进行比较，以确定正确的分区点(第二步)。当我们存储枢轴数据时，每个比较将花费O(1)时间，而每个交换则需要O(1)时间。因此，总的来说，n个元素需要O(n)时间。
所以递推关系是
T(n) = 2T(n/2) +n，为O(nlogn)，与链表合并排序相同。
那么，为什么对于链接列表来说，合并排序比快速排序更可取？
浏览 5提问于2017-11-30得票数 1
回答已采纳
5回答
这是我最近在一次面试中被问到的一个问题。给出了一个二叉树，条件是每个左子比根小1，右子大于1。这是一个示例树
按O(1)和O(n)时间复杂度对其进行排序。
以下是我建议的方法：
使用计数来保持每个元素的计数，然后在完成整个遍历之后返回O(n)时间和O(n)空间复杂度。
使用游程长度编码。当以数字作为键，计数作为值重复元素时，形成一个链。只有当no被重复时才需要用于计数的空间，因此除了数组之外不需要额外的空间，但是时间复杂度将是O(n log )，因为我们必须遍历数组来查看它是否存在。
最后，我建议宽度优先遍历。我们需要队列的O(log )空间和O(n)时间复杂度(假设插入为O
浏览 5提问于2013-03-29得票数 15
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
