此代码的时间复杂度是多少： for (i=1 to n) for (j=1 to i^2) if ((j mod i)==0) for (k=1 to j) write ("*"); 我发现I，j和k之间的关系： 例如，n=4，因此： i j k 1 1-1 1 k run for 1time 2 1-4 1

我偶然发现了一个循环，我不确定它的时间复杂性是什么。这是以下循环： for(i = 1; i <= n^2; i++){ for(j = 1; j <= i; j++) { //some elementary operation } } （i=1；i这是一个简单的算术级数 每一个新的迭代都要大1倍 外循环将执行n^2个操作，这将导致以下顺序： 1 + 2 + 3 + ... + n + ... + n^2 = n^2 (n^2+1) / 2 = O(n^4)

谁能帮我理解这是2^（n^2）=Θ（2^（n^3））？如果你也能证明这一点，那就太好了。根据我的观点，这不需要平等 首先，2^（n^2）是一个函数，Theta（2^（n^3））是一组函数，所以说2^（n^2）是正确的∈ θ（2^（n^3））。=只是一种常见的符号滥用，但实际上它的意思是∈。要确定该语句是否正确，请解决以下限制： lim (n->infinity) of (2^(n^2)) / (2^(n^3)) 如果结果为0或无穷大，则函数不属于该特定θ类。如果它是其他值，则它确实属于该

当我遇到这个问题时，我想知道如何分析它的复杂性 例如： 对于queue（），复杂性始终为O（1），因为它只是简单地推入收件箱 对于dequeue（），大多数情况下复杂性也是O（1），但当发件箱为空时，它需要一个循环来将所有元素从收件箱移动到发件箱。那么，这一行动的复杂性是什么 在分析此类问题时，您的想法是什么 如Dave L.在其解释中所述，“每个元素将被推两次并弹出两次，从而得到摊销的固定时间操作”。这是因为每次需要将n个元素从一个堆栈移动到另一个堆栈（需要O（n）个时间）的出列之后都会出

我最近遇到一个问题，读到它可以在时间n^（O（k））内决定，这仍然意味着这个问题是NP问题。这种复杂性代表什么？它是一个不确定的多项式时间复杂度吗？这意味着它在NP中，因为p是NP的子集，当k为常数时，n^（O（k））是多项式 如果它可以在多项式时间内确定，那么它在p中，p在NP中，所以问题也在NP中 编辑： 这是在假设k是常数或比n“小”的情况下（当n->无穷大）而且，n^（O（k））更常见地写为O（n^k），这使得多项式更明显。多亏了这一点，情况才变得更清楚了。尽管我仍然不清楚一个问题是如何

有人能用master方法解释下面的时间复杂性吗 int sum(Node node) { if (node == null) { return 0; } return sum(node.left) + node.value + sum(node.right); } 我知道a的值是2，但我很难识别b和d。b=1，d=cO（n）吗？在这种情况下，任何人都可以解释如何识别b和d这是一个用于对二叉树中的所有节点求和的函数。首先从根部向下离开，然后向上（堆栈展开）

我从中学到了大O符号的基本概念 在我的问题中，二维曲面被划分为均匀的M网格。每个网格（m）根据特征分配后验概率 m网格的后验概率计算如下： 边际可能性如下所示： 这里，A特征相互独立，sigma和mean符号表示每个网格上每个A特征的标准偏差和平均值。我需要计算所有M个网格的后验概率 根据大O表示法，上述操作的时间复杂度是多少？ 我猜是O（M）或O（M+A）。我说得对吗？我期待在正式论坛上有一个答案 此外，如果将M个网格划分为T个簇，每个簇都有Q个网格（Q离散和和积），那么时间复杂度会是多少

我只需要有人给我解释一行代码，我真的不明白。 *这只是伪代码 m:=1，l:=0，s:=0: 而mfor的第一个循环从n-m运行到n。所以它有m个迭代。在while循环的最后一次迭代中，m基本上是n，因此它在n中线性运行。但总体复杂度优于O（n logn） 总的来说，您有这么多的迭代 (1 + log n) + (3 + log n) + (9 + log n) + ... + (n + log n) ( log_3 n terms ) = log_3 n * log n + (1 + 3

假设我有一段代码，比如 for(int i = 0; i < n; i++){ randomFuntion(); // runtimes function is O(log n) } for（int i=0；i

“算法a的最坏情况运行时间”和“算法a的运行时间为O（n）”之间是否存在差异 我认为“没有区别”，因为最坏的情况是函数可以达到的峰值运行时间，O（n）表示函数是“有界的”。两者含义相同 希望我的逻辑是正确的。有区别 一个算法是O（f）是不精确的：你必须说一个算法在其最佳/最差/平均情况下是O（f）。当最佳、最差和平均值相同时，你可以说这是O（f），但这并不常见。这些字串之间有很大的区别。“算法A的最坏情况运行时间”是一个名词子句，它根本不作任何陈述。“算法A的运行时间是O（n）”是一句话，告诉我

对于这个问题，我们给出了一个函数f，它以标准方式计算第n个斐波那契数： f(n) { if(n == 0) return 0; if(n == 1) return 1; else return f(n-1) + f(n-2); } 然后，我的任务是计算函数对输入n执行的算术运算的数量。我知道对f的每次调用都执行3个运算（2减1加），然后我试图通过扩展函数来找到它，尝试找到某种递归关系，然后计算出完成了多少算术运算。但后来我被卡住了，因为这不是正确的答案 正确答案是f

有人告诉我，这段代码的时间复杂度是O（n），你能解释一下它是怎么做到的吗。外部循环的时间复杂度为logn，内部 int fun(int n) { int count = 0; for (int i = n; i > 0; i /= 2) for (int j = 0; j < i; j++) count += 1; return count; } intfun（intn） { 整数计数=0； 对于（int i=n；i>0；i/=2） 对于（int j=0；j

我有这样的反复： 我想应用，因为它似乎属于案例1，所以我想探究： 但我不知道该怎么做。我走对了吗 在维基百科页面中，“不可接受的方程式”下的第二个例子与您的类似。您的方程式的比率f（n）/n^log（b，a）与示例1/log（n）相同。因此，主方法不适用。@Aziz我明白了。。你知道怎么解决吗？@jscherman是官方的答案O（n^2）。@sumeethingh你是怎么做到的？

所以这些是for循环，我必须找到时间复杂度，但我并不清楚如何计算 for (int i = n; i > 1; i /= 3) { for (int j = 0; j < n; j += 2) { ... ... } for (int k = 2; k < n; k = (k * k) { ... } for（int i=n；i>1；i/=3）{ 对于（int j=0；j

我目前正在学习算法和数据结构。经过近两个月的学习，我仍然觉得时间的复杂性非常令人困惑 我的教授告诉我，如果某个程序的大ω和大O不相等，大θ就不存在 我现在真的对我所学到的一切提出了质疑。我将以BubbleSort为例，使用大ω（n）、大θ（n^2）和大O（n^2）。大θ确实存在（当我分析它时，它是有意义的） 有谁能向我解释一下我的教授是错的还是我误解了什么？存在大O、大ϴ和大Ω O是上界 Ω是下限 ϴ存在的充要条件是O=Ω 从本质上讲，Big-O是最有用的，因为它告诉我们函数可能表现得最差 大-

快速排序的最佳情况是n log（n），但每个人都使用大O表示法将最佳情况描述为O（n log（n））。根据我对符号的理解，快速排序有很大的ω（n log（n））和O（n^2）。这是正确的还是我误解了大欧米茄符号 您的详细信息不正确。从技术上讲，Big-O应该是最坏的情况。快速排序的平均情况为O（n logn），最坏情况为O（n^2）。根据技术定义，快速排序的正确大O是n^2。但是随机获得该性能的机会几乎为零（除非您在已排序的列表上运行QuickSort），因此QuickSort被赋予n log

这里Fn是斐波那契函数 我试着用c=F（n+1）/F（n）来解释这个问题，但当我们看到更大的n值时，这个比率会变大 这取决于斐波那契算法的实现。e、 比奈公式以O（1）时间复杂度计算斐波那契值。斐波那契数Fn相对于索引n的增长复杂度是Θ（1.618^n）-精确值是（1+sqrt（5））/2，黄金比率。所以你需要2^c

我得到了这段代码（函数） 如果我用n=10运行它，根据runCounter，它总共被调用2047次。如果我在n=20的情况下运行它，在完成之前总共调用2097151次 据我的老师说，这个代码的时间复杂度是O（n^2），但我不明白为什么。10^2=100. 远不及2047和20^2=400，甚至更大的误差。我认为这段代码更符合O（2^n），因为2^10=1024和2^20=1048576更符合函数的行为。我是对的还是我的老师是对的 有什么简单的方法来解决这些问题吗？我试着在纸上写调用堆栈，并对正

假设您找到了问题的解决方案，并试图了解其复杂性。通过调用B子例程总共n^2次，并进行恒定量的额外工作，可以解决A问题 如果B是选择排序，该解决方案的时间复杂度是多少 如果B是合并排序，这个解决方案的时间复杂度是多少 我对第一个问题的回答是n^2，对第二个问题的回答是nlogn。如果您对我的答案有任何想法，我们将不胜感激。是的，您是对的， OB=n^2->选择排序； OB=n*logn.->Marge Sort我假设你所说的解决方案是指算法，而这个解决方案是指通过调用B n^2次来解决问题A的算法

我很难比较这两种功能： n^(0.001n) n! 有什么见解吗？例如，尝试用几个数字替换n 0 10 10^6 10^15并比较这些函数的结果。它应该能让你知道哪一个长得更快。我很难理解你的问题。

假设我们有一个O（2^n）阶的算法。此外，假设我们将输入大小n乘以2，那么现在我们有一个大小为2n的输入。时间是如何影响的？我们是不是把这个问题看成，原来的时间是2^n，现在变成了2^（2n），所以答案是新时间是前一时间的2的幂 大0不是告诉您实际运行时间，而是告诉您输入大小对运行时间的影响。如果将输入的大小增加一倍，复杂性仍然是O（2^n），n只是更大 number of elements(n) units of work 1 1

我试图理解不同数据结构的时间复杂性，并从堆排序开始。从我所读到的内容来看，我认为人们一致认为堆排序的时间复杂度为O（nlogn）；然而，我很难理解这是怎么回事 大多数人似乎都同意heapify方法取O（logn），buildmaxheap方法取O（n），因此O（nlogn），但是为什么heapify取O（logn） 从我的角度来看，heapify似乎只是一个方法，它比较了节点的左、右节点，并根据它是最小还是最大堆正确地交换它们。为什么需要O（logn） 我想我遗漏了一些东西，如果有人能更好地向我

我正试图对跑步时间有更多的了解 假设我的函数中有代码，每个语句都有一些不同的时间复杂性： LinkedList myLL = new LinkedList(); //O(1) myLL.addAtHead("1"); //O(1) myLL.addAtHead("2"); //O(1) myLL.addAtHead("3"); //O(1) int[] myArray = new int[n] //O(n) , depending on what n is <Some other st

O（logn）和O（log2n）一样吗？By，log（2n）=log（2）+log（n）既然你是用大O来写的，你得到的是O（log（2））+O（log（n））=O（log（n）是的，O（logn）和O（log2n）的意思是一样的。这是因为 log2n=log2+logn 因为log2是一个常数，所以它被big-O符号忽略 更广泛地说，对数的属性意味着许多常用表达式的log最终都等价于O（logn） log nk=k log n=O（log n） log（2n）=log（2）+log（n）=log

在处理时间复杂性时，我认为O（n）和O（kn）是相等的。将常数 k 作为整数＞1。任何方式kn>n，对吗 有人能解释一下吗。我不是计算机科学出身。大O符号来自一个极限观点，它有一个非常具体的定义 我们说函数f（x）是O（g（x））当且仅当，对于非常大的x值，|f（x）|0 这个定义基本上意味着O（kn）是O（n）的一个子集。当然，O（2n）中的一个算法总是比O（3n）中的另一个算法快，但它们都属于O（n）算法的大家族 它们被认为是等价的，因为当处理无限大的数字时，没有人再关心常数了 大O符号来自

我见过很多这种类型的问题，但我仍然无法弄清楚while迭代 for i=1...n for j=1..i k=n while (k>2) k=k^(1/3) 的两个循环是O（n^2）组合的，内部循环是O（log2（log2（n））[*]，因此总体复杂度是O（n^2*log2（log2（n）） 要找到内部循环的迭代次数m，我们需要解决m的以下问题： n = 2^(3^m) 这就产生了log3（log2（n）），这与O（log2（log2（n））（使用相同的日志库以保持一致

不执行任何操作的for循环是否算作O（n）？或者这是恒定时间？这是恒定时间。Asi将始终从0运行到5 上述代码段的时间复杂度将是O（1）for循环不是“什么都不做”，它在每次迭代中将变量i增加一次五次。这当然忽略了编译器可能选择完全删除此代码的事实 因此for循环for（设i=0；i

以下代码的复杂性是什么（由于第2和第3个循环没有正文，因此令人困惑）： for（int h=0；h在平均情况下，它应该是O（n^2 lg n）（由规则司法部指出）。 关于空体的问题，答案是空体不会影响复杂度，你仍然在运行这些循环，即使你没有在其中做任何事情（即使你做了，我假设它会通过一些不会影响平均复杂度的常数时间操作） 编辑：我对时间复杂度做了更多的研究，但错过了一些计算时间复杂度的重要原则。多亏RulerOfJustice指出了这一点这能回答你的问题吗？你需要将每个术语相乘，而不是相加，这意

在一篇关于多叉树的论文中，它提到了多叉树是O（logn）-竞争的。二叉搜索树具有O（logn）-竞争性到底意味着什么？为什么多杀树O（logn）-具有竞争力

我理解大O符号，但我不知道如何计算许多函数的大O符号。特别是，我一直在试图找出斐波那契序列的原始版本的计算复杂性： int Fibonacci(int n) { if (n <= 1) return n; else return Fibonacci(n - 1) + Fibonacci(n - 2); } intfibonacci（intn） { 如果（n只需问问自己需要执行多少语句才能完成F（n） 对于F（1），答案是1（条件的第一部分）

以下算法的时间复杂度是多少 输入：点集p及其欧几里德坐标 计算点的行程（使用最近邻算法，如TSP问题） 对于每个点，获取最近邻信息（相对于原始数据集中的所有点） 复杂性是O（n）还是O（n²）？我们如何轻松地将复杂性和效率可视化 对于每个点，您必须找到最近的邻居。（您将获得第一个n） 计算两点之间的距离可以得到一个系数1，因为它在O（1）中运行 因此，计算一个点和所有其他点之间的距离可以得到一个系数O（n） 您总共得到了O（n²）。当然，在步骤3中，您不必计算到访问点的距离，但这只保存了一个常

对于任意整数n>100，我们可以写n=3*a+5*b+7*c，其中a、b和c是非负数 查找a、b和c的最佳复杂性是什么 如果a，b和c是整数，这个问题很容易，时间复杂度是O（1），因为n=3*2*n-5*nsoa=2*n，b=-n和c=0 蛮力将是沿着O（n^2）的东西。但我认为，使用动态规划可能会得到更好的结果。这给了你一个解决方案，但不是全部。我想列出所有的解决方案。无论如何，如果你有一个O（1）算法，你还想要什么呢？@Sirko，在这个解中，b是负数。我在找非负的a，b和c。不需要列出所有

假设我有两组数字，我想构建其中的所有值对。例如： A = {1, 2} B = {3, 4} Out = {(1,3), (1,4), (2,3), (2,4)} 我的集合的查找时间为O（1）。如果集合没有相同的大小，也可以用O（|A |+|B |）计算输出，但我找不到任何解决方案[简单的解决方案是两个foor循环，但这是O（n^2）]。你能告诉我如何在给定的复杂度下计算这个吗？不，你不能比两个for循环做得更好。这样想吧。对于A中的每个元素，必须输出B元素。所以你的运行时间总是A*B的倍数

我在一项任务中提出了这个问题 确定嵌套循环的时间复杂度 for(int i=1; i<=n; i=2*i){ for(int j=1; j<=i; i=2*j){ stuff } } for（int i=1；i内部循环运行log（i）+1次次（log base 2） 添加外部循环，对上述i=1,2,4，…n求和 所以：（log（1）+1）+（log（2）+1）+（log（4）+1）+…+（log（n）+1） 这是：1+2+3+…+log（n） 使用算

我的教授提出了以下问题，我真的不知道如何开始解决这个问题。欢迎任何帮助 假设树的空间是一棵具有均匀分支b的树，每个节点正好有b个子节点。我们从树根开始，以迭代深化的方式探索空间。程序将在0.2秒内在深度为3的位置找到第一个解决方案，并在10秒内在深度为5的位置找到下一个解决方案。我们知道第三种解决方案是在深度9。估计一下我们预计程序需要多少时间才能找到第三个解决方案。记住学校数学和几何级数之和 树看起来像b=3子级的示例 N N N N N N N N

我使用邻接列表来表示OCaml中的图形。然后，我从节点s开始，在OCaml中实现了以下BFS 大小表示图形的节点数。seen是一个数组，其中seen.t=true（如果我们已经看到了节点t），接下来是需要查看的节点列表 问题是BFS的时间复杂度通常是线性的，但我觉得我的实现没有这种复杂度。如果我没有弄错的话q@graph.t因为它是O | q |，所以相当大。因此，我的复杂性相当糟糕，因为在每一步中，我都要连接两个列表，这在时间上是很繁重的 因此，我想知道如何调整此代码以生成有效的BFS？我认为

我想知道所附代码的时间复杂度。 我得到O（n^2logn），而我的朋友得到O（nlogn）和O（n^2） SomeMethod（）=日志n 代码如下： j = i**2; for (k = 0; k < j; k++) { for (p = 0; p < j; p++) { x += p; } someMethod(); } j=i**2； 对于（k=0；k中考虑 n^ 2 < /代码>，其复杂性可以表示如下， i^4您的代码中的N是什么？是

我有个问题 这个函数的时间复杂度是多少 Function (int n) { for (i = 1 to n): print("hello") } 很明显，它是指数型的，因为是二进制数还是什么？？ 应该是O（n）对吗？这显然是O（n）。该函数打印“hello”次数n次。因此，时间复杂度是O（n），不是指数的。它是线性的 因为for循环是从1到n运行的，所以复杂性将是O（n）。它是线性的。有什么帮助吗？你能分享一下你的想法吗，这样其他人就可以知道你是否出了问题，你在哪里出了问题？

正如标题所说，我的问题是知道2^1000是常数还是指数函数 我认为它是常数，因为没有依赖变量n。但是它看起来像2^n，像指数函数。让我们把函数表示为T（n）=2^1000 T（n）值是否随n值的不同而变化？否。 如果T的每个域值的结果相同，那么T是一个常数函数 实现问题答案的另一种方法是找到函数的范围。如果它只包含一个元素，那么这个函数就是一个常量函数。如果它有一个指数（这与指数不同，即O（2^n）！），那么它就不重要了，如果没有像n这样的变量，那么它就只能是常量。

可否告知本局： T(N)= SUM T(N-i) //i=1 to N 解决方法如下： T（N）注意，O给出了执行时间的上限，这意味着如果某个算法是线性的，那么它就是O（N），但是它也是O（N^2）和O（N！），并且它也是任何超线性函数的O 您的推断是正确的，但是在这两个步骤中，您都高估了函数的复杂性。循环关系T（N）=sum（T（N-i））是O（2^N）（我怀疑它也是O（2^N））。这很容易表现出来，因为2^n=sum（2^i）+1对于1是的，我在心里推导时犯了一个错误！它应该像T（N）=

如果有一个NFA M，它的语言L（M）是{0,1}*的子集，那么如何证明对于n>=0，确定L（M）在{0,1}^n中的字符串是否少于一半是NP难的。首先，你必须确定你提出的问题是否确实是可解的 假设它确实可由NFA解，那么它肯定可由相应的图灵机（TM）解 设L（TM）=L（M） 然后，存在一个确定性图灵机，可以验证给定问题集的解决方案。因此，该问题是NP问题 根据你的问题，为了确定当n>=0时，L（M）在{0,1}^n中的字符串是否少于一半，这个问题是可判定的，并且可以简化为p类型 因此，我们可

我正在用树的方法推导masters定理，我注意到了一些东西 因此，我们： $T（n）=a*T（n/b）+n^c$ 由此：我们注意到，树的最后一级将有$a^（log_b_n）$splits，它等于$n^（log_b_a）$ 现在，如果$a=b$，我在最后一级得到n个拆分，这是我在快速排序和合并排序中看到的，如果 是否有大于n次拆分的实际示例？ 我们在哪里对元素重复操作 *此外，数学溢出格式似乎不起作用。如果有人帮忙，我将不胜感激 古典音乐就是这样一个例子。递推关系为：T（n）=8T（n/2）+θ（

我试图理解二进制搜索的时间复杂性的大O符号。我知道是O（logn）。那么这基本上是说对于一个包含16个元素的列表，它最多需要log2（16）=4次尝试？如果这是真的，那么对于日志为3.6的12个列表，这将如何工作 感谢大oh表示法的有用性是而不是，它可以准确地告诉您处理某个大小的输入需要多少操作。不可能 Big oh表示法告诉我们处理所需的操作数与输入大小的关系如何变化 因此，用实际数字来代替是没有多大意义的 如果它真的能帮助你从实际数字的角度来理解它，那么你可以把它们看作是平均数，因此对于12

任务是找到这个函数的递归关系，然后找到它的复杂性类。提供的是我的工作和功能。我的问题是，我觉得我在递归关系和复杂性类中遗漏了一些步骤。这是正确的吗？下面的代码是用JavaScript编写的 function divideAndConquerSum(x){ if(x.length<1){ return 0; } if(x.length == 1){ return x[0]; } var third = Math.floor((x.length-1)/3); var next = (third

设函数f和g，使得f（n）是O（g（n））并且如下 声明： I.日志f（n）是O（日志g（n）） 二,。2f（n）是O（2g（n）） 三、 f（n）2是O（g（n）2） 下列哪项陈述是错误的 A.I和II B.I和III C.II和III D.所有I、II、III 说明： 只有语句（III）f（n）2是O（g（n）2）是正确的 选项（A）是正确的 解决方案说，只有语句3是正确的，其余的2是错误的 我理解II是错误的，因为f（n）可以是2n，g（n）可以是n；那么f（n）！=O（g（n）），但语句

我有一个方法： while (i<k) { i = i * k } while（i0，n0>=1thatf（n）

网络的复杂性是什么？是同构的（图1，图2）？ 我特别感兴趣的是了解有向无环图的情况 干杯。根据文件，实现了vf2算法，甚至给出了原始的科学参考 “L.p.Cordella，p.Foggia，C.Sansone，M.Vento，“匹配大型图的改进算法”，第三届IAPR-TC15模式识别中基于图的表示研讨会，Cuen，第149-159页，2001年。” boost库针对以下复杂度声明： VF2的空间复杂度为O（V）级，其中V是两个图的（最大）顶点数。时间复杂度在最佳情况下为O（V^2），在最坏情况下

我可以找到函数的big-O和big-Omega，但我很难检查某个函数是另一个函数的big-O还是big-Omega。例如： n^（1/2）是n^（2/3）？ log（5n）是10log（n）的大O还是大Ω？ 除了使用图形计算器，我不知道如何比较它们。有人能告诉我一个提供函数增长比较技术的资源吗？第一个很简单，你只需要比较幂，所以a=n^（1/2）渐近平均增长，两者都是θ 作为一种检查工具，你可以看一下 当函数检查起来更复杂时，您也可以将它们的商对n的限值设置为无穷大。例如查看n和n^n 最常用

大O描述了时间复杂度和空间复杂度的概念，但是否有更一般的更高级别类别描述了大O符号所描述的复杂度域 例如，如果有人在应用程序中提出复杂性的话题，我可能会问“你是指圈复杂度还是大O复杂度？”。然而，大O是一种描述复杂性的符号，而不是一种实际的复杂性类型 时间复杂度和空间复杂度的概念是否不同，以至于它们没有被归入一个更正式的一般范畴？如果这些概念通常被归为一个更一般的类别，那么该类别的名称是什么？涉及大O符号的语句的一个重要特性是，它们只适用于渐近复杂性。因为它不同于圈复杂度或其他软件度量 与软件度

这是使用西格玛符号可以做的： H{n-1}是调和函数： sum =0; for (int i=1; i<n; i++) { for (int j=1; j< n/i; j++) { sum = sum +j; } }