时间复杂度的杂项问题

先决条件：渐近符号

时间复杂度：
时间复杂度是算法所需的时间，表示为问题大小的函数。它也可以定义为运行程序完成所需的计算机时间量。当我们解决时间复杂度问题时，这个定义最有帮助——
“它是算法为完成与输入大小相关的任务而执行的操作数。”

以下是一些时间复杂度的杂项问题，这些问题总是在不同类型的测验中经常被问到。

1. 以下代码的时间复杂度是多少——

C++

void function(int n)
{
    int i = 1, s = 1;
    while (s < n) {
        s = s + i;
        i++;
    }
}
 
// This code is contributed by Shubham Singh

C

void function(int n)
{
    int i = 1, s = 1;
    while (s < n) {
        s = s + i;
        i++;
    }
}

Java

public static void function(int n)
{
    int i = 1, s = 1;
    while (s < n) {
        s = s + i;
        i++;
    }
}
 
// This code is contributed by Shubham Singh

Python3

def function(n):
    i = 1
    s = 1
    while (s < n):
        s = s + i
        i+=1
     
# This code is contributed by Shubham Singh

C#

public static void function(int n)
{
    int i = 1, s = 1;
    while (s < n) {
        s = s + i;
        i++;
    }
}
 
// This code is contributed by Shubham Singh

Javascript

function functionn(int n)
{
    var i = 1;
    var s = 1;
    while (s < n) {
        s = s + i;
        i++;
    }
}
 
// This code is contributed by Shubham Singh

---

---




解决方案 -
时间复杂度 = O(√n)。

解释 -
我们可以根据关系 S i = S i-1 + i 定义“S”项。令k是程序所进行的总迭代次数

i	S
1	1
2	2
3	2 + 2
4	2 + 2 + 3
…	…
k	2 + 2 + 3 + 4 + ……+ k

当 S >= n 时，循环将在第 k次迭代处停止，
⇒ S>=n ⇒ S=n
⇒ 2 + 2 + 3 + 4 + ……+ k = n
⇒ 1 + (k * (k + 1))/2 = n
⇒ k 2 = n
k = √n
因此，时间复杂度为 O(√n)。

2. 以下代码的时间复杂度是多少：

C++

void fun(int n)
{
    if (n < 5)
        cout << "GeeksforGeeks";
    else {
        for (int i = 0; i < n; i++) {
            cout << i;
        }
    }
}
 
// This code is contributed by Shubham Singh

C

void fun(int n)
{
    if (n < 5)
        printf("GeeksforGeeks");
    else {
        for (int i = 0; i < n; i++) {
            printf("%d", i);
        }
    }
}

Java

public static void fun(int n)
{
    if (n < 5)
        System.out.print("GeeksforGeeks");
    else {
        for (int i = 0; i < n; i++) {
            System.out.print(i + " ");
        }
    }
}
 
// This code is contributed by Shubham Singh

Python3

def fun(n):
    if (n < 5):
        print("GeeksforGeeks", end ="")
    else:
        for i in range(n):
            print(i, end= " ")
             
# This code is contributed by Shubham Singh

C＃

public static void fun(int n)
{
    if (n < 5)
        Console.Write("GeeksforGeeks");
    else {
        for (int i = 0; i < n; i++) {
            Console.Write(i + " ");
        }
    }
}
 
// This code is contributed by Shubham Singh

Javascript

function fun(n)
{
    if (n < 5)
        document.write("GeeksforGeeks");
    else {
        for (var i = 0; i < n; i++) {
            document.write(i + " ");
        }
    }
}
 
//This code is contributed by Shubham Singh

解决方案 -
时间复杂度在最佳情况下 = O(1)，在最坏情况下 = O(n)。

解释 -
该程序包含 if 和 else 条件。因此，时间复杂度有两种可能性。如果 n 的值小于 5，那么我们只会得到GeeksforGeeks作为输出，其时间复杂度将为 O(1)。
但是，如果 n>=5，则执行 for 循环，时间复杂度变为 O(n)，这被认为是最坏的情况，因为它需要更多时间。

3. 以下代码的时间复杂度是多少：

C++

void fun(int a, int b)
{
    while (a != b) {
        if (a > b)
            a = a - b;
        else
            b = b - a;
    }
}
 
// This code is contributed by Shubham Singh

C

void fun(int a, int b)
{
    while (a != b) {
        if (a > b)
            a = a - b;
        else
            b = b - a;
    }
}

Java

public static void fun(int a, int b)
{
    while (a != b) {
        if (a > b)
            a = a - b;
        else
            b = b - a;
    }
}
 
// This code is contributed by Shubham Singh

Python3

def fun(a, b):
     
    while (a != b):
        if (a > b):
            a = a - b
        else:
            b = b - a
             
# This code is contributed by Shubham Singh

C＃

public static void fun(int a, int b)
{
    while (a != b) {
        if (a > b)
            a = a - b;
        else
            b = b - a;
    }
}
 
// This code is contributed by Shubham Singh




解决方案 -
最佳情况下时间复杂度 = O(1)，最坏情况下时间复杂度 = O(max(a, b))。

解释 -
如果 a 和 b 的值相同，则不会执行 while 循环。因此，时间复杂度将为 O(1)。
但是如果 a!=b，那么 while 循环将被执行。设a=16，b=5；

