是否存在表示主操作时间为O(n*log )的有序列表的数据结构？
是的，存在表示主操作时间为O(n*logn)的有序列表的数据结构，这个数据结构就是平衡二叉搜索树（Balanced Binary Search Tree），也被称为平衡二叉排序树（Self-Balancing Binary Search Tree）。
平衡二叉搜索树是一种特殊的二叉搜索树，它通过自动调整树的结构来保持树的平衡，从而保证了插入、删除和查找等操作的时间复杂度为O(logn)。常见的平衡二叉搜索树包括红黑树（Red-Black Tree）、AVL树、B树等。
优势：
- 快速的插入、删除和查找操作：平衡二叉搜索树的主要优势在于它能够在O(logn)的时间复杂度内完成这些操作，使得处理大量数据时效率更高。
- 有序性：平衡二叉搜索树中的元素按照一定的顺序排列，可以方便地进行范围查找、前驱后继查找等操作。
- 动态性：平衡二叉搜索树支持动态的插入和删除操作，可以随时调整树的结构以保持平衡。
应用场景：
- 数据库索引：平衡二叉搜索树常被用作数据库索引的底层数据结构，可以快速地定位和检索数据。
- 路由表：在网络路由中，平衡二叉搜索树可以用来存储路由表信息，实现快速的路由查找。
- 缓存淘汰策略：平衡二叉搜索树可以用来实现缓存淘汰策略，根据访问频率和时间等因素进行数据的淘汰和替换。
腾讯云相关产品： 腾讯云提供了云数据库 TencentDB for MySQL，它支持在云上部署和管理MySQL数据库，可以作为存储平衡二叉搜索树数据结构的选择。您可以通过以下链接了解更多关于腾讯云数据库的信息：https://cloud.tencent.com/product/cdb
相关·内容
2回答
由
向量:末端的插入是常数，摊销时间，但其他地方的插入是昂贵的O(n)。
list :您不能随意访问元素，因此获取列表中的特定元素可能会很昂贵。
我需要一个容器，这样您就可以在O(1)时间的任何索引上访问元素，但也可以在O(1)时间的任何索引处插入/删除元素。它还必须能够管理数以千计的条目。有这样的集装箱吗？
编辑:如果不是O(1)，一些X << O(n)？
浏览 5提问于2020-05-04得票数 4
回答已采纳
我想要一个数据结构，在其中插入元素，在插入之后，它将保持排序，并找到我刚刚插入的log时间中元素的索引。
我尝试过使用向量和多集，但两者都不能满足这两个要求。
向量：
如果我想找到元素的索引，我可以：
using namespace std;
vector<int>::iterator it = lower_bound(myvec.begin(), myvec.end(), someElement);
int index = (it - myvec.begin());
但是，向量在保持排序的同时不允许O(log )插入时间。每次插入后的向量排序为O(N log )。我试过：
vec
浏览 1提问于2020-01-07得票数 2
2回答
许多快速优先级队列(如和)都支持减键操作，该操作采用已存储在优先级队列中的元素，并有效地降低其优先级。在Fibonacci和配对堆的情况下，执行decrease key比从优先级队列中删除元素，然后重新插入它更快。
我想知道是否可以在有序字典结构(二进制搜索树、跳过列表等)上支持类似的操作。具体地说，假设我有一个有序的字典，并希望将某个键/值对的键更改为不同的键。是否有可能在O(1)或O(log log n)时间内对有序字典的任何标准表示形式执行此操作？我很好奇，因为使用平衡的BST，通过删除元素并重新插入它，可以在O(log )时间内完成这一点，但似乎有一种更快的方法可以做到这一点。
谢谢!
浏览 5提问于2013-01-06得票数 8
回答已采纳
是否有已知的标准数据结构，它是使用二叉树解析冲突的哈希表？如果是的话，这个数据结构的名称是什么？我认为这种结构是有用的，因为与散列表中的O(n)相比，它应该将最坏的情况搜索时间降到O(log(n))，最好的情况仍然是O(1)。
浏览 0提问于2014-06-27得票数 2
如何从二叉树中寻找最小元素
制约因素有：
时间复杂度必须是O(1)
不应使用额外的空间
我已经尝试过两种方法了。
进行有序遍历和寻找n个元素-时间复杂度O(n)
坚持不。比当前节点更小的元素和具有m个小元素的查找元素-时间复杂度O(log n)
浏览 4提问于2015-06-09得票数 2
4回答
所以我的数据结构类涵盖了时间复杂性，我只想问一个关于arraylist和treemap的性能的问题。
ArrayList的get方法是O(1)，TreeMap的get方法是o(log )
现在，如果我创建了一个遍历整个列表或树的循环，比如
for (int i = 0; i < blahblah.size(); i++)
{
blah blah
}
对于arraylist，这个循环性能是o(1)还是o(n)？我意识到，当你检索1个项目时，性能是O(1)，但是这个循环遍历整个列表，所以它不是1* n个项目，这将使它成为n吗？
树地图也是一样，它是o(log n)还是n log n，因为
浏览 0提问于2011-03-05得票数 0
1回答
我有日志( n)成对排序的子序列(长度可能不同)，我需要在O(n日志日志n)中排序，但我不知道如何排序。我已经考虑过使用合并排序，但是时间复杂度为O(n log )。
浏览 0提问于2018-11-04得票数 0
回答已采纳
可能重复：
是否有一种方法可以创建一个模仿JavaScript集的c++数据结构？我需要在log(n)时间内执行搜索，但是在语言中找不到任何服务良好的东西。我看到了几个问题，说我应该把这个集合表示为一个对象。那能行吗？数组的键和有效载荷是数字。
浏览 4提问于2012-08-14得票数 0
1回答
我有这段代码：
int f = 0;
for(int i=1 ; i<m ; i=i*2) {
for(int l=500 ; l<700 ; l++) {
f++;
}
for(int j=n ; j>0 ; j=j/2) {
f++;
}
for(int k=0 ; k<m ; k=k+3) {
f++;
}
f += 10;
}
其中，m和n作为参数给出。
到目前为止，我已经计算了以下内容：
主循环按指数递增，这意味着它的时间效率是O(log m)
第一个f
浏览 5提问于2014-11-09得票数 1
1回答
(O(n)，O(log n))方法是否足以解决这个问题- ？
(更新时间- O(n)，查询时间- O(log n))
我的解决方案-使用上述方法解决(使用段树)被Codechef法官判断为“TLE”提交。
我甚至尝试了一种(O(log )，O( n) )方法来解决这个问题(更新时间- O(log )，查询时间- O( n) )，但是即使这也被Codechef法官拒绝了，因为它超过了时间限制。从现在起我不知道从这里往哪里走。这是我第二次提交的链接--
任何已经解决了这个问题的人都被要求在这方面帮助我。我能做(O(lgn)-O(lgn))吗？多么?
提前谢谢。
浏览 3提问于2011-05-31得票数 0
1回答
据我所知，不能对无序数组进行二进制搜索。我还了解到，有序数组中二进制搜索的复杂性是O(log(n))。
我能问问吗
有序数组的二进制搜索(插入)的复杂度是多少？我从一本教科书上看到，它的复杂性是O(n)。为什么它不是O(1)，因为它可以直接插入，就像线性搜索一样。
既然二进制搜索不能在无序列表中完成，那么为什么可以在复杂的O(N)中进行插入呢？
浏览 3提问于2016-04-10得票数 3
回答已采纳
1回答
我使用一个排序列表对二进制搜索值使用内置的二分模块，这使查找时间为O(log )。二分法的文献指出，用insort()插入总时间为O(n)，在列表中占主导的插入时间。它的删除时间为O(n)。
是否有一种使用列表并让O(log )插入、删除和查找的方法？我能用一个平衡的二叉树(BST)像红黑树那样做吗？哪个Python3模块具有具有这些属性的数据结构？
注意:我已经看到PyPI上有一个包二叉树，它有RBTree和AVLTree，但是它被放弃了，它们的文档指向使用排序容器库。据我所见，分类容器没有这些树供使用(它们是用C写的，是SortedList、SortedDict和SortedSet的基础)
浏览 7提问于2019-10-27得票数 2
回答已采纳
3回答
Swift有排序的集合类型吗？如果没有，如果我想使用它，我有什么选择？
如文档所示，标准库的Set是无序的：
数组是值的有序集合。集合是具有唯一值的无序集合。字典是键值关联的无序集合.
然而，许多适合实现有序集(和字典)的数据结构是众所周知的，特别是 (如 )。
例如，c++的stl具有和map，并允许使用下限和上限对它们进行范围查询。
我知道可以将集合的成员排序到数组中，但我需要的是具有O(log(n))插入、删除和查询的数据结构。
浏览 5提问于2017-10-02得票数 30
回答已采纳
优先级队列:基本操作:插入删除(Delete minumum元素)
目标:为上述功能提供高效的运行时间或增长顺序。
通过：实现优先级队列：
Linked List: Insertion will take o(n) in case of insertion at end o(1) in case of
insertion at head.
Delet (Finding minumum and Delete this ) will take o(n)
BST:
Insertion/Deltion of minimum = In av
浏览 7提问于2012-05-29得票数 2
回答已采纳
1回答
示例算法1：我有一个结构数组(PaymentReceipt[] paymentReceiptList;)，假设大约有1000个被推送的项和数组的大小保持增长。每个项目都有一个time_start和time_end值。在我的契约函数中，我必须将所有这些成员迭代到检查给定的一组间隔之间是否有任意两个间隔重叠，这是O(n)时间。
示例算法2：我使用一个计算n Fibonacci数的算法函数来找到第1000个值。这是一个递归函数，用于计算第n个Fibonacci数，其时间为O(log(n))。
对于Algorithm_1，有一个小集合，对于Algorithm_2，如果nth值很小，应该没有问题。但是A
浏览 0提问于2017-01-26得票数 2
回答已采纳
2回答
链表的搜索算法是否有可能是O(Log N)？根据我的理解，链接列表可能有O(n)或O(1)，因为您可以选择从哪里开始，从链接列表开始到结束。知道了这一点，你能从中间开始寻找一个在O(Log)时间内运行的搜索算法吗？
浏览 4提问于2021-04-13得票数 2
回答已采纳
1回答
JavaScript阵列的大O
、、、、
JavaScript中的数组很容易通过添加和删除项来修改。它在某种程度上掩盖了这样一个事实:大多数语言数组都是固定大小的，需要复杂的操作来调整大小。JavaScript似乎使编写性能不佳的数组代码变得容易。这就引出了一个问题：
我可以期望JavaScript实现在数组性能方面的性能(在大的O时间复杂度方面)？？
我假设所有合理的JavaScript实现最多都有以下的大O。
出入- O(1)
附加- O(n)
预演- O(n)
插入- O(n)
删除- O(n)
交换- O(1)
JavaScript允许您使用new Array(length)语法将数组预先填充到
浏览 2提问于2012-07-16得票数 122
回答已采纳
我正在为一门算法课程自学，并试图解决以下问题：
描述用于存储一组实数的数据结构，这些实数可以在O(1)摊销时间内执行下列每一项操作：
Insert( x )：删除不大于x的所有元素，并将x添加到集合中。
FindMin()：找到集合的最小值。
我意识到，一旦插入，findmin就变得很简单，并且看看如何使用链接列表实现可以同时删除多个元素(即O(1))，但找出要删除的链接(也就是x所在的位置)似乎是一个O(n)或O(log )操作，而不是O(1)。这个问题给出了一个提示:考虑使用堆栈，但我看不出这有什么帮助。
任何帮助都是非常感谢的。
原来的问题如下：
浏览 3提问于2014-05-29得票数 3
回答已采纳
我遇到了以下非常困难的面试问题：
考虑具有三个操作的队列数据结构：
添加到列表的前面(注意列表前面)-从列表的尾部删除(列表的末尾)-提取Min (删除)
这个数据结构中最好的implementation是摊销时间。
( A)在O(1)进行三次行动
( B)在O(log n)进行三次行动
C)在O(1)中添加和删除，在O(log n)中添加和删除-min。
D)在O(log n)中添加和删除(Log N)，在O(n)中添加和删除(Min)。
面试后，我发现(C)是正确的答案。为什么是这种情况？
第一个挑战是比较选项:哪个选项比其他选项更好?我们如何才能理解最终的正确选
浏览 11提问于2021-01-08得票数 22
1回答
我想练习一下数据结构。因此，假设我有一个(动态数组、链接列表、双链接列表、搜索树、哈希表)。所以我在想
，其中哪一个需要最少的内存。我想这是一个哈希表
的实现要求搜索值的时间复杂度为O(log )。我会说这是一棵搜索树。
的实现通常适合于序列的实现。链接列表？
我只是在检查自己，只是想知道我是否想错了。提前谢谢你。
浏览 1提问于2021-05-25得票数 1
回答已采纳
此示例演示如何确定元素应插入到排序列表中的索引位置。尽管binarySearch()用于定位已存在的元素，但它也可用于确定不存在的元素的插入索引。
// Create a list with an ordered list of items
List sortedList = new LinkedList();
sortedList.addAll(Arrays.asList(new String[]{"ant", "bat", "cat", "dog"}));
// Search for the non-existent it
浏览 2提问于2010-11-20得票数 0
3回答
原来的问题是：
设计了一种O(N log )算法来读取单词列表，并打印出所有的字谜。例如，弦乐“喜剧演员”和“妖魔怪”是彼此的暗喻。假设有N个单词，每个单词最多包含20个字母。设计一个O(N^2)算法不应该太困难，但是将其归结为O(N log N)需要一些技巧。
我很困惑，因为一个单词的长度不取决于N，它是一个恒数20，所以我认为我们可以把一个单词的运行时间乘以N，所以结果是O(N)。然而，我似乎错过了什么。
浏览 8提问于2021-12-17得票数 2
1回答
根据我对主定理的理解，一个算法可以递归地定义为：
a T(n/b) + O(n^d)
其中a是子问题的数量，n/b是子问题的大小，O(n^d)是子问题的重组时间。计算主定理的时间复杂度如下：
T(n) = { O(n^d) if d > log base b of a
{
{ O(n^d log n) if d = log base b of a
{
{ O(n^ (log base b of a) ) if d < log base b of a
我
浏览 0提问于2013-05-17得票数 3
回答已采纳
是否有一种类似集合的数据结构支持O(logn)时间内的合并和O(logn)时间内的第k个元素搜索？N是这个集合的大小。
浏览 13提问于2010-10-26得票数 3
回答已采纳
1回答
我想知道，在下面的标准和时间(可能是复杂的)下，会有这样的数据结构吗？
如果我们获得一个未排序的列表L，就会生成一个数据结构，如下所示：
构建(L，X) -在O(n)时间内，我们从n个元素的未排序列表构建结构S
在O(lg n)下插入(y，S)，我们在结构S中插入z
DEL-MIN(S) -在O(lg n)下，我们从S中删除极小元素
DEL-MAX(S) -在O(lg n)下，我们从S中删除极大元
在O(lg n)下，我们从S中删除上内侧(天花板函数)元素。
问题是列表L没有排序。这样的数据结构能存在吗？
浏览 0提问于2018-04-21得票数 0
回答已采纳
我正在搜索在Erlang中进行二进制搜索的可能解决方案，我找到了，但我想知道blog中的解决方案是否运行在O(lg )。现在，由于二分查找的递归是:T( n) = T(n/2) +c，这给出了O(lg )的执行时间。
因为在C数组中，您可以在O(1)时间内访问任何元素。但在erlang中，如果访问列表的中间位置需要cn时间，那么二进制搜索在线性总体时间内运行的性能与线性搜索一样差。
我遇到了列表: nth /2BIF，用于查找列表中的第n项，但我不确定它的执行时间。
有什么意见吗？
浏览 0提问于2010-09-08得票数 5
回答已采纳
3回答
大O符号在计算机科学中的对数？
、、、、
我一直有这个问题在我的脑海中，从来没有能够联系这两个概念，所以我寻求一些帮助理解对数在计算机科学有关的大-O符号和算法的时间复杂性。我把对数理解为数学概念，因为它能够回答以下问题：“我需要把这个基数提高到指数级才能得到X?”例如，log2( 16 )告诉我们，我们需要提高2到4次方才能得到16。我还知道O(log n)算法比O(n)和其他较慢的算法(如指数算法)更快，并且O(log n)算法的一个例子是搜索一个平衡的二进制搜索树。
我的问题有点难以准确表述，但我认为它归结为为什么要搜索平衡的BST对数，是什么使它成为对数，以及我如何将数学对数与CS术语的使用联系起来？接下来的问题是O(n lo
浏览 0提问于2018-03-24得票数 0
2回答
用于快速交叉操作的数据结构？
、、、、
随机选择两个集合，两个集合都包含不同的键(一个键可能属于多个集合，一个集合不能包含重复的键)。
返回一个整数，该整数表示属于这两个集合的键数。
例如，相交({1，2，3，4}，{3,4,5})返回2。
我只需要交叉口的大小，.I不需要确切知道交叉口中有哪些键。
在小于O(n)时间的中，是否有任何数据结构支持这种操作？
编辑：
读取数据确实需要O(n)时间，但不会得出结论，即不能在小于O(n)时间的中执行交叉操作。
想象一下这个场景：
我有N组，每个包含100个键。我把它们读了起来，那是N*100运算.Now，我想知道女巫对集合有最大的交集，那就是O(N平方)交叉口操作.So，我想降低交叉口运算
浏览 8提问于2016-08-25得票数 6
回答已采纳
(我是数据库新手，如果这是个奇怪的问题，我很抱歉。如果你认为我的想法不太清楚，可以不同意我的观点。)
一些数据结构支持比O(n)时间更好的操作，其中n是当前存储在结构中的项数。例如，允许O(log n)插入和删除项。我不明白在数据库中存储这样的数据结构的正确方法。
问题:对于一般的数据库，特别是关于Django 2.2.7和Postgres 12.0，当需要比O(n)操作更快的时候，存储数据结构的正确方法是什么？
这个问题的其余部分是详细阐述和讨论。
例如，假设我们的数据库由两个表组成，一个称为Person，另一个称为Task。每个Task都有一个名为assignee的关联Person
浏览 0提问于2019-11-14得票数 2
2回答
对于二进制堆，插入有O(log(n))，删除min有O(log(n))，堆构造可以在O(n)中完成。
在使用Djikstra中的二进制堆的上下文中，我的试卷涉及堆中的一个“更新”，其中更改了顶点的优先级。
我假设这个更新的时间复杂性将是O(n)，因为在我看来，在堆中定位顶点需要按照线性搜索的顺序，然后是上堆或下堆。这将是O(n + log(n))，它就是O(n)。
不幸的是，我认为这使我得出了错误的答案。
那么，二进制堆中优先级更新的实际时间复杂度是多少？
浏览 0提问于2015-11-16得票数 9
2回答
实现智能列表
、、
我被要求设计一个名为“智能列表”的数据结构，该结构包含带有真实密钥号的项，并提供了接下来的操作：
Insert(x) -向列表插入一个新元素。应该在O(log n)中。
删除min/max -删除并返回列表中的min/max元素。应该在O(log n)时间内。
Transform -更改remove min/max的返回对象(如果是min，则改为max，相反)。应该在O(1)中。
随机样本(K)-返回从列表中随机选择的k元素(k大于0，小于n)。应该在O(min(k log k，n+ (n-k) log (n-k))中)。
关于结构的假设:数据结构在任何阶段都不能容纳超过3n个元素。我们不能假
浏览 3提问于2014-05-31得票数 1
是排序数组中成功的二进制搜索和二进制搜索树中相同的O(log (n))的平均时间复杂度
另外，最坏情况下的时间复杂度对两个O(n)都是相同的吗？
当绘制一个图的邻接列表时，这个问题的顺序是什么？例如，改变这种情况是否是错误的：
为此(请注意第一行如何切换2和3)：
浏览 2提问于2016-05-08得票数 1
回答已采纳
2回答
我的意思是，实现只能独立地分配少量(O(1)/O(log ))内存--队列的大部分数据必须在哈希表中。
编辑:这个数据结构应该支持(Push，Pop，Top，Len)操作，但是在幕后，它将使用哈希表而不是链接列表/数组。所需的大部分O(n)内存将包含在哈希表中。
浏览 1提问于2018-12-04得票数 0
回答已采纳
来自redis医生：
ZPOPMIN密钥计数可从5.0.0开始。
时间复杂度: O(log(N)*M)，N是排序集中的元素数，M是弹出的元素数。
移除并返回存储在键处的排序集中得分最低的成员。
所以，我的问题是，如果列表是排序的，为什么要取log，为什么不是O(1)？
浏览 0提问于2019-01-26得票数 0
回答已采纳
2回答
我有一个排列有序的N个元素数组，它们都分布在K个列表中，这也是排序的。什么是时间复杂性(以最严密的大-O符号)：
移除最小的元素。
移除最小元素后的吸收数组。
除去所有N元素
对于第一部分，我认为答案是O(1)，因为最小的元素是第一个元素。但这份清单并不一定是第一份清单，所以我不确定。
对于第二部分，我不确定(也许是O(NK)?)
对于第三部分，它必须是O(N)，因为我们正在遍历整个数组，但是，我还是不确定
浏览 0提问于2019-02-04得票数 0
回答已采纳
2回答
我有一个很大的列表，列出了一些按概率排序的元素：
data class Element(val value: String, val probability: Float)
val sortedElements = listOf(
Element("dddcccdd", 0.7f),
Element("aaaabb", 0.2f),
Element("bbddee", 0.1f)
)
现在我需要在这个列表上执行前缀搜索，以查找以一个前缀开头，然后是下一个前缀的条目，依此类推(元素仍然需要按概率排序)
val filter
浏览 24提问于2019-08-13得票数 2
1回答
On a singly circular ordered list having N elements and
if M elements are to be inserted what will be the complexity of time?
a) O(M*N)
b) O(M*(M+N))
c) O((M+N) * log(M+N))
我认为，完成这项工作所花费的时间应该是O(N + M)。因为我们需要O(N)查找最后一个元素，O(M)在它之后插入所有元素，所以链接将使用O(1)。
而且，我觉得Ordered这个词有点混乱，是Sorted还是Preserving Natur
浏览 1提问于2019-11-19得票数 0
是否有任何数据结构可以提供O(1) -即常数插入复杂度和O(log(n))搜索复杂性，即使在最坏的情况下也是。
排序向量可以进行O(log(n))搜索，但是插入需要O(n) (假设我并不总是在前面或后面插入元素)。而列表将执行O(1)插入，但不能提供O(log(n))查找。
我不知道这种数据结构是否能够实现。
浏览 4提问于2016-11-05得票数 6
看看上的文档，我看不出有什么办法。理想情况下，我希望能够在SortedSet<int>时间中找到O(log(n))时间的中值(中间元素或两个中间元素的和)(显然，我知道我可以通过转换到列表或数组来在O(n)时间找到它)。
浏览 3提问于2017-01-28得票数 1
回答已采纳
2回答
目录
问题陈述
阐述和实例
访问的资源
答案(已张贴)
跟进问题(如所设想的那样)
问题
在计算“空间(内存)复杂性”的大O样式表示法时，如何考虑基元类型的大小？
阐述和实例
如果我分配一个数组N个元素的长度，并且每个元素是一个32位整数，那么我大概已经分配了大约N*32位。据我理解，这种分配的内存复杂性被认为是O(N)。
使用上面的示例，如果我将数组中的每个元素视为指向唯一链接列表的指针，其中链接列表的长度为1(包含1个节点和一个空指针)，并且该节点的数据段也是一个32位整数，那么我现在很清楚地分配：
32位阵列元件
32位链表数据
32位链表空指针
浏览 4提问于2013-11-21得票数 2
2回答
我有个任务听起来是这样的：
设A是一个有n个元素的排序列表。我们希望将一些元素添加到A中，以便对整个列表进行排序。
(i)给出一个O(n)-algorithm，它将O(1)元素添加到A中，并返回排序列表。
(ii)给出一个O( n) -algorithm，它将O(log )元素添加到A中，并返回一个排序列表。
我理解如何使用大O表示法来描述时间和空间复杂性(在任务中，我假设这两个部分都要求时间复杂度为O(n))，但在这个任务中，它似乎描述了too.It的元素数量，这是很难理解的。有人能解释如何解释"O(1)“的"O(log n)”部分吗？
编辑：，您有什么建议吗?我应该使用什么
浏览 7提问于2020-01-07得票数 0
回答已采纳
在C++ std::set (通常使用红黑二进制搜索树实现)中，元素会自动排序，任意位置的键查找和删除需要时间O(log )分期，即当大小变得太大而无法满足当前容量时忽略重新分配。
在排序的C++ std::vector中，查找也是快速的(实际上可能比std::set__快一点)，但是插入比较慢(因为保持排序需要时间O(n))。
但是，已排序的C++ std::vector还有另一个属性:它们可以快速找到范围内的元素数(在时间O(log )中)。
也就是说，排序的C++ std::vector可以快速回答:给定的x，y之间有多少个元素？
std::set可以快速找到迭代器到范围的开始和结束，但
浏览 4提问于2021-10-28得票数 2
回答已采纳
2回答
我有一个关于10^5英语单词的列表，以及它们的初始频率。我想要写一个单词完成建议程序，它将返回一个最大的k单词列表，从一个给定的前缀开始，按其频率的降序排序。数据结构还应该能够将单词的频率计数更新为1(每当使用一个单词时)。
例如，给定'engin‘作为前缀和k = 3，它应该返回这样的列表- {17，"engine"}，{10，"engineer"}，{4，"engineering"} }
k的值应该在1，15以内。
如果按频率排序不是问题，那么Trie数据结构就应该足够了，但事实是这样的。有人能提示我任何数据结构或解决这个问题的方法吗
浏览 4提问于2014-09-29得票数 0
3回答
超集搜索
、、、、
我正在寻找一种算法，在合理的时间内解决以下问题。
给出了一组集合，找出所有这类集的子集.
例如，如果您有一组搜索词，如“堆栈溢出”、"foo bar“、.，则在给定文档D时，查找所有单词均以D表示的搜索词。
我找到了两个适当的解决办法：
使用位向量列表作为索引。若要查询给定的超集，请为其创建一个位向量，然后对列表中的每个向量执行按位或执行的列表迭代。如果结果等于搜索向量，则搜索集是由当前向量表示的集合的超集。该算法是O(n)算法，其中n是索引中的集合数，按位OR是非常快的。插入是O(1)。警告:为了支持英语中的所有单词，位向量需要几百万位长，并且需要有一个单词的总顺序，没有空白。
浏览 4提问于2009-08-11得票数 9
回答已采纳
在搜索无序列表中的特定元素时访问的节点的平均数量是多少？在一个有序的名单里？一个有序的数组？请注意，列表可以作为链接结构或在数组中实现。
我认为答案是：
无序列表:n/2ordered:n/2无序数组:n/2有序数组：(log n)，因为可以二进制搜索数组。<代码>G 211</code>
有序数组和有序列表有什么区别？为什么一个有序的列表不能成为一个二叉树？
浏览 1提问于2020-02-24得票数 0
回答已采纳
1回答
在(max)堆中，很容易在O(1)时间内找到最大的项，但是要实际删除它，需要O(log(n))的复杂性。
那么，如果堆中的插入和删除都是O(log(n))，那么堆对于表示优先级队列的二叉树有什么好处？
浏览 0提问于2013-03-26得票数 8
1回答
刚刚对Shor的算法和下面的方程进行了研究，
O\big(\big(\log N\big)^2 \big(\log \log N\big)\big(\log \log \log N\big)\big)
因为它的时间复杂性。但是，对于大多数小值来说，这是负值，在1\cdot 10^{10}中为0。
为什么会这样呢？
浏览 0提问于2018-10-14得票数 1
回答已采纳
流API文档说：
某些流源(如List或数组)是本质有序的，而其他流源(如HashSet)则不是。
Arrays.stream()方法的时间复杂度是多少？
O(n log )，因为它返回排序数组，还是O(n)，正如我们从stream()的方法中期望的那样？
浏览 2提问于2022-07-10得票数 0
因此，每次调用服务时，我都需要实例化一次的字符串列表。是否值得将List<String>转换为HashSet<String>，然后检查字符串是否在hashSet中？
例如：
HashSet<String> services = new HashSet<String>((List<String>) services);
我知道检查列表中的字符串是O(n)，hashSet中的字符串检查是O(1)。我认为转换可能是O(n)。
如果我在列表中搜索的次数不超过几次，那么重铸是否对性能有好处？
浏览 7提问于2015-09-16得票数 7
回答已采纳
我正在用我的O(n*log(n))解决方案介绍我的教授在课堂上展示的问题：
给定一个n数字列表，我们希望执行以下n-1时间：
从列表中提取出两个最小元素x,y，并将它们表示为创建一个新的数字z，其中z = x+y 将z返回到列表<code>H 212</code><code>F 213</code>
给出了O(n*log(n))和O(n)的数据结构和算法
解决方案：
我们将使用最小的堆：
只创建一次堆就需要O(n)。在此之后，提取两个最小元素需要O(log(n))。将z放入堆中需要O(log(n))。
执行上述n-1时间需要O(n*log(n))
浏览 3提问于2012-06-19得票数 23
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
