一个用于从对象中删除n个元素的线性函数
是指一个函数，可以从给定的对象中删除指定数量的元素，并且删除操作的时间复杂度是线性的，即与要删除的元素数量成正比。
这样的线性函数可以通过以下步骤实现：
- 首先，确定要删除的元素的位置或索引。可以根据元素的值、键或其他属性来确定要删除的元素。
- 然后，使用适当的方法或操作来删除这些元素。具体的方法取决于对象的类型和编程语言的特性。例如，在数组中，可以使用splice()方法来删除元素；在链表中，可以通过修改指针来删除元素。
- 重复上述步骤，直到删除了指定数量的元素。
这样的线性函数在实际开发中非常常见，可以用于各种场景，例如：
- 数据清洗：从数据集中删除无效或重复的数据项。
- 缓存管理：从缓存中删除过期或不再需要的数据。
- 队列操作：从队列中删除指定数量的元素。
- 数据库操作：从数据库表中删除指定数量的记录。
腾讯云提供了一系列与云计算相关的产品，其中包括存储、数据库、服务器运维等。以下是一些腾讯云产品的介绍链接：
- 对象存储（COS）：腾讯云对象存储（COS）是一种高可用、高可靠、安全、低成本的云存储服务，适用于各种场景，包括数据备份、静态网站托管、大规模数据处理等。了解更多：腾讯云对象存储（COS）
- 云数据库 MySQL 版（CMQ）：腾讯云数据库 MySQL 版（CMQ）是一种高性能、可扩展的关系型数据库服务，适用于各种应用场景，包括Web应用、移动应用、物联网等。了解更多：腾讯云数据库 MySQL 版（CMQ）
- 云服务器（CVM）：腾讯云服务器（CVM）是一种弹性、安全、稳定的云计算基础设施，提供了多种规格和配置的虚拟机实例，适用于各种应用场景，包括网站托管、应用部署、大数据分析等。了解更多：腾讯云服务器（CVM）
请注意，以上链接仅供参考，具体的产品选择应根据实际需求和情况进行评估和决策。
相关·内容
佩奇说
线性的元素数擦除(破坏)加上最后一个元素删除后的元素数(移动)。
那么，如果我从某个长度的向量( j )中删除一个元素，比如索引n，它是常数还是线性的(O(N))？
或者，如果我在p元素后面有Jth元素，那么它将是O(p)的顺序--对吗？
浏览 6提问于2016-06-02得票数 1
回答已采纳
3回答
从最后一个元素开始，我想以相反的顺序从向量中删除元素。据我所知，使用迭代器进行此操作的最简单方法是：
std::vector<int> data = ...
std::vector<int>::iterator iter;
for(iter = data.end() - 1; iter != data.begin() - 1; iter--) {
data.erase(iter);
}
我的问题是，每个擦除()调用是否都是O(1)，因为我们在最后删除，尽管删除的一般复杂性是O(n)？另外，假设向量至少有一个元素，这个代码“安全”吗？
浏览 5提问于2014-04-12得票数 3
回答已采纳
移除方法：
public ()：如果存在指定元素，此方法将从该队列中删除指定元素的单个实例。
删除方法在O(1)中工作吗？如果是这样
如何找到特定的元素？
由于优先级队列使用数组，并且没有排序，因此不能使用二进制搜索，而线性搜索是一项代价高昂的操作。
它怎麽工作?
PriorityQueue<String> queue = new PriorityQueue<String>();
// Use add() method to add elements into the Queue
queue.add("Welcome");
queue.add(&
浏览 2提问于2020-07-08得票数 0
回答已采纳
3回答
是否有一个数据结构可以在O(n)中按插入顺序和数量级遍历，最多可以插入和删除O(log(n))？
换句话说，给定元素5、1、4、3、2(按此顺序插入)，可以在O(n)时间内以1,2,3,4,5或5,1,4,3,2的形式遍历它。
当然，我可以在遍历之前使用数组并简单地对其进行排序，但是这需要一个O(n*log(n))遍历前步骤。另外，我可以使用一个多链接列表来实现O(n)遍历，但是在这种情况下，插入和删除操作也需要O(n)，因为我不能保证最新的元素一定是最大的。
如果有这样的数据结构，请为我提供一个正式的名称，以便我可以进一步研究，或如果它没有，一个简短的表面级的描述将不胜感激。
谢谢
浏览 0提问于2015-07-01得票数 0
回答已采纳
1回答
对于给定的N个列表，每个列表中有M个数字，我们必须从每个组中找到一个元素，这样每对ai aj给|ai-aj|的值越小越好。
例如，我们有3个列表
{12,16,67,43}
{7,17,68,48}
{14,15,77,54}
为了最小化结果，我们必须从列表1中选择数字16，从列表2中选择数字17，从列表3中选择数字15，所以
|16-17|=1
|16-15|=1
|17-15|=2
所以我们的结果是:2
如何快速解决这个问题？在N*M时间内？或者记录一些时间
克里斯
浏览 1提问于2011-06-09得票数 0
假设我在一个大小为'n‘的std::vector<mytype>中的第'i’个位置插入p个新元素。
由于std::vector中的项目保证使用连续的存储位置来存储它们的元素，因此我似乎需要4个步骤才能完成上面的操作：
1)如果空间不足，可能会重新分配向量，基本上会使其大小加倍。但这是一个恒定的时间操作(尽管是一个非常大的操作)。
2)接下来是从索引0到i-1的从旧向量到新向量的元素的memcpy。
3)然后复制'p‘个插入到第i个索引处的新项目。
4)然后对从旧向量到新向量的n个索引的i+1中的所有项进行另一个memcpy。
以上不都是恒定的时间操作吗？那么
浏览 0提问于2014-08-09得票数 12
回答已采纳
在向量上调用clear()将调用存储在向量中的任何内容的析构函数，这是一个线性时间操作。但是，当向量包含诸如int或double之类的原始类型时，情况是否如此呢
浏览 0提问于2013-02-20得票数 11
1回答
我目前正在使用大小为0的std::vector<int> vec n以任意顺序存储从0到n-1的整数。假设vec是由以下内容提供的：
std::vector<int> vec = {4, 1, 2, 0, 3};
我需要
按顺序在vec上迭代，即4 -> 1 -> 2 -> 0 -> 3.通过索引vec[3] -> 0访问特定元素，通过值del vec[2] -> vec删除特定元素。
向量是预先给定的，最大的大小是已知的(因为我们从不添加元素)。什么数据结构适合这里(考虑性能)？
浏览 11提问于2022-09-29得票数 0
对于使用N个键和M个列表(地址)的单独链接的哈希表，其时间复杂度为：
Insert: O(1)
Search: O(N/M)
Remove: O(N/M)
我认为上面的应该是正确的。
但我不喜欢分析开放寻址的时间复杂性。假设负载因子仍然是N/M，有人能说明一下如何接近它的时间复杂度吗?也许还可以对两种实现进行一点比较。谢谢!
编辑:我对这里的线性探测特别感兴趣。
浏览 0提问于2013-04-08得票数 1
回答已采纳
我的代码包括使用parequery适配器显示从解析后端检索的数据。基于检索到的文本，我的代码在列表视图中显示一些图像，这些图像基本上是带有自定义背景的按钮和一些文本。
问题是，onListItemClick方法似乎根本没有被调用。(如果调用它，它可能会起作用)
代码的构造如下所示: NavActivity包含一个片段，其中包含在XML中定义的子列表片段。
这是我的getItemView中的ParseQueryAdapter方法
@Override
public View getItemView(ParseObject object, View v, ViewGroup parent) {
浏览 0提问于2015-01-18得票数 0
回答已采纳
2回答
我需要从排序向量中删除一个元素，同时抑制复杂度等于或大于n。我知道vector . erase方法可以消除它，但它的复杂性是n。我可以用最后一个元素重写这个结构元素，然后使用弹出函数删除应该是常量的最后一个方法，但问题是它不会被排序，所以我不得不重新排序。它甚至有可能解决这个问题，并保持在n以下的复杂性？
浏览 2提问于2016-03-28得票数 3
回答已采纳
4回答
向量中项删除的时间复杂度
、、、
我已经读过，向std::vector的末尾添加项的时间复杂性是摊销常数，在std::deque的顶部和底部插入项是constant.Since，这两个容器都有一个随机访问迭代器，因此在任何索引下访问元素都是常数。请告诉我，如果我有这些事实，wrong.My的问题是，如果访问std::vector或std::deque中的元素是常数，那么通过擦除O(n)删除元素的时间复杂性为何。答案之一在这里说，删除元素通过擦除是O(n)。我知道擦除开始迭代器和结束迭代器之间的元素，所以答案基本上意味着它的O(n)取决于两个迭代器之间元素的no，并且在任何索引中从一个向量/deque中删除一个元素都是零吗？
浏览 11提问于2015-02-01得票数 20
回答已采纳
我问这个问题已有一段时间了，但我对答案并不满意，因为这些区别似乎是武断的，更像是一种被盲目接受的传统智慧，而不是批判性的评价。
在ArrayList中，插入成本(对于单个元素)是线性的。如果我们在索引p处插入0 <= p<n，其中n是列表的大小，那么在将新元素复制到位置p之前，剩余的n元素首先被移动。
在LinkedList中，据说插入成本(对于单个元素)是恒定的。例如，如果我们已经有了一个节点，并且想要在它后面插入，我们重新排列一些指针，它很快就完成了。但是，首先，除了线性搜索之外，我看不出如何完成这个节点(假设它不是像列表开始时的前置或末尾附加这样的琐碎情况)。
然而，在Lin
浏览 4提问于2016-10-03得票数 1
回答已采纳
6回答
我正在研究一种算法，它将存储一个小的对象列表，作为一个更大的对象集的子列表。对象本身是有序的，因此需要一个有序的列表。
最常见的操作将按频率顺序排列：
从列表中检索nth元素(对于某些任意的n)
将单变量插入列表的开头或结尾
从列表中删除第一个或最后的n个元素(对于某些任意的n)
从中间移除和插入永远不会完成，因此没有必要考虑其效率。
我的问题是，在Java中，List最有效的实现是什么(即LinkedList、ArrayList、向量等)？请通过解释不同数据结构的实现来为您的回答辩护，这样我就可以做出一个明智的决定。
谢谢。
注意事项
不，这不是家庭作业问题。不，我没有能
浏览 13提问于2012-07-18得票数 4
回答已采纳
我必须做一个函数，它接受一个整数m，并删除map中具有最小值的m元素。我的主要问题是这样做的复杂度是O(nlogn)。(n是地图的大小)
这是我的解决方案：
if (Map.isEmpty())
return;
if (Map.size()<m){ //remove all keys
Iterator<K> it=Map.keys().iterator(); //collection of all keys
while (it.hasNext())
Map.remove(it.next());
}
else{
for (i
浏览 0提问于2013-04-18得票数 0
回答已采纳
我在Python中为问题找到了一个解决方案，它使用“非比较排序算法来获取计数”。它对执行按位操作的代码进行2次递归调用。
def inv_count(a, m=(1 << 32)):
if not m or not a:
return 0
count = 0
ones, zeros = [], []
for n in a:
if n & m:
ones.append(n & ~m)
else:
count += len(ones)
浏览 6提问于2015-07-19得票数 2
回答已采纳
我想写一个从列表中删除某个整数的函数。这两个值都是输入的。例如，removeValues([1, 2, 3], 3)将返回列表[1, 2]
def removeValues(aList, n):
newList = []
if n in aList:
aList.remove(n)
newList.append(aList)
else:
return False
我不确定.remove是否是正确的选择。
浏览 0提问于2015-10-22得票数 0
2回答
有一个数字数组，这个数组是不规则的，我们应该找到至少n个数字大于它的最大值(这个数字可能在数组中，也可能不在数组中)
例如，如果我们给出2，5，7，9，数字4是最大数，至少有4个数(或大于它)大于4 (5，6，9，大于4)
我解决了这个问题，但我认为它给出了一个大数列的时间限制，所以我想用另一种方式来解决这个问题，所以我用合并排序，因为它使用nlog(n)，然后我使用一个计数器，它计数从1到k，如果k数大于k，我们再次计数，例如，从1到4，然后在5中，我们没有超过5，所以我们给出k-1 =4，这是我们的n。
它是好的，还是它可能有时间限制？有人有别的主意吗？
谢谢
浏览 1提问于2013-11-15得票数 1
证明或否定:如果数组是最小堆有序的，则有一种通用排序算法，可以在n中对长度为O(n)的数组进行排序。
明天我写考试，非常害怕证明任务.这是我从以前的考试中发现的一个很难解决的问题.：/
我想我知道答案，但我的理由不是很好。所以我的理由是这个语句是假的，因为当数组是最小堆排序时，假设它是一棵树，那么树的叶子就不会被排序。在O(n)中对数组进行排序是必需的。由于这个原因，陈述是错误的。
这里我有一个例子，我创建了我自己的最小堆排序树：
1
/ \
3 2
/ \ \
8 99 7
从这里我们制作数组，我们有1, 3, 2, 8
浏览 5提问于2017-09-28得票数 1
回答已采纳
如何从std::vector中删除第i项
我知道我想删除第i个元素。我有一个int i; and std::vector<process> pList;，其中process是一个结构。我想做一些与以下内容相当的事情：
pList.remove(i);
浏览 0提问于2010-12-15得票数 35
回答已采纳
我有一个相当简单的问题。我一直在将一些统计分析代码从R转换到Python。到目前为止，我一直做得很好，但我被这条线卡住了：
nlsfit <- nls(N~pnorm(m, mean=mean, sd=sd),data=data4fit,start=list(mean=mu, sd=sig), control=list(maxiter=100,warnOnly = TRUE))
本质上，程序计算的是一组数据的非线性最小二乘拟合，即"nls“命令。在原文中，“代字号”看起来像一个"enye"，我不确定这是否有意义。
据我所知，Python的等价物是来自scipy.s
浏览 0提问于2019-03-10得票数 0
我知道，类似的问题可能会问很多次，但它是不同的。
给定一个带有值的未排序整数数组，1 to N-1中有一个重复元素(N是数组的大小，最大值是N-1，因为有重复的元素)。找到重复元素的最佳方法是什么？如果可能的话，O(log n).`
我知道O(n)的解决方案，但是有没有办法在O(log n)时解决这个问题？
O(n)解：
1) Find sum of first N-1 natural numbers using N(N-1)/2, lets say it SUM1
2) Find sum of all the elements of the arrays, let say it SUM2
浏览 4提问于2012-06-13得票数 0
回答已采纳
1回答
我有一个unordered_map类型的std::unordered_map<std::string, int64_t> sMap。这包含了与每个字符串关联的多个字符串和一个“权重”。我想找到N个最大权重的字符串。
如果我想使用一个线程来完成这个任务，我想我可以像这样创建一个优先级队列。
std::priority_queue<
std::pair<std::string, int64_t>,
std::vector<std::pair<std::string, int64_t>>,
std::function<
浏览 1提问于2015-07-10得票数 2
回答已采纳
2回答
一维和二维阵列的时间复杂度
、、、、
例如，从用户那里获取大小为n的一维数组的输入，我们知道它的时间复杂度是O(n)。
for(i=0;i<n;i=i+1)
{
scanf("%d",&a[i]);
}
如果数组是二维的，则时间复杂度为O(n^2)。
for(i=0;i<n;i=i+1)
{
for(j=0;j<n;j=j+1)
{
scanf("%d",&a[i][j]);
}
}
但即使是二维数组也是以与一维数组相同的方式保存的。从本质上说，这只是规模的增加，为什么会有区别呢？
浏览 7提问于2016-03-30得票数 0
回答已采纳
这是一个非常直截了当的建筑问题，然而它已经困扰了我很久了。
对我来说，使用list的全部意义是O(1) insert/remove。删除O(1)的唯一方法是为erase()设置一个迭代器。获得迭代器的唯一方法是将其保持在初始的insert()中，或者通过迭代找到它。
那么，应该传递什么:一个迭代器还是一个指针？
看起来，如果快速删除很重要，比如一些变化非常频繁的大列表，您应该传递一个迭代器，如果您不担心在列表中找到项目的时间，那么就传递指针。
下面是一个典型的缩减示例：
在本例中，我们有一个名为Foo的类型。Foo很可能是一个基类指针，但它并不是为了简单而出现的。
然后是FooManger，它
浏览 3提问于2010-07-18得票数 2
回答已采纳
4回答
在java中进行不替换的采摘
、、、、
我经常发现自己需要一个具有以下属性的数据结构：
可以用O(N)中的n个对象数组初始化，one可以在O(1)中获得一个随机元素，在此操作之后，从结构中删除选中的元素。(如果没有replacement)one，就可以撤消O(P)中的p‘选择而不替换’操作，可以从O(log(n))one中的结构中删除一个特定的对象(例如id)，可以获得O(N)中当前结构中的对象数组。
其他行动(如插入)的复杂性(甚至可能)并不重要。除了复杂度外，对于n的小数，它也是有效的。
有谁能为我提供实施这个架构的指引呢？目前，我实现了一个具有上述所有属性的结构，除了元素的选取采用O(d)和过去选择的数量(因为我显式地检查它
浏览 0提问于2011-07-01得票数 4
回答已采纳
我只是因为我的离散结构和算法类>而进入python，而由于某种原因，我的语法出现了一个错误，我不明白为什么您可以帮助我--这就是错误：
第10行
I=I+1
IndentationError:不缩进不匹配任何外部缩进级别，也因为某些原因，我的代码没有打印
#linear search algorithm
def search(list1, n):
i = 0
while i < len(list1):
if list1[i] == n:
print("found now")
浏览 0提问于2019-04-12得票数 0
回答已采纳
4回答
我正在尝试寻找列表中的第二个max元素，我有一个关于重复情况的问题。为什么我的for循环没有删除列表1(a)中列表2(b)中的max元素的所有实例。for循环应该检查并删除所有重复的实例。我已经附上了我的代码如下。
a=[]
b=[]
print "Enter the value of n\n"
n= int(raw_input())
print "enter the values\n"
for i in range(0,n):
y = raw_input()
a.append(int(y))
max = a[0]
for i in a:
浏览 3提问于2019-09-25得票数 0
我有两个数组，N和M，它们都是任意大小的，尽管N通常比M小。我想以最快的方式找出N中的哪些元素也存在于M中。
为了给您一个可能的程序实例的示例，N是一个大小为12个单位的数组，M是一个大小为1000个单位的数组。我想找出N中的哪些元素也存在于M中(可能没有任何匹配)。解决方案的并行度越高越好。
我过去常常使用散列映射来实现这一点，但它并不像我希望的那样高效。
输入这段代码后，我只想在sizeof(N)个独立线程上运行M的二进制搜索。(使用CUDA)我将看看这是如何工作的，但也欢迎其他建议。
浏览 0提问于2010-06-12得票数 2
回答已采纳
2回答
矢量替代器
、、
我推出了一个改进了性能的类似向量的构造，并对其进行了审查。这是最新版本。
#ifndef GUARD_HEADER_custom_2_h
#define GUARD_HEADER_custom_2_h
#include <vector>
namespace custom_2
{
template <class T> class container
{
public:
class iterator
{
public:
typedef int
浏览 0提问于2017-11-07得票数 2
如果我们有一个线性算法(例如，查找一个数字是否存在于给定的数字数组中)，这是否意味着Omega(n) = n？步骤数为n。我能做的最紧的界限是c*n，c = 1。
但据我所知，Omega还描述了最好的情况场景，在本例中是1，因为搜索的元素可以位于数组的第一个位置，并且只占一个步骤。所以，根据这个逻辑，Omega(n) = 1。
哪个变体是正确的，为什么？谢谢。
浏览 0提问于2018-07-06得票数 2
回答已采纳
1回答
请看下面的图，忽略实线(只需看虚线/虚线)。
对于每条曲线，g在、凹、双射之间。我从措施背后的过程中知道，通过增加V，相应的曲线变平了。
当V发生变化时，会产生不同的曲线。顶部的橙色曲线代表V=100，底部曲线(红色/品红)是V=180的结果。
我用以下形式用更多的数据点来测量数据：
T[1] V[1] g[1]
T[2] V[1] g[2]
T[3] V[1] g[3]
... V[1] g[4]
T[N] V[1] g[5]
.......
T[1] V[N] g[1]
T[2] V[N] g[2]
T[3] V[N] g[3]
... V[N] g
浏览 2提问于2014-02-08得票数 2
回答已采纳
1回答
下面的代码创建了两个随机数的和，然后我们训练了1000个例子，然后我们能够预测哪一个工作得很好。
考虑以下创建随机数据的代码：
def random_sum_pairs(n_examples, n_numbers, largest):
X, y = list(), list()
for i in range(n_examples):
in_pattern = [randint(1,largest) for _ in range(n_numbers)]
out_pattern = sum(in_pattern)
X.append(i
浏览 0提问于2019-09-13得票数 2
回答已采纳
3回答
我需要一个数据结构来存储正(不一定是整数)值。它必须在次线性时间内支持以下两个操作：
添加一个元素。
移除最大的元素。
此外，最大的键可以缩放为N^2，N是元素的数目。原则上，对O(N^2)空间的需求不是一个大问题，但是如果在存储方面存在一个更有效的选项，它会更好地工作。
我是用Python工作的，所以如果存在这样的数据结构，用这种语言实现会有帮助。
浏览 5提问于2020-07-10得票数 0
我正在创建2d rpg游戏。对于地图，我使用32x32瓦片。像玩家和怪物这样的物体有不同的精灵遮罩宽度和高度，它们不是在瓷砖中移动，而是按x和y移动。所以我试图找到一种“正确”(快速而准确的)方法来检查玩家和瓷砖、玩家和怪物、怪物和玩家之间的碰撞。
对于碰撞检测，我使用:矩形到矩形，圆到圆(距离)，矩形到圆，圆到矩形碰撞检查。
例如，我有一张地图: 1600x1600宽和高。除以32，我就得到了50x50的平铺地图。
我做了一个二维布尔数组：
bool tile_area[50][50];
因此，对于每个无碰撞的棋子，它将容纳1，对于无碰撞的棋子，它将容纳0。例如，如果玩家在tile_area
浏览 0提问于2012-08-22得票数 0
1回答
我有一个问题，需要将字符串附加到其初始值的副本中，从而将其转换为另一个字符串。这个问题允许在某些地方删除单个字符。
解释
let x = "abba"; // First string
let y = "aba" // Second initial string
y("aba") => remove last "a" => y("ab") => y+initialY = "ab"+"aba" =>
y("ababa") => remo
浏览 1提问于2018-12-03得票数 8
3回答
复杂度-输入长度
、、
我目前正在学习复杂性(或效率--不管你怎么称呼它)，我在一本书中读到了这一点。我觉得有些东西是毫无意义的，我需要一个解释。我试着上网看看，但是我没有找到他们给出的这个例子的答案。
对于一个在一维数组中获取最大数字的算法，其大小为n，输入长度为n。
“对于在二维数组中获取n*n大小的最大数的算法，输入长度仍然是n。”
我不明白为什么输入长度在这两种情况下都是“n”，即使对于二维的，你必须通过n*n数.上面写着
输入长度=完成的工作量。
对我来说没有任何意义。，有人愿意解释吗？，他们肯定不会在那里解释这个。
浏览 4提问于2016-04-05得票数 1
回答已采纳
1回答
为什么下面的代码会抛出TLE呢？即使时间复杂度是O(n)，它也在抛出TLE问题：，你可以把这个网站作为你的参考：
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
PriorityQueue<Integer> ans = new PriorityQueue<>(Collections.reverseOrder());
ArrayList<Integer> res = new ArrayList<>();
i
浏览 6提问于2022-10-03得票数 -2
2回答
我正在试着用一段简单的代码测试CUDA 1D纹理。它非常简单:首先分配一个全局内存，然后将它绑定到一个纹理引用；通过tex1D()从内核中访问纹理；打印出纹理获取返回的值。
代码如下：
#include "cuda.h"
#include "cuda_runtime.h"
#include <iostream>
#include <vector>
#include <cstdio>
using namespace std;
texture<float, cudaTextureType1D, cudaReadModeE
浏览 0提问于2012-09-13得票数 2
回答已采纳
问题：
下面的代码中有两个函数。它们应该从数组中选择一个随机变量，用于变量次数。然后删除数组中的随机数据。
两个随机数的第一个函数有效，而第二个函数，对于小写字母，则不起作用。
我试过：
我试过看这两个函数，但它们在我看来是一样的，只是不同的变量.
(这是创建随机密码的代码的一小部分。)
// Needed vars
var numbersN = [
'0',
'1',
'2',
'3',
'4',
'5',
'6',
浏览 6提问于2022-12-02得票数 1
回答已采纳
最近我遇到了一个问题。算法的部分要求计算长度为K的滑动窗口的最大单元和。其中K的范围从1<=K<=N (数组的N长度)。
示例，如果我有一个数组A作为5,3,12,4
长度为1：5 + 3 + 12 + 4 = 24的滑动窗口
长度为2：5 + 12 + 12 = 29的滑动窗口
长度为3：12 + 12 = 24的滑动窗口
长度为4：12的滑动窗口
Final answer is 24,29,24,12。
我试过这个O(N^2)。对于长度为K的每一个滑动窗口，我可以计算O(N)中的最大值。因此，由于K是向上N的，所以总的复杂性是O(N^2)。
我正在寻找O(N)或O(NlogN)
浏览 8提问于2016-02-08得票数 6
回答已采纳
3回答
虽然关于向量的remove_if +擦除有几十个问题。我找不到这种行动的表现。当我写到：
myVector.erase(remove_if(myVector.begin(),
myVector.end(),
some_predicate), myVector.end());
remove if将返回一个迭代器到最后一个相关项+1(让我们称之为X)。我相信O(n)会发生这种情况。
但是擦除是怎么回事？
如果擦除将尝试从X删除到myVector.end()，它将是O(n^2)，因为它将导
浏览 1提问于2017-02-08得票数 8
回答已采纳
2回答
我试图使用用户指定的索引从对象数组中删除对象。当用户指定m和n之间的范围时，这意味着所有数组的索引都小于m或高于n，我希望将它们从数组中删除。
我尝试了以下时间(m=0和n=7)：
for (const array in this.data) {
if (parseInt(array) <= 0 || parseInt(array) >7) {
this.data.splice(parseInt(array))
}
}
console.log(this.data)
而且它正常工作，但是一旦我将m转换为1，所有数组都会被清空。
这是一个。
浏览 3提问于2020-06-23得票数 1
回答已采纳
1回答
有人能告诉我以下代码的时间复杂度吗？
a是一个int数组。
Set<Integer> set = new HashSet<Integer>();
for (int i = 0; i < a.length; i++) {
if (set.contains(arr[i])) {
System.out.println("Hello");
}
set.add(arr[i]);
}
我认为它是O(n)，但我不确定，因为它使用的是Set，这也包含方法。它还调用了add方法的set。
有人能确认和解释整个代码的时间复杂度是
浏览 1提问于2011-07-20得票数 22
回答已采纳
我正在使用java中的array based MinHeap。我正在尝试创建一个自定义方法，它可以从堆中删除任何元素，不仅是root，而且不能。下面是MinHeap代码：
public class MinHeap {
/** Fixed-size array based heap representation */
private int[] h;
/** Number of nodes in the heap (h) */
private int n = 0;
/** Constructs a heap of specified size */
浏览 2提问于2012-10-01得票数 2
1回答
我是否可以知道是否有一种方法可以从循环数组中的某个索引中排出一个项？
假设这是一个循环数组..。
1
\x{e76f}\x{e76f}11\x{e 010}\x{e76f}\x{e76f}#**$}#^#
1
\x{e76f}\x{e76f}11\x{e76f}76\x{e76f}\x{
1
\x{e76f}\x{e76f}##*##.##**##.##**#.##.#.#**#.#.#**#.#.
排队索引8
1-2-3-4-5-6-7-8
有办法吗？还是我需要把它们全部转移到一起，然后它就能工作了？谢谢。
浏览 1提问于2012-12-14得票数 0
1回答
利用整数乘法的布尔卷积
、、、、
在提出的算法中，提出了一种布尔卷积方法来求两组正整数的和集。
在上面的工作中，这两个集合都表示为位掩码- 。如果将它们表示为1 + bit(0) * x + bit(1) * x^2 + ... + bit(i) * x^(i + 1) + ... + bit(n - 1) * x^n形式的多项式，那么它们的乘积实际上只包含那些幂为第一集、第二集或和集中的数的单项式。对于子集和问题，乘积系数不重要。它们的值只是指示了从第一集和第二集，或者可能从0得到数(对应单项的程度)作为元素之和的方法。受两个集合的较大大小限制的任何系数的值(s)。
为了将多项式乘法问题转化为大整数(指示向量)乘法问题，需要
浏览 0提问于2018-03-01得票数 1
回答已采纳
1回答
让A，一个数字数组。我们需要创建一个数组B，以便使B[i] = min(A[i],...,A[i+sqrt(n)]。
为什么是创建B is O(nlogn)的最紧的上限？
实际上，我收到了一份清单，列出了以下选项：
O(sqrt(n)*logn)
O(n/logn)
O(n*logn)
O(nlog(n)^2)
O(n*sqrt(n))
O(n^2)
浏览 2提问于2015-02-16得票数 0
回答已采纳
我使用优先级队列找到了Dijkstra的 (相关部分如下)。能否通过实现斐波纳契堆或甚至转向迭代深化A*来进一步加快速度？
47 public static void computePaths(Vertex source)
48 {
49 source.minDistance = 0.;
50 PriorityQueue<Vertex> vertexQueue = new PriorityQueue<Vertex>();
51 vertexQueue.add(source);
52
53 w
浏览 2提问于2015-06-16得票数 0
回答已采纳
1回答
在许多情况下，向量是首选的，因为随机访问是O(1)，因为没有足够快的容器，或者至少O(log(n))。
我对向量的问题是，vector<>::erase()是O(n)，map<>::erase()更快，是一个更好的容器。
另一种选择是使用对象池，但它不是标准容器，实现可能因使用而异，因此我不太喜欢使用一些我并不真正理解或了解的东西。
在经常发生删除的情况下，map似乎是vector<>的一个很好的替代方案，但我想知道是否有更好的替代方案。
那么，是否有一个既快速又具有随机访问和删除的容器？
是否有一种常见的方法来创建对象池？
浏览 1提问于2017-11-10得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