no. of iterations	a	b
1	16	5
2	16-5=11	5
3	11-5=6	5
4	6-5=1	5
5	1	5-1=4
6	1	4-1=3
7	1	3-1=2
8	1	2-1=1

对于这种情况，while 循环执行了 8 次（a/2⇒16/2⇒8）。
如果 a=5 且 b=16，则循环也将执行 8 次。所以我们可以说时间复杂度是 O(max(a/2,b/2))⇒O(max(a, b)) ，它被认为是最坏的情况，因为它需要更多的时间。

4. 以下代码的时间复杂度是多少：

C++

void fun(int n)
{
  for(int i=0;i*i

C

void fun(int n)
{
  for(int i=0;i*i

解决方案 -
时间复杂度 = O(√n)。

解释 -
设k为否。循环的迭代。

i	i*i
1	1
2	22
3	32
4	42
…	…
k	k2

⇒当 i * i >=n 即 i*i=n 时，循环将停止
⇒ i*i=n ⇒ k 2 = n
⇒ k =√n
因此，时间复杂度为 O(√n)。

5. 以下代码的时间复杂度是多少：

C++

void fun(int n, int x)
{
    for (int i = 1; i < n; i = i * x) //or for(int i = n; i >=1; i = i / x)
        cout << "GeeksforGeeks";
}
 
//This code is contributed by Shubham Singh

C

void fun(int n, int x)
{
    for (int i = 1; i < n; i = i * x) //or for(int i = n; i >=1; i = i / x)
        print("GeeksforGeeks");
}




解决方案 -
时间复杂度 = O(log x n)。

解释 -
设k为否。循环的迭代。

no. of itr	i=i*x
1	1*x=x
2	x*x=x2
3	x2 *x=x3
…	…
k	xk-1 *x= xk

⇒当 i>=n ⇒ x k = n 时循环将停止
⇒ x k =n（两边取log）
⇒ k=log x n
⇒因此，时间复杂度为 O(log x n)。

6. 以下代码的时间复杂度是多少：

C

void fun(int n)
{
    for (int i = 0; i < n / 2; i++)
        for (int j = 1; j + n / 2 <= n; j++)
            for (int k = 1; k <= n; k = k * 2)
                cout << "GeeksforGeeks";
}




解决方案 -
时间复杂度 = O(n 2 log 2 n)。

解释 -
第一个 for 循环的时间复杂度 = O(n/2) ⇒ O(n)。
2 nd for 循环的时间复杂度 = O(n/2) ⇒ O(n)。
第 3次for 循环的时间复杂度 = O(log 2 n)。 （参考问题编号 - 5）
因此，函数的时间复杂度将变为 O(n 2 log 2 n)。

7. 以下代码的时间复杂度是多少：

C

void fun(int n)
{
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j = j + i)
            cout << "GeeksforGeeks";
}




解决方案 –时间复杂度 = O(nlogn)。

解释 -
第一个 for 循环的时间复杂度 = O(n)。第二个循环对 i 的每个值执行 n/i 次。
它的时间复杂度是 O(∑ n i=1 n/i) ⇒ O(logn)。
因此，函数的时间复杂度 = O(nlogn)。

8. 以下代码的时间复杂度是多少：

C

void fun(int n)
{
    for (int i = 0; i <= n / 3; i++)
        for (int j = 1; j <= n; j = j + 4)
            cout << "GeeksforGeeks";
}

解决方案 –时间复杂度 = O(n 2 )。

解释 -
第一个 for 循环的时间复杂度 = O(n/3) ⇒ O(n)。
第二个 for 循环的时间复杂度 = O(n/4) ⇒ O(n)。
因此，函数的时间复杂度将变为 O(n 2 ) 。

9. 以下代码的时间复杂度是多少：

C++

void fun(int n)
{
    int i = 1;
    while (i < n) {
        int j = n;
        while (j > 0) {
            j = j / 2;
        }
        i = i * 2;
    }
}
 
//This code is contributed by Shubham Singh

C

void fun(int n)
{
    int i = 1;
    while (i < n) {
        int j = n;
        while (j > 0) {
            j = j / 2;
        }
        i = i * 2;
    }
}

解决方案 –时间复杂度 = O(log 2 n)。

解释 -
在每次迭代中，i 变为两次 (TC=O(logn))，j 变为一半 (TC=O(logn))。因此，时间复杂度将变为 O(log 2 n)。
我们可以将此while循环转换为for循环。
for(int i = 1; i < n; i = i * 2)
for(int j=n;j > 0;j = j / 2)。

上述 for 循环的时间复杂度也是 O(log 2 n)。

10. 考虑以下 C 代码，在循环执行中进行的比较次数是多少？

C

void fun(int n)
{
    int j = 1;
    while (j <= n) {
        j = j * 2;
    }
}

解决方案 -
细胞（log 2 n）+1。

解释 -
设k为否。循环的迭代。在第 k 步之后， j 的值为 2 k 。因此，k=log 2 n。在这里，我们使用log 2 n 的 ceil ，因为 log 2 n 可能是十进制的。因为我们正在为退出循环进行另一次比较。
所以，答案是 ceil(log 2 n)+1。