嵌套的while循环怎么可能是O(n)呢？
嵌套的while循环的时间复杂度是由内外两个循环的迭代次数决定的。通常情况下，如果内外两个循环的迭代次数分别是n和m，那么嵌套的while循环的时间复杂度为O(n*m)。
然而，在某些特殊情况下，嵌套的while循环的时间复杂度可以简化为O(n)。这是因为在一些场景下，内层循环的迭代次数是由外层循环的迭代次数决定的，且内外循环的迭代次数是近似相等的。
例如，当内层循环的迭代次数是外层循环迭代次数的一个固定比例时，嵌套的while循环的时间复杂度可以简化为O(n)。这种情况下，内层循环的迭代次数随着n的增长而线性增长，而总体的时间复杂度仍然是O(n)。
在云计算领域中，嵌套的while循环的时间复杂度的分析对于性能优化和资源管理非常重要。通过优化嵌套的while循环，可以提高程序的效率和响应速度。
推荐的腾讯云相关产品：腾讯云函数（Tencent Cloud Functions），是一种事件驱动的无服务器计算服务，可帮助开发人员以函数的方式编写和执行代码，灵活高效。产品介绍链接地址：https://cloud.tencent.com/product/scf
注意：本回答中没有提及亚马逊AWS、Azure、阿里云、华为云、天翼云、GoDaddy、Namecheap、Google等流行的云计算品牌商，以遵守问题要求。
相关·内容
3回答
我还有另一个关于循环的问题。我知道2for循环使运行时间为O(n^2)，因为您遍历列表n*n次。
但是如果有两个while循环呢？
While (array1 is not empty)
if(~~~)
do ~~~
else(~~~)
do ~~~
while (array2 is not empty)
if(~~~)
do ~~~
else(~~~)
do ~~~
因此，一个while循环嵌套在另一个while循环中。这是否也使运行时间为n^2，因为我们迭代了第一个循环n次和第二个循环
浏览 0提问于2011-02-07得票数 2
1回答
我被这个大O符号卡住了，它应该是O(n^3)。我的思维过程哪里出了问题？ 我知道嵌套的for循环是O(n^2)，而while循环可能是O(nlogn)函数，因为for循环是一个O(n)函数，while循环的值乘以2就是O(logn)。也就是说，答案是O(n^3)，我很困惑这是怎么来的，除非函数的递归部分与此有关？ def do_stuff2(n, x=1.23):
if n <= 0:
return 0
val = 1
for i in range(n//2):
for j in range(n//4):
浏览 10提问于2019-05-29得票数 1
回答已采纳
如果n等于3，我想要中断这个while循环，但是我该怎么做呢？
n = 0;
while(true){
switch (n){
case 3:
break;
default:
break;
}
}
浏览 0提问于2021-01-03得票数 1
5回答
我有一个巨大的C项目，里面有许多C文件。我必须找到所有的内循环。我确信项目中没有任何O(n³)块，因此必须找到O(n²)个-compexity块(循环中的循环)。
是否可以使用grep找到所有内部循环？如果是，我可以使用哪个regexp来查找所有类型的内部循环，如{for，for}，{while，for}，{for，while}，{do，while}等？如果没有，有没有什么简单的unix-way方法(可能是多个grep或一种awk)？
浏览 0提问于2011-11-25得票数 10
回答已采纳
1回答
test = 0
for i in range(n):
for j in range(n):
test = test + i * j
*B*
test = 0
for i in range(n):
test = test + 1
*C*
for j in range(n):
test = test – 1
i = n
while i > 0:
k = 2 + 2
i = i // 2
对于A，我认为它是O(N^2)，因为它是嵌套的For循环，对于B，它是O
浏览 4提问于2017-09-24得票数 0
回答已采纳
1回答
如何处理这类问题？我知道O(n)、O(n^2)等基本的时间复杂度，但是如何创建一个类似于O(log(n^2/m))的算法
它是对的吗?例如：O(m^2*(log(n))^2)
for(i=0; i<m; i++)
for(j=0; j<m; j++)
for(k=0; k<n; k*=2)
for(l=0; l<n; l*=2)
something()
第二个呢？
编辑的：第二个就是这样
O(log(n^2/m))=O(log(n)+log(n/m))
for(i=n;i>0;i/=2);
for(j=
浏览 0提问于2016-09-10得票数 2
回答已采纳
1回答
根据的说法，如果所有的点都已经排序，那么安德鲁的算法将在线性时间内运行。我们将以排序点为例。
然而，在伪代码中，它说：
for i = 1, 2, ..., n:
while L contains at least two points and the sequence of last two points
of L and the point P[i] does not make a counter-clockwise turn:
remove the last point from L
append P[i] to L
现在，我们可以看到一个for循环和一个嵌套在f
浏览 1提问于2015-06-09得票数 2
回答已采纳
我们的教授给我们这个代码作为大O表示法O(n)的例子.但我不知道为什么。在我看来，这是O(n平方米)的代码。我希望你能帮助我。
def g(n):
x = n
y = 1
while x > 0:
x = x - 1
y = y + n
while y > 0:
y = y - 1
return True
当我在循环中有一个循环时，我以为代码在O(n平方)中。这段代码显示了两个独立的循环，所以应该是O(2n)，但是我可以忽略常量，得到O(n)。如果我错了，请纠正我。
谢谢你
浏览 0提问于2019-04-04得票数 0
回答已采纳
1回答
嗯，我正在为即将到来的考试学习算法，我很难验证下面的练习是否正确。
i=1
while(i<=n)
j=1
while(j<i)
j=j+1
i=i*2
我对这个问题的回答是O(n.log n)
i=1
while(i<=n)
j=1
while(j<i)
j=j*2
i=i+1
我再一次回答为O(n.log n)
有人能证实我的回答是否正确吗？另外，任何关于分析未来实践的建议都是受欢迎的。
浏览 1提问于2017-11-16得票数 0
回答已采纳
1回答
我在思考如何正确计算这个函数的时间复杂度：
def foo(lst):
jump = 1
total = 0
while jump < len(lst):
for i in range(0, len(lst), jump):
total += i
jump = jump * 2
return total
我假设它是O(n)，其中n是列表的长度。
我们的while循环是O(n)，for循环也是O(n)，这意味着我们得到了2*O(n)，它等于O(n)。
我说的对吗？
浏览 3提问于2021-01-19得票数 0
2回答
算法运行时间分析
、、、
大的运行时间是什么？我对while循环运行时感到很困惑。我知道这两个循环的运行时间都是O(n)。
cin >> n >> min >> max;
for(int i = min; i < n; i++) {
for(int j = 1; j < max; j++) {
total = 1;
while(total < n) {
total = total *2;
}
}
}
浏览 2提问于2015-10-23得票数 3
回答已采纳
1回答
算法的大O
、、
我有一个关于这个算法的问题，我很难理解它的复杂性
While(input) {
...
array to check
...
for (int i=0; i< arraysize; i++) {
creation first subarray;
creation second subarray;
}
for (int i=0; i < firstsubarray
浏览 0提问于2017-10-16得票数 0
所以我刚刚完成了下面的大的O/时间复杂度的问题，但我不确定我的答案或我做它们的方式，如果你熟悉它，请检查我的答案并给我一些建议。因为当我做大O问题的循环时，我总是感到困惑
1)
For each item N
For each item N
For each item N
do some kind of processing
EndFor
EndFor
This one should be the easiest, O(n^3), but someone said it should be O(n)?
2)
For each it
浏览 2提问于2015-07-29得票数 1
1回答
KMP算法的时间复杂度
、、、
我试图使用KMP算法实现strstr。这是维基百科给出的算法。KMP算法的时间复杂度为O(n)，其中n为较大字符串的大小。
vector<int> KMP(string S, string K)
{
vector<int> T(K.size() + 1, -1);
vector<int> matches;
if(K.size() == 0)
{
matches.push_back(0);
return matches;
}
for(int i = 1; i <= K.si
浏览 2提问于2014-02-09得票数 0
回答已采纳
2回答
Shell排序最坏情况时间复杂度
、、、、
我想了解shell排序代码中最坏的情况分析。你们能帮我找出答案吗？while循环将执行O(log n)时间和for循环O(n)时间；那么，复杂性是如何形成的呢？一个完整的答案将不胜感激；我已经坚持了一天。
int i, n = a.length, diff = n/2, interchange, temp;
while (diff > 0)
{
interchange=0;
for (i = 0; i < n - diff; i++)
{
if (a[i] > a[i + diff])
{
temp = a[i];
浏览 2提问于2015-09-18得票数 1
回答已采纳
2回答
代码应该找到两个数字之间的最大下降(或差异)，而较大的数字必须在较小的数字之前(不一定是一个接一个)。 我想知道你是否能帮我理解代码的复杂性。在这种情况下，让我困惑的是，考虑到最坏的情况(如果我错了，请纠正我)我遍历数组，对于j运行n次，对于i运行n-1次。它是相加还是相乘？为什么呢？ O(n+n-1)？或者O(n*(n-1))？ public static int maximalDrop (int[] a)
{
int max=0; int i=0; int j=1;
while (j<a.length && i<a.le
浏览 28提问于2021-08-14得票数 0
回答已采纳
3回答
n = 0
m = 40
o = 0
while n < m
n = n + 1
end
while n = m
o = o + 1
n = 0
end
使用这些代码，最好的方法是让它通过第二个循环，然后再回到第一个循环？
欢迎对这个初学者的任何帮助。:)
浏览 0提问于2010-02-15得票数 0
for i = 1 to n do
j = i
while j < n do
j = 2 * j
给我的答案是O(n)，因为从i=1到n的1+ log(n/i)的和是它运行的次数。有人能解释一下怎么得出这个结论吗？我知道外循环运行O(n)，但是如何从内环得到我所需要的呢？
浏览 0提问于2018-05-01得票数 0
回答已采纳
1回答
据我所知，这段代码的时间复杂度是O(N)，for循环只迭代一次，所以时间复杂度说明了O(N)，但是for循环中有一个while循环。
所以在for循环中有一个while循环，为什么我们忽略了这个循环的时间复杂性？
var dailyTemperatures = function(temperatures) {
let result = new Array(temperatures.length).fill(0);
let stack = [];
for(let i = 0; i < temperatures.length; i++) {
whil
浏览 3提问于2021-10-08得票数 2
回答已采纳
2回答
堆栈排序算法的时间复杂度分析
、、、、
我一直在努力解决破解编码面试的问题，为一些面试做准备。我能够解决堆栈排序问题，但我很难找到如何解释时间复杂性的方法。我的解决方案非常类似于书中提供的解决方案，我已经对它进行了相当多的测试，所以我确信它是正确的。任何对思维过程的洞察力，都将是非常感谢的，我们将通过这个过程来分析这个算法。书上说是O(n^2)。以下是算法：
def sort_stack(stack):
temp_stack = Stack()
while not stack.is_empty():
v = stack.pop()
if temp_stack.is_empty() or
浏览 5提问于2016-09-16得票数 0
回答已采纳
2回答
如何计算算法的复杂度？
、、、
int sum = 0;
for (int n = N; n > 0; n /= 2)
for(int i = 0; i < n; i++)
sum++;
int sum = 0;
for (int i = 1 i < N; i *= 2)
for (int j = 0; j < i; j++)
sum++;
int sum = 0;
for (int i = 1 i < N; i *= 2)
for (int j = 0; j < N; j++)
sum++;
我已经遭受了很长
浏览 1提问于2018-12-23得票数 1
1回答
下面是寻找和大于或等于给定数目S的子数组的最小大小问题的解决方案
public static int findMinSubArray(int S, int[] arr) {
int windowSum = 0, minLength = Integer.MAX_VALUE;
int windowStart = 0;
for (int windowEnd = 0; windowEnd < arr.length; windowEnd++) {
windowSum += arr[windowEnd]; // add the next element
浏览 0提问于2021-02-14得票数 0
4回答
int count(int *a, int *b, int n) {
int i=0,j=0,roz=0;
while(i<n) {
while(j<n) {
if(a[i]==b[j])
roz++;
j++;
}
i++;
}
return roz;
}
N是a或b数组的大小(两者大小相同)。嵌套的while循环似乎只工作一次，当i=0时。接下来似乎要发生的事情是神奇地将n变成1(开头是5)，这样嵌套的while就不会
浏览 0提问于2013-01-05得票数 1
回答已采纳
1回答
我知道传统的气泡排序是n^2时间复杂度，但我自己编写了它的实现，在我看来它看起来是O(n)。我不明白它怎么可能是n^2，因为我没有任何嵌套循环。即使在循环中递归调用它，也会在递归之后中断循环。
def bubblesort(x):
index = 0
while index <= len(x) - 2:
if x[index + 1] < x[index]:
temp = x[index + 1]
x[index + 1] = x[index]
x[index] = temp
浏览 2提问于2021-12-06得票数 0
1回答
基本时间复杂度？
、、、
考虑这三个循环
O(N^2)
int i = 0, s = 0;
while (2*i <= N*N) {
s+=i;
i++;
}
O(N)
int i = 0, s = 0;
while (s <= N*N) {
s+=i;
i++;
}
O(sqrt(N))
int i = 0, s=0, p=1;
while (s < N) {
i++;
p = p*i;
s += i;
}
前者的时间复杂度为O( N^2 )，而第二个为O(N) (在我看来，N^2更为合适)。怎么会这样?此外，为什么循环三sqrt(N)而不是log(N) -我怎么能区分？
浏览 1提问于2016-11-03得票数 1
我正在研究各种解决方案的时间复杂性，因为我不是一个数学爱好者，我无法确定我的调用的最佳时间复杂度。
问题是，我不确定是否需要更长的时间才能得到一个带1条语句的while循环，以及嵌套的if-else，或者是否最好删除嵌套的if-else，并在while循环中添加检查。
作为一般的例子，这会更快地执行吗？
while a>1 and b is True
if x is True:
a -= 1
else
a += 1
而不是
while a>1:
if x is True:
if b is True:
浏览 0提问于2016-01-02得票数 1
回答已采纳
1回答
我想在C中退出嵌套函数以返回主函数。但我不知道该怎么做。我的意思是，在我的代码中，我想使用一个指令(除了goto指令，因为我想创建一个过程程序)来打破这两个循环并返回到主函数。
这是我的密码：
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
int main()
{
float *Score = (float*) malloc (5 * sizeof (float));
if (!Score)
{
printf("An error o
浏览 1提问于2020-03-27得票数 0
回答已采纳
我的老师声称这个代码块的执行时间为O(n)。我在努力找出原因。我意识到捆绑在一起的两个for循环将是一个算术级数……我的逻辑方法是，如果K= 3，那么内部循环将运行三次，然后是两次，然后是一次。如果K= 2，那么内部循环将运行两次，一次，然后停止。
在数学术语中，当k=3时，它将是N，N-1，N-2
后来我可以使用算术级数公式得到N*(N +(N-(N-1))/2。
我不知道如何处理while循环。
我所能猜测的是，当N=4时，循环运行两次，直到N= 9，循环运行三次...我该如何在数学上设置它？
最终结果是N*(N+(N-(N-1)/2+ O(while循环)得到O(N)？
任何建议都将不胜
浏览 48提问于2019-05-12得票数 3
回答已采纳
1回答
这就是算法:我认为它的时间复杂度是O(n^2)，因为循环在循环。我该怎么解释呢？
FindSum(array, n, t)
i := 0
found := 0
array := quick_sort(array, 0, n - 1)
while i < n – 2
j = i + 1
k = n - 1
while k > j
sum = array[i] + array[j] + array[k]
if sum == t
浏览 2提问于2015-06-09得票数 0
2回答
我认为下面代码的时间复杂度是O(n^2)或O(n*logn)。
int j = 0;
for(i = 0; i < n; ++i) {
while(j < n && arr[i] < arr[j]) {
j++;
}
}
然而，答案页说它是O(n)。
我不明白为什么会变成这样。
我(愚蠢的)观点如下：
由于有两个循环运行n时间，所以时间复杂度为O(n^2)。arr[i] < arr[j]可能会影响while循环，但这并不重要。
时间复杂度为O(n*logn)，因为while循环运行的次数可能少于n次数，因为在循环
浏览 7提问于2017-10-01得票数 1
回答已采纳
def triangles(A):
n = len(A)
result = 0
for x in xrange(n):
z=x+2
for y in xrange(x + 1, n):
while (z < n and A[x] + A[y] > A[z]):
z += 1
result += z - y - 1
return result
这是密码中的解决方案()的一个例子。
在手册中，他们声称这个算法的最大优点是O(N^2)。
关于我认为很大-哦，O(N^3)是最坏的情况下的迭代
(n-1)(n-2) +
浏览 0提问于2016-06-28得票数 1
回答已采纳
2回答
在我寻求理解数据结构的过程中，我开始在java.The中实现它们，deleteAll的时间复杂性将是O(n + n^2).How，我能改进deleteAll方法吗？
/*
* Singly linked list
*/
package linkedlisttest;
class Node {
int data;
Node next;
public Node(int data) {
this.data = data;
}
}
class LinkedList {
Node head;
int size;
/
浏览 1提问于2017-07-22得票数 1
回答已采纳
2回答
O循环符号
、、
for(int i = 0; i < n; i++) {
for(int j = 0; j < i; j++) {
O(1);
}
}
这里的函数是n * (n+1) / 2，但是如果外部循环条件是i < log(n)呢？我对互相联系的回路有问题。
浏览 1提问于2017-06-21得票数 4
回答已采纳
嵌套语句的时间复杂度是否相同？假设a是一个长度为n的数组。
for _ in range(len(a)):
for _ in range(len(a)):
do_something
上述发言为O(n平方米)。
i = 0
while i < len(a) * len(a):
do_something
i += 1
乍一看，上面的循环可以被认为是O(n)，但最后我认为它也是O(n平方)。
我说的对吗？
浏览 27提问于2022-03-02得票数 22
回答已采纳
我在使用这段代码时，使用了一些实际的代码，这些代码需要循环中的所有变量。我在想，如果迭代发生的范围是相同的，那么就必须有另一种方式，减少缩进，并对所有变量进行相同的访问。
除了这样的嵌套循环之外，还有其他的方法吗？
较少压痕
在封闭范围内以相同顺序访问变量
守则：
import itertools
import time
#My Way
s = time.time()
sums_pyramid = [0] * 36
for i in xrange(1,5):
for j in xrange(1,5):
for k in xrange(1,5):
浏览 0提问于2013-06-28得票数 0
回答已采纳
1回答
从Leetcode上的一个流行问题来考虑这个python解决方案： def findOptimalRadius(houses, heaters):
houses.sort()
heaters.sort()
last = len(heaters) - 1
x1,x2 = 0,0
res = 0
for house in houses:
while x2 < last and house > heaters[x2]:
x1, x2
浏览 21提问于2021-03-30得票数 1
回答已采纳
2回答
我有两个字符串列表： ['Tipo de fertilizante',
'N',
'P2O5',
'K2O',
'S',
'CaO',
'MgO',
'Zn',
'Solubilidad g/100cc H2O',
'Precio (€/100 kg)',
'€/UF (N)',
'€/UF (P2O5)',
'€/UF (K2O)',
'€/UF (S
浏览 45提问于2020-10-05得票数 0
回答已采纳
2回答
我是Python新手，如果我有这个元组 testGrid = [['p','c','n','d','t','h','g'],
['w','a','x','o','a','x','f'],
['o','t','w','g','d','r','k']
浏览 43提问于2021-10-06得票数 0
1回答
public int[] maxSlidingWindow(int[] nums, int k) {
int n = nums.length;
if (n == 0) {
return nums;
}
int[] result = new int[n - k + 1];
LinkedList<Integer> dq = new LinkedList<>();
for (int i = 0; i < n; i++) {
if (!dq.isEmpty() && dq.pe
浏览 6提问于2020-02-16得票数 2
回答已采纳
我的方法(可能是不正确的)是公式化的。如果有循环则(n+1)如果有嵌套循环(n^2)如果有语句则O(1)。如果除法，则log(n)。
这里有一些例子和我解决问题的理由，我根本不确定这种方法是否有问题，或者其中任何一个是正确的。我需要你的帮助。
Example1：
i = n; // I think O(1) because it's a statment
while (i > 1) // I think O(n) because it's a loop
i = i/4; // O(n) because it's in a loop and log_4(n) b
浏览 14提问于2017-03-16得票数 1
1回答
我能请人帮我从这个算法的时间复杂度开始吗？
我特别想弄清楚如何才能得到大人物。
我想我很少知道，时间可能是O(n)，而'for‘是O(n)，因为T.length使它不是常数。但我不确定这是否意味着整个算法可能是O(n^2)，还是仅仅是O(n)，还是我在完全错误的路径上？
函数的描述说它应该做'SquareRootByItems‘。
int function(int T[]){
for (int i := 0; i < T.length; i++){
int j := 1;
while(j * j <= T[i]) j++;
T[i] := j
浏览 7提问于2022-09-21得票数 0
回答已采纳
在for循环中有一个while循环可以被认为是嵌套的while循环吗？
我如何使用do while来做同样的问题呢？
#include <stdio.h>
#define NUMS 3
int main() {
// insert code here...
int highVal;
int lowVal;
int i;
printf("---=== IPC Temperature Analyzer ===---\n");
for (i=1;i<=NUMS;i++){
printf("
浏览 0提问于2019-05-31得票数 0
1回答
我尝试了codechef中给出的时间复杂性mcq问题，在数据结构和算法的实践中。其中一个问题有一行a*< ai。这行是什么意思？
我知道如果没有and语句，复杂度将为O(n^2)。但a*<对我来说完全陌生。我在互联网上搜索了一下，但我得到的都是关于a star算法和星号的！我尝试使用一条print语句在python中运行该程序，但它显示*无效。这是否意味着指向数组中第一个元素的指针之类的东西？
找出以下函数的时间复杂度
n = len(a)
j = 0
for i =0 to n-1:
while (j < n and a* <
浏览 8提问于2019-08-02得票数 1
回答已采纳
3回答
我很难理解而循环是如何影响大O时间复杂性的。
例如，如何计算下面代码的时间复杂度？由于它有一个遍历数组中每个元素的for循环和两个嵌套的while循环，所以我最初的想法是时间复杂度为O(n^3)，但我认为这是不对的。
HashMap<Integer,Boolean> ht = new HashMap<>();
for(int j : array){
if(ht.get(j)) continue;
int left = j-1;
//check if hashtable contains number
while(ht.
浏览 13提问于2022-05-26得票数 0
回答已采纳
我听说过这段代码中正确或最严格的上限是O(N+M)。我的问题是，为什么说O(N+N)是错误的。我听说这将是一个松散或错误的上限。如果是这样的话，我们如何知道O(n)是否< O(m)，或者我们如何知道O(n) > O(m)？我一直看到的主要原因是我们使用O(N + M)而不是O(2N)是因为没有保证O(N) = O(M)。我的困惑是，我们怎么能不说O(N) = O(M)是真的呢？显然，我们有两个简单的for循环，它们线性运行，这将允许我们将它们添加到我的大脑中，并将其设置为O(N + N)。我哪里错了？是否因为我们不知道这两个线性增长率是否有关系？如果这是在常规数学中的情况，我们可以
浏览 0提问于2020-09-03得票数 1
我有点困惑，不知道这样的方法的大O符号是什么
public void printOut (SinglyLinkedList<Double> myLinked){
Iterator<Double> itr = myLinked.iterator();
while (itr.hasNext()){
double d = itr.next(); // unboxing
if (d > 5.0)
System.out.println (d);
} // while
} // method printOut
如果没有If语句，我知道它会是'n
浏览 1提问于2016-05-19得票数 0
1回答
我在n长列表中实现了整数从1到n的计数.此条件不允许附加数据结构。只操作原始列表。打印出整数及其计数
例如：
org_arr = [3, 4, 3, 1]
count_int(org_arr )
for i, item in enumerate(org_arr , 1):
print(i, '->', abs(item))
产出：
1 -> 1
2 -> 0
3 -> 2
4 -> 1
下面是我的count_int()实现
def count_int(arr):
for i, check_index in enumerate(ar
浏览 0提问于2018-10-03得票数 0
回答已采纳
我正在尝试计算下面函数的运行时复杂性。它找出给定数的质因数。
function test(n){
n = parseInt(n);
var factors = [];
for(var i = 2; i <= n; i++){
while((n % i) === 0){
factors.push(i);
n /= i;
}
}
return factors;
}
while循环的执行依赖于i的值，我不知道如何计算它，或者应该是I。这不是O(N2)对吗？
浏览 0提问于2017-10-27得票数 3
1回答
我知道每个for循环都是一个O(log₂n)，但是我不知道其中的3个在一起会产生什么效果呢？O(3⋅log₂n)？谢谢你们。
for (int i = n; i > 0; i = i / 2) {
for (int j = n; j > 0; j = j / 2) {
for (int k = n; k > 0; k = k / 2) {
count++;
}
}
}
浏览 0提问于2015-01-26得票数 2
回答已采纳
1回答
我正在做这个例子()，他们给出的答案是O(N^2)。原因是-引用，“while循环中有一个for循环。”这是正确的，但这不是分配array[index1] = array[index2];和array[index2] = temporaryValue; n的时候，这不需要大O到n^3吗？
function sortByValue(array){
function swap(array, index1, index2){
let temporaryValue = array[index1];
array[index1] = array[index2];
array[i
浏览 2提问于2022-07-29得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
