输入数据的时间复杂度
是指算法在处理输入数据时所需的时间量级。它是衡量算法效率的重要指标之一。
在计算机科学中，常见的时间复杂度有以下几种：
- 常数时间复杂度（O(1)）：无论输入数据的规模如何增加，算法的执行时间都保持不变。例如，访问数组中的某个元素。
- 对数时间复杂度（O(log n)）：算法的执行时间随着输入数据的规模呈对数增长。例如，二分查找算法。
- 线性时间复杂度（O(n)）：算法的执行时间与输入数据的规模成线性关系。例如，遍历一个数组。
- 线性对数时间复杂度（O(n log n)）：算法的执行时间与输入数据的规模成线性对数关系。例如，快速排序算法。
- 平方时间复杂度（O(n^2)）：算法的执行时间与输入数据的规模成平方关系。例如，冒泡排序算法。
- 指数时间复杂度（O(2^n)）：算法的执行时间随着输入数据的规模呈指数增长。例如，穷举法解决旅行商问题。
在实际应用中，我们通常希望选择时间复杂度较低的算法，以提高程序的执行效率。腾讯云提供了丰富的云计算产品，可以帮助开发者快速构建高效的应用系统。
例如，腾讯云的云服务器（CVM）提供了弹性计算能力，可以根据实际需求灵活调整计算资源，提高算法的执行效率。同时，腾讯云还提供了云数据库（CDB）、云存储（COS）等产品，帮助开发者处理大规模数据和存储需求。
更多关于腾讯云产品的信息，您可以访问腾讯云官方网站：https://cloud.tencent.com/
相关·内容
1回答
多输入神经网络的运行时间
、、、、
假设我有一个固定架构的神经网络。如果我输入一个数据点，运行时间是1秒。那么如果输入是N个数据点，那么运行时间是多少？
是O(1)还是O(N)？换句话说，运行时间是以线性方式还是常量依赖于输入的数量？我听说过术语""，它可以减少运行时间，并用于前馈神经网络。但是向量化在大小上是恒定的吗？
浏览 11提问于2020-03-12得票数 0
我有一个在O(m)时间内运行的算法。该算法接受一组包含m个条目的数据。
通过指定严格的正整数输入n随机生成数据。生成的条目数为O(n log )。
编辑
单独地，生成数据的时间复杂度不依赖于n(或O(1))，这意味着给定整数n，条目是立即随机生成的。结果条目的数目是随机的，但是是O(n log )。例如，n= 10，则生成的条目数是一些常数乘以10 (log 10)。
数据是预先生成的。然后将得到的m项作为输入输入到算法中。
问题
那么，我可以假设算法在O(n log )时间内运行吗？
浏览 4提问于2012-12-03得票数 1
回答已采纳
1回答
通常，当分析算法的运行时间时，我处理的是影响运行时间的单个输入。我正在尝试理解当有2个或更多的输入影响运行时间时，如何表示T(n)。 例如，在最坏情况下的线性搜索中： function LinearSearch(arr, N, x)
for (i = 0; i < N; i++) ---> C1*N + C2
if arr[i] = x ---> C3*N
return true
return false --->
浏览 25提问于2020-12-19得票数 0
回答已采纳
1回答
给出了一个n个整数的未排序数组，您希望找到数组中是否有任何重复项(即任何整数出现不止一次)。
该算法基于大小为n个整数的未排序数组。使用嵌套循环来查找重复项，其复杂度为:O (N^2)
如果我们限制输入数据以实现一些最好的情况场景，那么如何限制输入数据以实现更好的大O复杂度？描述一种处理此有限数据的算法，以查找是否存在任何重复数据。什么是大O复杂性？
这些问题提出以下问题：
如何限制数据的一种方法。
这将如何改变您查找重复项的算法，以及更好的大O复杂度是什么。
我想出的答案是：
如果我们将数据限制在5 (n = 5)的数组大小上，我们可以将复杂度降低到O(N)。
如果数组是排序
浏览 1提问于2014-03-15得票数 0
3回答
学习算法，当涉及到计算时间复杂度时，我有点困惑。据我所知，如果算法的输出不取决于输入大小，则需要恒定的时间，即O(1)。而当它依赖于输入时，它被称为线性时间，即O(n)。
然而，当我们知道输入的大小时，时间复杂度是如何计算出来的呢？
例如，我有下面的代码，它输出1到100之间的所有素数。在这个场景中，我知道输入(100)的大小，那么这将如何转化为时间复杂性？
public void findPrime(){
for(int i = 2; i <=100; i++){
boolean isPrime = true;
for(int j = 2; j
浏览 8提问于2020-06-04得票数 3
回答已采纳
1回答
我正在通过互联网学习数据结构和算法，我了解到了这一点；
时间复杂度是一个算法运行所需的时间，作为输入长度的函数。
大O表示法是，是计算时间复杂度和
增长率是，算法的成本随着输入的大小而增长的速度。
假设有一个具有f(n) = n^2+3n+1操作总数的算法。那么如果这种算法的时间复杂度和增长率是多少呢？都由O(n^2)表示。
对于我来说，用Big表示法来表示时间复杂度和增长率之间的区别是什么还不清楚。
请帮我弄清楚这些条款。我们会很感激的。
提前谢谢你！
浏览 9提问于2021-12-28得票数 1
1回答
算法复杂度渐近图
、、、、
我正在准备一个C++项目，我必须计算出许多算法复杂度big-O，并将其与图上的理论值进行比较。我做了一个时间函数来计算算法的执行时间，但我没有找到一种方法来计算复杂度，并使用时间T和输入N绘制曲线。
有什么想法吗？
浏览 4提问于2016-04-22得票数 0
我是一个初级开发人员，仍然不是很熟悉大O。
这是我的leetcode问题的解决方案，我不确定这个解决方案的时间和空间复杂度是多少。
String s = "";
String t = "";
int back = 0;
for (int i = S.length() - 1; i >= 0; i--) {
if (S.charAt(i) == '#') {
back++;
continue;
}
if (back
浏览 3提问于2019-11-28得票数 0
1回答
我对big-o还很陌生，我想弄清楚这一小段代码的大o运行时间是多少。我知道通常情况下，如果有，但是整个数组的事情会改变什么吗？我很困惑，所以任何一点的输入都是很好的。提前感谢！
public apple(int n)
{
int n = 0;
int apple = 0;
a = apple + n;
}
浏览 0提问于2017-09-07得票数 0
2回答
我对O(n)在太空中的意义有很高的理解。这意味着，对于输入为n的算法，该算法在内存中分配的额外存储空间将与n成比例增加。
因此，如果您有一个算法，它接受一个数字n作为输入，并创建一个大小为2n的数组并将其填充为全0，时间复杂度将为O(n)，空间复杂度将为O(n)，因为您正在创建一个相对于输入大小的数组(额外的存储空间)。这种理解是正确的吗？
像快速排序这样的流行排序算法的最坏情况下的空间复杂度为O(n)，因此对于任意长的数据，O(n)空间复杂度有可能产生可怕的影响吗？
浏览 1提问于2014-12-27得票数 5
2回答
函数时间复杂度
、、、
在书中读到，调用子例程被认为是恒定时间操作，即使子例程本身不是在恒定时间内执行，而是取决于输入大小。如果我有下面这段代码：
void func(int m){
int n = 10;
subrout(m);//function which complexity depends on m
subrout2(n);//function which complexity depends on n
}
我想我可以认为func()是一个常数时间函数，例如O(1)？
如果我有这样的结果：
void func(){
int n = 10;
Type object;
o
浏览 5提问于2017-02-13得票数 0
如何使用数学或大O表示法计算数据代数中使用的代数操作的时间复杂度。我将用书中的例子来解释我的问题。考虑一下书中给出的例子。B
在上面的例子中，我想计算转置和合成操作的时间复杂度。
如果可能的话，我还想找出其他代数数据操作的时间复杂度。如果你需要更多的解释，请告诉我。
@wesholler我编辑了我的问题以理解您的解释。下面是一个真实的例子，假设我们想要计算下面使用的操作的时间复杂度。
假设我有如下的数据操作代数
你能描述一下我们如何计算上面例子中的时间复杂度吗？最好是在大O区？
谢谢
浏览 0提问于2015-10-06得票数 0
1回答
以下代码的时间复杂度是多少？
def func(n):
for _ in range(n):
if n == 4:
for _ in range(n):
<do something>
对于一个特定的输入(n = 4)，它将只是O(n^2)，但对于所有其他输入，它将是O(n)。在这种情况下，最坏的情况显然是O(n^2)，但我的讲师说O(n)是正确的答案。如果"big-Oh“符号表示的是最坏的情况，为什么它不是O(n^2)？
另一个是：
def func2(n):
for _ in rang
浏览 0提问于2014-04-01得票数 1
输入文件如下：
5 6 2 12
1 1
1 2
1 3
1 4
2 1
2 2
2 5
3 3
3 4
3 6
4 5
5 6
输入装置
M是集合的数，n是总元素。
K表示每一行的大小，p表示数据的总行。
M= 5，n= 6，k= 2，p= 12
集合1{1,2,3,4}
集合2{1,2,5}
集合3{3,4,6}
集合4{5}
集合5{6}
但是，{m，n，k，p}是随机值。
我希望将所有数据输入到如下所示的2D数组数据表中
1 1 1 0
1 1 0 0 1 0
0 0 1 1 0 1
0 0 0 1 0
0 0 0 1
在O(k+p)时间复杂度中。
你能给我一些主意来及时完成输入吗？谢
浏览 9提问于2022-12-02得票数 -1
1回答
数组中顶k频繁元素的时空复杂性
、、、、
对于给定问题的时间和空间复杂性，存在着一种小小的混淆：
给定一个大小为N的数组，返回顶级K频繁元素的列表。
基于最流行的解决方案：
使用大小为HashMap的K，并将每个条目的计数作为值。
通过遍历上面生成的MaxHeap，构建大小为K的HashMap。
将MaxHeap中的元素弹出到列表中并返回列表。
K是输入中唯一元素的数目。
空间和时间复杂度为: O(K)和O(K*log(K) )。
现在混乱就从这里开始。我们知道，在上述分析中，我们正在处理最坏的情况。所以，当数组中的所有元素都是唯一的时，K的最坏值是N。
因此K <= N.因此O(K)被表示为O(N) ??
浏览 3提问于2019-05-19得票数 0
回答已采纳
2回答
作为一个非计算机科学家，我发现很难理解时间复杂度和它的计算方式，所以我的问题是，是否有可能通过在越来越大的输入数据上运行某个算法/程序的时间复杂度，然后看看运行时是如何相对于输入大小n的增加而变化的。
我之所以这样问，是因为我用C++写了一个算法，它基本上是使用单个cpu核心和单线程(3 3GHZ处理器)对2D图像进行像素着色。我测量了从2^4到2^30的输入大小的运行时间，它是一个大小为32,768 ** 2的矩阵。现在，我得到了运行时如何作为输入大小n的函数的图
因此，对于n = 2^4 to 2^30的输入大小，确切的运行时间是(按行)：
[1] 0.000 0.000
浏览 0提问于2020-05-29得票数 4
1回答
我有下面的代码，我试图得到时间复杂度。
seen = set()
a=[4,4,4,3,3,2,1,1,1,5,5]
result = []
for item in a:
if item not in seen:
seen.add(item)
result.append(item)
print (result)
据我所知，当我访问列表时，该操作的时间复杂度将是O(n)。与if块一样，每次我查找集合时，都会花费另一个O(n)。那么，总体时间复杂度是O(n^2)吗？set.add()是否也增加了复杂性？
另外，由于空间的复杂性，它是O(n)吗？因为集合的大小
浏览 18提问于2017-03-10得票数 2
回答已采纳
2回答
确定问题的时间复杂度(例如，下界或上界)输入:图输出:如果图包含大小为100的团，则输出为“yes”。否则输出“no”。
确定此问题的较低时间复杂度界限
我认为时间复杂度是O(1)常数，因为集团的大小是固定的
另外，如果有人能帮助我找到一个很好的资源来确定决策问题的时间复杂性，我将不胜感激
浏览 0提问于2016-05-12得票数 1
1回答
空间复杂性的定义
、、
根据时间复杂度，我们将算法的运行时间理解为输入大小(表示内存中实例所需的位数)的函数。那么，对于这个观察，我们如何定义空间复杂性呢？很明显它与例子的大小无关.
浏览 1提问于2015-02-04得票数 2
回答已采纳
我看到了这个解释，但我仍然不能完全理解它。如果我们遵循这样的逻辑:假设某个算法在O(n)时间内工作，那么:让我们假设n= 1000 (4位长)，那么时间复杂度T(n) = O(8)让输入的大小加倍。时间是指数增长的，所以O(n)不是多项式时间？
浏览 7提问于2021-06-02得票数 0
我对计算pop和push在数据结构中的成本感到有点困惑。
1)它说，push(x)：像往常一样实现，Θ(1)时间
这是否意味着，如果一个推送操作完成Θ(1)次，如果完成两个操作，Θ(2)时间，以及如果n个推送操作完成Θ(n)次？
2) multipop(k)：调用pop()最多k次，Θ(k)最坏情况时间
这就像从堆栈S中删除k个顶部对象一样。Θ(k)是怎么来的？由于弹出了k个对象，因此时间将为Θ(k)。
3)这是最令人困惑的部分。从空开始，执行m次操作。总时间是多少？
至多m次推送，m次弹出: total O(m)。这是如何得到O(m)的。既然有2m次运算，难道不需要是O(2m)吗？
因此，在
浏览 3提问于2016-11-21得票数 0
根据我的理解，时间复杂度是通过计算运算数随输入大小的增加而得出的。
在合并排序中，有两个阶段。
将输入数组划分为较小的数组排序并合并这些数组
根据视频讲座，为合并排序划分数组的时间复杂性是O(log n)。
但在这里，他不是指计算时间复杂度的操作数，而是调用解压次数或递归函数的次数。
*他使用递归来划分数组。
纯粹就伪代码而言，在这种情况下，递归比n操作更重要；
相反，这段代码总是采用n操作；
function divide(arr){
for (let i = 0; i < arr.length; i++) {
arr[i] = [arr[i
浏览 5提问于2021-08-04得票数 0
偶然发现了一个计算数字平方根的(可怕的)算法。关于时间复杂度发生了一场小争论。我断言时间复杂度是O(n^2)，因为对于n个输入，它将被乘以n倍。我的朋友断言时间复杂度实际上是O(n)。谁是对的?为什么？
def squareRoot(x):
if x<0:
return "undefined"
elif x==0:
return 0
for i in range(0,x):
if(i*i)==x:
return i
浏览 0提问于2016-04-20得票数 3
2回答
假设我有这样的密码，
def func1(arr):
arr = sorted(arr)
for i in range(len(arr)):
# something in here
return some_val
在这种情况下，时间的复杂性是什么？是因为for循环造成的吗？在对排序输入列表调用循环之前，我有一个排序函数O(n*log(n))。在这种情况下，整个问题的总时间复杂度是多少？
浏览 5提问于2022-04-27得票数 0
1回答
使用散列的数组子集
、、、
检查arr2是否为子集。输入：arr1[] = {11, 1, 13, 21, 3, 7}, arr2[] = {11, 3, 7, 1}输出：arr2[]是arr1[]的子集
如果我们使用线性探测。哈希表将如下所示：{0=7, 1=1, 2=13, 3=21, 4=3, 5=11}，其中第一项是索引(散列代码)，第二项是值，如果你看到元素7。散列代码是7%6=1。因此从1开始，它必须通过检查每个桶来遍历完整的哈希表。这里的时间复杂度为O(n)
稍后，我们将使用哈希表搜索arr2中的所有元素。
因此，总体时间复杂度将是Len(arr2)*O(n)。
那么哈希的好处是什么呢？
浏览 1提问于2016-12-17得票数 1
1回答
这里是我的程序中最重要的部分(数据在一个文本文件中，用逗号分隔为2列)。(3，12)第一列值表示权重，第二列值表示利润)该方法从文本文件中的数据中填充大小为n的结构数组(struct有2个字段的权重和利润)，然后按照我的比较方法将项目排序如下。
static void Read(ref Items[] Item)
{
string[] lines = File.ReadAllLines(@"E:\test1.txt");
int i = 0;
string[] word;
for (int j=0
浏览 1提问于2014-12-02得票数 0
回答已采纳
2回答
这段代码是从破解编码采访书中得到的。
public static boolean isUniqueChars2(String str) {
boolean[] char_set = new boolean[256];
for (int i = 0; i < str.length(); i++) {
int val = str.charAt(i);
if (char_set[val]) return false;
char_set[val] = true;
}
return true;
}
提交人提到，
时间
浏览 0提问于2013-02-20得票数 6
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
回答已采纳
通过摊销分析，我们知道用N方法插入StringBuilder#append需要花费O(N)时间。但这就是我迷路的地方。考虑一下，inputString是来自用户的输入字符串。
for (int i = 0; i < N; i++) {
s.append(inputString);
// where s is an empty StringBuilder object at the beginning
// and inputString is the string that is taken from the user
}
这是否应该具有O(inputString.
浏览 0提问于2019-06-27得票数 6
回答已采纳
问:给你一个包含n个数字和q个查询的数组。对于每个查询，必须打印子数组的期望值(平均值)的下限(从L到R )。
输入：
第一行包含两个整数N和Q，分别表示数组元素的数量和查询的数量。
下一行包含表示数组元素的N个空格分隔的整数。
接下来，q行包含两个整数L和R(数组的索引)。
输出：
打印一个表示答案的整数。
1<= N，Q，L，R <= 10^6
1<=数组元素<= 10^9
示例输入：
5 3
1 2 3 4 5
1 3
2 4
2 5
示例输出：
2
3
3
CODE1：
n,q=map(int, input().split())
arr=list(map(
浏览 0提问于2019-10-07得票数 1
1回答
帮助我理解修改后的MergeSort算法的运行时。在经典的MergeSort中，当输入数组被分成两部分并递归排序时，执行时间为: nlogn
如果将输入数组划分为三个部分(而不是一半)，每三分之一递归排序，最后使用三参数合并合并子程序合并结果，那么MergeSort算法的执行时间是多少？
nnlognn (log n) ^ 2n ^2 2logn
浏览 3提问于2020-04-08得票数 0
回答已采纳
以下排序算法在哪种类型的数据输入上有效/无效？快速排序，合并排序，堆排序，插入排序等。 我知道至少有两个因素影响排序算法的性能: 1)输入的大小，2)数据是否已经大部分排序。但我不知道这些因素是如何影响算法效率的。 我想详细研究这一点，所以如果你能给我任何来源/链接，那就太好了。
浏览 18提问于2019-05-03得票数 1
3回答
我有下面的代码来模拟算法的递归行为，因为我没有计算出该算法的时间复杂度：
int M(int n)
{
int result = 1;
for (int i = n-1; i >= 0; --i)
{
result += M(i);
}
return result;
}
根据我的理解，我画了下面的树来说明算法：
(图片中的输入n为3)。我认为树中的节点数就是算法的复杂度。如果输入是n，时间复杂度是多少？谢谢!
浏览 36提问于2017-05-14得票数 5
回答已采纳
2回答
这个算法的时间复杂度是多少：
public int[] createTargetArray(int[] nums, int[] index) {
int[] target = new int[nums.length];
int i = 0, k = 0;
while (i < index.length) {
for (k = target.length - 1; k > index[i]; k--)
target[k] = target[k - 1];
target[index[i]] = nums[i
浏览 3提问于2021-02-27得票数 1
回答已采纳
我试图了解是否有任何替代蛮力算法(或轻微的改进/最坏的性能比幼稚的蛮力算法)仍然将导致O(N^2)的时间复杂性和O(1)辅助空间。
这是我的蛮力伪码：
procedure distinct(Input: array)
for i=0 to i < length of array
for j=i+1 to j < length of array
if array[i] ==
浏览 1提问于2016-03-07得票数 1
回答已采纳
假设我有以下函数
def test(arr):
for i in range(10000):
for j in range(10000):
print("hello world")
for num in arr:
print(num)
总体时间复杂度是多少？我想我对嵌套的for循环更感困惑。它们是O(10,000^2)还是O(1)，因为它们不依赖于输入arr大小。
浏览 0提问于2021-03-07得票数 0
我试图分析，但是在deepValueEqual()中调用了许多其他函数，我必须承认，在这种情况下，递归的使用使我无法使用。
功能最坏的运行时间有任何官方文件吗？
*Edit:我不太明白在这种情况下，如何用两个interface{}类型参数来定义输入大小，这增加了我的困惑。也许这是因为我对时间的复杂性不熟悉。
浏览 5提问于2022-04-19得票数 -2
当我被介绍给一个算法时，我知道如何找到算法的时间复杂度，但当我得到算法执行的次数和所用的时间时，我似乎不知道如何计算出算法的时间复杂度。
当O(n)，O(n)或O(n^2)这样显而易见的东西时，我有时可以得到它，但以这个问题为例：
算法运行大小为n的给定输入。如果n为4096，则运行时间为512毫秒。如果n为16384，则运行时间为1024ms。如果n为36864，则运行时间为1536毫秒。
时间复杂度是多少？
我认为它是n* 2，t* 1.5，但我不太确定如何计算它。
感谢您的帮助:)
浏览 3提问于2012-10-14得票数 0
回答已采纳
在一些CP竞赛(很重要)中，我使用了两个版本的upper_bound在我的std::map中找到上限
算法上界(1)
auto itr = std::upper_bound(s.begin(),s.end(), somenumber);
if(itr == s.end() || *itr > somenumber2)
{
//dosth
} else
//dosth2
}
std::map::upper_bound (2)
auto itr = s.upper_bound(somenumber);
if(itr == s.end() || *itr > somenumber2)
浏览 1提问于2020-01-18得票数 3
回答已采纳
4回答
例如，假设有一个函数可以迭代大小为m的数组两次，而大小为n的数组则是一次迭代。
func(){
for(i = 0; i < m; i++){//do something}
for(i = 0; i < n; i++){//do something}
for(i = 0; i < m; i++){//do something}
}
将其时间复杂度写为O(2m+n) = O(m+n)是否正确，因为O(2m) = O(m)？
对于另一个问题，如果我有一个函数，迭代大小为n，k的数组，在调用函数之前，从输入中计算k。
func(int k){
for(in
浏览 0提问于2018-03-25得票数 1
回答已采纳
2回答
我正在阅读排序方法，包括冒泡排序、选择排序、合并排序、堆排序、桶排序等。它们还包含时间复杂性，帮助我们知道哪种排序是有效的。所以我有个基本问题。如果我们包含的数据比我们将如何选择排序。时间复杂度是决定排序方法的参数之一。但是，我们是否有另一个参数来选择排序方法？
只是为了更好的理解而找出分类。
查询堆排序：
我们在哪里使用堆排序？
堆排序有什么更大的优势(除了时间复杂度O(n log ))？
堆排序的缺点是什么？
堆的构建时间是多少？(我听说了O(n)，但我不确定。)
任何必须使用堆排序或堆排序的场景都是更好的选择(除了优先级队列)？
在对数据应用堆排序之前，我们将查看
浏览 1提问于2012-03-21得票数 12
回答已采纳
2回答
我很难计算出一段代码的时间复杂度，该代码从1行(例如打开10)中提取用户输入，然后通过空格拆分输入，然后允许用户在堆中创建一个新的“帐户”对象。我认为这是一个O(n^2)操作，因为它包含2个while循环，加上一个额外的函数调用，这可能是完全错误的。
int main(){
std::vector <std::string> parameters;
std::string userCommand;
// Make a new account manager object for a new user
AccountManager accounts
浏览 3提问于2022-01-19得票数 0
回答已采纳
1回答
我有一个如下所示的模型，我正在尝试计算它的总体计算复杂度(Big-O记法)。
在这个模型中，类型为"A“的分类器的时间复杂度为O(mN)，其中N是数据集中的实例数，m是由分类器"A”确定的常量变量(我正在尝试生成一个最小的工作示例，以便问题可以清楚地表达出来。如果需要更多关于m)的信息，请让我知道。分类器"B“的时间复杂度为O(N^2)，其中N是数据集中的实例数。
这个模型基本上是一个集成分类器，由n个"A“分类器和m个"B”分类器组成。最后的决定是基于简单的加权多数票。为了确定权重，我使用数据集训练系统，同时将随机生成的权重组合分配给分类器&
浏览 0提问于2017-08-11得票数 1
1回答
采用二维数组作为输入有成本吗？ for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
cin >> a[i][j];
}
} 时间复杂度是O(n^2)还是O(1)？
浏览 23提问于2020-09-05得票数 0
回答已采纳
1回答
我有一个项目，它使用JSON作为跨语言序列化来传递数据。最近，数据的大小变得有点庞大(10k长度的对象列表)。python标准json库需要大约20秒来序列化数据。
我正在努力优化时间。虽然切换到其他json序列化程序(cjson、simplejson、ujson)可以提高速度，但我开始怀疑JSON序列化的时间复杂性。如果关系不是线性的(比方说，如果是n^2)，我可以很容易地将数据分成块并显着减少时间。
根据我的猜测，复杂性实际上应该取决于输入数据。但是，有没有最坏的情况/平均估计呢？链接到参考资料也将受到高度赞赏。
谢谢。
浏览 0提问于2012-05-21得票数 3
回答已采纳
1回答
我不擅长确定时间复杂性和记忆复杂性，如果有人能帮我解决问题，我会很感激的。
我有一种算法，可以从缓存中返回数据或获取数据，如果数据不在缓存中，我不确定它的时间和内存复杂性。
我想弄明白什么?
它的时间和记忆的复杂性是什么以及为什么。
在发布问题之前我做了什么?
我读过，，和更多的链接。
到目前为止我做了什么?
正如我从我读过的所有文章和问题中了解到的，我所有的循环操作都是线性的。我有3个循环，所以它是N+N+N复杂性，我们可以把它写成N。我认为getData的复杂性是O(n)。空间复杂性更复杂，因为我理解它通常等于简单数据结构的时间复杂性，所以我认为空间复杂性也是N，但是我有cache对象(哈
浏览 0提问于2018-10-04得票数 0
回答已采纳
我正在看下面的解决方案
function SubstringsKDistinct(str, k) {
let start = 0;
let end = 0;
let result = [];
let len = str.length;
while (start < len && end < len) {
while (end <= len) {
if (str.slice(start, end).length > 1) {
l
浏览 8提问于2022-08-19得票数 0
对于像std::set和std::map这样的数据类型，在对数时间内进行查找，是否需要实现来维护begin和end迭代器？访问begin和end是否意味着可以在对数时间内进行查找？
我一直认为开始和结束总是发生在恒定的时间内，但是我在Josuttis中找不到任何证实这一点的地方。现在我正在做一些我需要对性能进行分析的事情，我想确保覆盖我的基础。
谢谢
浏览 4提问于2008-09-17得票数 8
回答已采纳
我正在进行一些关于时间复杂性的讲座&在这个链接上，作者在4:50解释说，常数在很多情况下都很重要，当它们有小的输入大小时。请解释
浏览 2提问于2017-11-12得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
