if/else条件下for循环的时间复杂度
在if/else条件下的for循环的时间复杂度取决于循环体内的代码执行次数。假设循环体内的代码执行次数为n，那么时间复杂度可以表示为O(n)。
在这种情况下，循环体内的代码会根据if/else条件的判断结果来执行不同的操作。如果if条件成立，循环体内的代码会执行一次；如果if条件不成立，循环体内的代码会执行另外一次。因此，无论if条件是否成立，循环体内的代码都会执行一次。
在时间复杂度的表示中，我们通常关注的是随着输入规模的增加，算法执行时间的增长趋势。在这种情况下，无论if条件是否成立，循环体内的代码执行次数都是固定的，与输入规模无关。因此，时间复杂度为O(1)。
总结起来，if/else条件下的for循环的时间复杂度为O(1)。这意味着循环体内的代码执行时间与输入规模无关，执行时间是固定的。
相关·内容
1回答
我试图找到一种方法，以尽可能最小的时间复杂度排序数组。我当时认为下面的是O(n)，但是对我来说似乎不太可能，因为现有的数组排序方法最多只有O(nlogn)。我的问题是，这个方法在java中的大O复杂度是什么，它是如何计算的？
public static void ArrSort(int[] arr){
int temp;
for(int j=0;j<arr.length;j++)
{
if(arr[j]>arr[j+1]) {
temp=arr[j];
浏览 2提问于2022-05-22得票数 -2
回答已采纳
1回答
计算“时间复杂度”
、、、
希望你过得很好，
我正在计算算法的时间复杂度，该算法有三个嵌套的for，但我在最新的for中添加了一个if，比如：
for (i=0 ; i<n1 ; i++){
for (j=0 ; j<n2 ; j++){
for (k=0 ; k<n3 ; k++){
if (A[i][j][k] == true){
...
}
}
}
}
因此，如果A[i][j][k]是false，那么它将被跳过，并且不会使用计算时间。
我的问题是:我们是否要跳过某些部分
浏览 2提问于2020-11-19得票数 0
回答已采纳
3回答
我认为这段代码的时间复杂度将是O(n^2)，但我不确定，所以如果有人能解释一下这段代码的时间复杂度，那将是非常有帮助的 int func2()
{
int i, j, k = 0;
scanf("%d", &n);
for (i = 1; i < n; i++)
{
i -= 1;
i *= 2;
k = k + i;
for (j = 1; j < n; j++);
}
}
浏览 24提问于2021-08-22得票数 0
1回答
我如何找到作为问题大小n的函数的时间复杂度？
sum = 0;
if (EVEN(n)) {
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
O(logn)
}
else {
sum++;
}
}
}
else {
sum = sum + n;
}
浏览 3提问于2015-10-08得票数 0
3回答
我一直在尝试计算我的项目的时间复杂度。如果循环是这样的，有人能指导我如何计算复杂度吗？
while (k < K){
for( int i=0; i<M; i++){
// if condition
// sets i = dp
}
for(int i=dp; i<M; i++){
for(int j=0; j<=i; j++){
// single stmt
}
// if else condition
funct
浏览 7提问于2013-06-05得票数 1
2回答
我知道删除双向链表中的一个节点的时间复杂度是O(1)。我见过很多代码的例子，人们在双向链表的remove方法中使用循环，但时间复杂度仍然是O(1)。我已经写了一段代码来撤消，即删除双向链表中的节点，但我的问题是:当我调用包含循环的getNode()方法时，我的代码会撤消/删除undo()方法中O(1)中的节点吗？我很感谢你的解释！提前感谢！
private Node <T> getNode( int idx ){
return getNode( idx, 0, size( ) - 1 );
}
private Node<T> getNode( i
浏览 1提问于2015-10-04得票数 1
1回答
我试图找出do while循环的时间复杂度，其中有一个内部for循环。我知道如何找到for循环的复杂性，但当涉及到while循环时，我完全迷失了方向。有什么建议吗？ 下面是该算法的一个示例。 M = 6
k = 1
NoItrs = 20
G_dependency = 100
alpha_dependency = 90
beta_dependency = 80
delta_dependency
do
k := k + 1
a := 2(1- k/NoItrs)
for i = 1 to M do
Calculate b and c using Eq. 1 and 2, respect
浏览 115提问于2019-12-14得票数 0
回答已采纳
我编写了以下代码，我对如何计算这段代码的时间复杂度感到困惑。
我认为它是O(n)，但我的朋友却不这么说。你认为如何？
public class Matrix {
public static int hole(int[][]mat)
{
int col=0;
int count1 = 0;
int count0=0;
for(int k=0;k<mat[0].length;k++)
{
count0 = 0;
count1 = 0;
浏览 2提问于2016-12-22得票数 0
回答已采纳
1回答
这个函数的时间复杂度是多少？
bool prime(int n) {
if(n <= 1) {
return false;
} else if(n <= 3) {
return true;
} else if(n % 2 == 0 || n % 3 == 0) {
return false;
} else {
for(int i = 5; i * i <= n; i += 6) {
if(n % i == 0 || n % (i + 2) == 0) {
浏览 4提问于2020-07-14得票数 2
1回答
我知道时间复杂度应该是O(N)。然而，当我对它进行经验测试时，我得到了奇怪的结果。有人能解释一下发生了什么事吗？
def insertPivot(array, start, end):
pivot = end
i = start
j = end - 1
while i < j:
while array[i] < array[pivot] and i < j:
i += 1
while array[j] > array[pivot] and j > i:
浏览 1提问于2021-04-03得票数 1
1回答
如何计算嵌套循环的时间复杂度？另外，如何计算包含多个函数的程序的时间复杂度？
基本上，我对何时添加/乘以时间复杂度感到困惑。
#include <stdio.h>
long pascal(int, int);
int main()
{
int n,m,k,j;
printf ("Enter the height for Pascal's Triangle: ");
scanf("%d", &n);
for(k = 0; k<n; k++)
{
for(j = 0; j <
浏览 0提问于2020-08-12得票数 0
2回答
我感兴趣的是如何计算递归函数的时间和空间复杂度，如置换、斐波那契(描述为)
一般来说，我们可以在许多地方进行递归，而不仅仅是在置换或递归上，所以我正在寻找一种通常遵循的方法来计算空间复杂度。
谢谢
浏览 0提问于2010-12-02得票数 4
回答已采纳
1回答
时间/空间复杂性
、、、、
准备考试。我认为时间复杂度是O(n^2)，空间复杂度是O(1)。请帮帮忙，我说的对吗？ public static String lastSubstring(String s) {
int start=0;
int end = start+1;
int len =0;
while (end + len < s.length()) {
if (s.charAt(start + len) == s.charAt(end + len)) {
len++;
} else if (s.c
浏览 19提问于2020-11-02得票数 0
3回答
所以我有以下代码
def example(array):
count = 5
for _ in range(count):
array.remove(0)
array.append(0)
整体的时间复杂度是多少？for循环本身应该是O(1)，对吗？但我不确定'array.remove(0)‘行将如何影响整体时间复杂度。
浏览 0提问于2021-01-14得票数 0
1回答
虽然我只使用了一个循环，但我不认为代码的时间复杂度是O(n)。有人能解释一下下面代码的时间复杂性吗？
public class PatternPyramid {
public static void main(String[] args) {
int rows = 15;
int i = 0;
int j = 0;
int k = rows - 1;
while (i < rows) {
if (j < k) {
System.ou
浏览 5提问于2020-07-25得票数 0
回答已采纳
3回答
在以下两个案例中，我对时间和空间复杂性有疑问。
区块报价
案例I:
递推:阶乘计算。
int fact(int n)
{
if(n==0)
return 1;
else
return (n*fact(n-1));
}
这里为什么时间复杂度变成2*n，空间复杂度与n成正比。
和
Case II:
迭代：-
int fact(int n)
{
int i, result = 1;
if(n==0)
result = 1;
else
{
for(1=1;i<=n;i++)
浏览 5提问于2012-05-21得票数 0
回答已采纳
在练习一些算法时，我遇到了以下问题，我很难弄清楚时间和空间的复杂性是什么。
问题:从数组中打印出的对，它们加起来等于k的和。
int[] arr = new int[]{1, 7, 2, 3, 4};
int k = 4;
findSum(arr, k);
威尔输出
Pair: 1, 3
我的问题：，下面的解决方案的运行时和空间复杂性是什么？
Java示例如下：
private void findSum(int[] arr, int k) {
if (arr == null || arr.length < 2)
throw new RuntimeExceptio
浏览 4提问于2013-10-09得票数 2
2回答
第一职能：-
void strange (int n,int k)
{
int i;
if(k > n)
return;
for(i=k; i<n; i++)
printf("?");
strange(n, k+2);
return;
}
第二职能：-
void weird(int n, int k)
{
int i;
if(n <= 0 || (k <= 0))
return;
k *=2;
for(i=0; i < k; i++){
printf("?");
weird(n/2, -n
浏览 4提问于2015-06-07得票数 1
回答已采纳
下面的代码我发现时间复杂度是n^2，如果这是正确的？
int numbers[9] = {1, 5, 7, 8, 9, 14, 21};
int check = 50;
int count = 0;
for (int i = 0; i < 9; i++) {
int squared = numbers[i]*numbers[i];
int target = check - squared;
for (int j = i; j < 9; j++) {
if (numbers[j]*numbers[j] == target) {
浏览 23提问于2020-06-03得票数 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
我在编码方面是个新手，在寻找简单for循环的时间复杂度方面遇到了问题。
for (int i=0;i<n;i++)
我在一些网站上看到，上面的时间复杂度是2n +2，据我所了解。
1 for assignment i=0
n+1 for comparision of i<n
但是在i++ n times for i++的情况下，因为循环将在某些站点中迭代n次。
so total time complexity `= 1+(n+1)*2 +n`
但我的问题是i++ =i+1 (这是一种自动操作和赋值)，即需要2次操作，这意味着n*2次总运算，所以总时间复杂度=
浏览 2提问于2016-05-21得票数 0
回答已采纳
我试图找出它的时间复杂度，发现它是O(n)。由于每个时间循环都被调用，我们得到的for循环的时间复杂度减少了1。因此，将每次调用print()时循环运行的次数相加，得到O(n)。我说的对吗？你能推荐我学习更多关于递归函数时间复杂度的资源吗？
伪码
print(n){
if(n==0)
return 0;
else
{
for(int i = 0 ; i < n ; i++)
{
printf("%d", i);
}
return print(n-1);
}
main(){
n=6;
print(n);
}
浏览 2提问于2021-08-27得票数 0
我想问一下我的函数的时间复杂度。下面是我用C++编写的函数。
void List::swap(List& other)
{
List temp;
Iterator r = begin();
Iterator i = other.begin();
while(!i.equals(other.end()))
{
temp.push_back(i.position->data);
i = other.erase(i);
}
while(!r.equals(end()))
浏览 0提问于2012-03-19得票数 1
回答已采纳
2回答
我是分析时间complexity.some的新手，可以帮我解决以下算法的时间复杂度吗？ public void test(int n)
{
int i=1;
while(i<n)
{
int j=1;
while (j<i)
{
j=j*2;
}
i=i*2;
}
} 外部循环将多次运行log(n) times.How，内部循环将运行多次。我们如何根据"n“计算内部循环的频率，因为这里它依赖于变量"i”，并将运行log(i)次。 有人能帮我找出上面代码的时间复杂
浏览 14提问于2020-04-05得票数 0
1回答
问题是:给定一个无向无环图 (N节点和N1边)，其中每个节点都被标记为一个字符，则可以找到构成回文的图中节点最长路径的长度。
假设存在N (1 <= N <= 500 000)节点，是否有算法解决O(N^2)或O(N.log2(N))的时间复杂度问题
经过一些研究，我认为这可以用图上的Manacher算法来解决。
浏览 6提问于2021-07-18得票数 1
回答已采纳
1回答
迭代与递归的最大O区别是什么？为什么运行时间会如此不同。我假设O(n)，因为它有一个迭代循环。
这是一个中等大小的，有一个很好的图表。
function factorial (n) {
if( n === 0 || n === 1 ) {
return 1;
}
let prev = 1;
let ret;
while(n >= 2) {
ret = prev * n;
prev = ret;
n--;
}
return ret;
}
function factorialR (n) {
if( n === 0 || n =
浏览 0提问于2019-07-28得票数 0
我正在尝试找出这段代码的时间复杂度。
while(m!=4){
if(m>n)
m=m-n
else
n=n-m
}
我尝试了m&n的随机值，这使得它成为一个无限循环。我不知道怎么找到它？
浏览 1提问于2019-02-24得票数 0
问:给你一个包含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
4回答
我想找出这段代码的时间复杂度。我的理解是-
外部的for循环将循环2n次，在最坏的情况下，当i==n时，我们将进入if块，其中嵌套的for循环的复杂度为O(n^2)，将外部for循环计算在内，代码块的时间复杂度将为O(n^3)。
在最好的情况下，i!=n，else具有O(n)的复杂度，而外部的for循环是O(n)，这使得复杂度，在最好的情况下是O(n^2)。
我说的对吗?还是我漏掉了什么？
for (int i = 0; i < 2*n; i++)
{
if (i == n)
{
for (int j = 0; j < i; j++)
fo
浏览 33提问于2021-02-24得票数 2
1回答
下面算法的时间复杂度是O(log(n))，但我只是好奇for循环的时间复杂度是多少？
func TwoNumberSum(array[] int, target int)[] int {
sort.Ints(array)
left, right: = 0, len(array) - 1
for left < right && left >= 0 && right < len(array) {
if array[left] + array[right] == target {
ret
浏览 4提问于2022-08-17得票数 2
1回答
很明显，一个while (i < k)将运行k个项目--或者不运行，这取决于i的起始值。 但是如果我有一个while循环，比如： while (counter != k && !found) {
if (some condition)
found = true;
else
counter++;
} 如果我不知道何时找到将被设置为真，我如何计算最坏情况的时间复杂度？
浏览 25提问于2020-04-23得票数 0
回答已采纳
1回答
算法的时间复杂度
、、、、
嗨，我一直在研究和尝试学习hw来检查某些算法的时间复杂性。
话虽如此，我还是不知道，并开始尝试计算出某些算法的精算化案例和一般情况。
程序#1:这是一个用RPN格式计算的计算器.
function evaluate() {
var input = prompt("Please enter your input string\n\nExamples of input strings:\n\n\t1. 10 4 5 + *\n\t2. 10 4 5 + * 2 +\n\t3. 10 8 *");
var values = input.split(&#
浏览 0提问于2018-05-08得票数 0
2回答
def f1(n):
for i in range(n):
k = aux1(n - i)
while k > 0:
print(i*k)
k //= 2
def aux1(m):
jj = 0
for j in range(m):
jj += j
return m
我正在试图计算函数f1的时间复杂度，但它并不适用于我。
如果对我的工作有任何反馈意见，我将不胜感激。
我正在做的事情:我首先尝试替代i=1并尝试进行迭代，因此函数用m=n-1调用aux，aux1迭代n-1时间并返回m = n-1，
浏览 1提问于2021-02-20得票数 0
回答已采纳
1回答
我一直在寻找这种方法的时间复杂性。有一些对数据库的疑问，我认为不应该被考虑。在座有谁擅长做这样的事吗？我试着看过指南和视频，但大多数都是例子，远不及这个大小，我必须承认我的数学真的很糟糕，所以当它变成两个以上的循环时，我很难理解它。当你不考虑DB的时候，它仅仅是O(n^3)吗？ public List<HotelRoom> getSuitableHotelRooms(Date startDate, Date endDate, String roomType, int singleBedQty, int doubleBedQty) throws DataAccessExceptio
浏览 10提问于2020-06-15得票数 0
1回答
所以我知道如果我的程序有这样的东西-
method 1:
for (int i = 0; i < N; i++)
statement;
算法的时间复杂度为O(N)，或
method 2:
for(int i = 0; i < N; i++)
for(int j = 0; j < N; j++)
statement;
它将是O(N^2)
如果我的程序是像这样的几个循环的组合呢？就像-
method1: statement;
method2: statement;
或
method1: stat
浏览 1提问于2020-07-11得票数 1
回答已采纳
我是一个初级开发人员，仍然不是很熟悉大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
2回答
在学习算法的基本知识的同时，我发现了运行代码时的时间复杂度计算和实时消耗的困惑。
演示代码指定了问题。
function calcDemo1(){
var init = 0;
for(var i=0;i<40;i++){
init += 0;
}
return init;
}
function calcDemo2(){
var init = 0;
init += (0+1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25+26+27+28+2
浏览 1提问于2017-11-14得票数 0
回答已采纳
1回答
需要帮助来确定我的多数元素解决方案的时间复杂性 问题描述任务。 此代码问题的目标是检查输入序列是否包含多数元素。输入格式。 第一行包含一个整数?，下一行包含一系列?非负整数?0，?1，.。。，??−1.约束。 1≤?≤105；0≤??≤109，全部为0≤?<?。 输出格式。 如果序列包含的元素严格超过?/2次，则输出1，否则输出0。 示例1。 输入:5 2 3 9 2 2 输出： 1 public class MajorityElement {
private static int getMajorityElement( int count, int right) {
浏览 28提问于2021-07-29得票数 1
回答已采纳
1回答
算法如下:从上到下求三角形最大和的时间和空间复杂度分别是什么和最差
For each ELEMENT in particular ROW and COLUMN
{
If ( ELEMENT is FIRST ELEMENT of ROW)
{
MAX_SUM[ROW][COLUMN] = ELEMENT + FIRST element of (ROW-1)
}
Else If (ELEMENT is LAST ELEMENT of ROW)
{
MAX_SUM[ROW][COLUMN] = ELEMENT + LAST element of (ROW-1)
}
Else
浏览 0提问于2018-01-14得票数 0
以下解决方案的空间和时间复杂度(最坏的情况)是什么？
Node getNodeFromTail(Node head, int x){
Node p = head;
Node q = head;
int diff = 0;
while (p.next != NULL){
p = p.next;
if (diff >= x)
q = q.next;
else
diff++;
}
return q;
}
以下是对上述代码的解释：
以这个链表为例:
浏览 1提问于2020-01-06得票数 0
我相信空间复杂度只有O(n)，因为集合是整个程序中唯一存储的集合，并且每次都会重新计算列表。我不确定时间复杂度是否会是O(n^2)，因为有一个while循环，里面有一个for循环，或者它是不同的，因为当n不是1或在集合中时，while循环可以继续运行。
def isHappy(self,n):
seen = set()
while True:
if n not in seen:
seen.add(n)
n = sum([int(x) * int(x) for x in str
浏览 2提问于2020-06-05得票数 2
2回答
我需要找到f3在时间和空间上的复杂性。我认为g具有log(n)的空间复杂性，因此对于时间复杂性，我不太确定如何找到f3的时间和空间复杂性，因为对g的调用位于for推荐的内部，这是否意味着每次都会调用g来检查g(i) < n
int g(int n)
{
if (n <= 1)
return 1;
return g(n / 2) + 1;
}
int f3(int n)
{
int counter = 0;
for (int i = 0; g(i) < n; ++i)
++counter;
return
浏览 1提问于2020-08-15得票数 1
我有一个本地主机网站，其中有一个“开始”按钮，它触发以下功能：
function startGame(){
startTime = new Date().getTime();
currentTime = new Date().getTime();
while((currentTime-startTime)<2000){
document.getElementById('test').innerHTML = 'test1'
if(allyClicked){
allyTrack +
浏览 0提问于2018-03-04得票数 0
1回答
我认为这段代码经历了一个循环。此外，我认为“做一些不同的事情”无论如何都不会完成，所以我不知道如何找到它的递归关系和时间复杂性。任何帮助都将不胜感激。
1F( n : integer )
2 {
3 if n == 1 then
4 “Do something”;
5 else
6 {
7 for i = 1 to n do
8 {
9 F( i – 1 );
10 “Do something different”;
11 }
12 }
13 }
浏览 0提问于2020-10-23得票数 1
p = 0
for( i=1; i<n; i=i*2 ) {
p++ // log n
}
for( j=1; j<p; j=j*2 ) {
some_statement // log P
}
// O( log log n )
为什么来自独立循环的变量会影响另一个循环的时间？如果我们要删除第二个循环，时间复杂度将仅仅是O(logn)，这要慢得多。为什么时间复杂度不只是logn + logn =2 logn，因此O(logn)？
浏览 6提问于2022-09-29得票数 2
回答已采纳
1回答
下面的代码块来自一个函数，该函数查找达到用户给定的特定数量所需的最小硬币数量。这里使用了两个队列“sum”和"costs“。
while(Sums.front()<=TargetSum){
int tempSum = Sums.front();
Sums.pop();
int tempCost = Costs.front();
Costs.pop();
for(int i=0;i<TypesOfCoins;i++)
{
Sums.push(coins[i]+tempSum);
Costs.
浏览 1提问于2017-07-15得票数 0
3回答
有一个问题要求返回数组元素的所有唯一三重奏，这些元素加起来等于零(交换两个元素在三胞胎中的位置不算唯一)。
我想出了以下代码：
function threeSum(nums) {
nums.sort((a, b) => a - b);
const result = [];
for (let i = 0; i < nums.length; i++) {
// skipping duplicates
if (i !== 0 && nums[i] === nums[i - 1]) continue;
let left = i + 1
浏览 0提问于2019-08-24得票数 4
回答已采纳
1回答
我算法的复杂性
、、、
问题是:我的功能是哪一种复杂性？以及如何找到我算法的时间复杂度？
该函数检查给定的int数组是否已排序。
我的守则：
public static boolean isSorted(double d[]){
boolean sortedAscending = true;
boolean sortedDescending = true;
boolean bool = false;
for (int i = 0; i < d.length-1; i++) {
if(d[i] > d[i+1] && sortedAscending){
sorted
浏览 2提问于2017-05-31得票数 0
回答已采纳
2回答
循环的大O分析
、、、
我必须分析这个循环和其他循环，并使用Big-O表示法确定它的运行时间。
for ( int i = 0; i < n; i += 4 )
for ( int j = 0; j < n; j++ )
for ( int k = 1; k < j*j; k *= 2 )`
这是我到目前为止所知道的：
for ( int i = 0; i < n; i += 4 ) = n
for ( int j = 0; j < n; j++ ) = n
for ( int k = 1; k < j*j; k *= 2 ) = log^2 n
现在我
浏览 22提问于2015-08-25得票数 17
回答已采纳
1回答
这是我的第一个问题，我很确定我也会收到我的第一个答案：
我必须对一个算法进行渐近分析，该算法从一个数组A[1...n]计算一个矩阵M[n][n]，该矩阵包含每个M[i][j]的一个值，由下式给出：
M[i][j] = (A[i] + ... + A[j])/(j-i+1), if i<=j
和
M[i][j] = 0, if i>j
for i=1 to N do [N]
for j=1 to N do [N]
if(i<=j) [cost]
start=i
浏览 1提问于2013-03-08得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
