数据结构：时间复杂度

大O渐进表示法

   a.常数1表示所有常数

   b.若有多项，只保留最高阶项

   c.若最高阶项存在且不为O(1),则去除常数，保留1  eg.F(N)=N^2+2N+1

                                                                               即为F(N)=N^2

时间复杂度计算

1.

void fun(int n) {
      int i=1;
    while(i<=n)
      i=i*2;
  }
设循环进行了k次 2^k>=n   即k>=logn 时，退出循环 ---> O(logn)

2. 

设某算法的递推公式是T(n)=T(n-1)+n，T(0)=1，则求该算法中第n项的时间复杂度为（）

时间复杂度为O(N)

3.

int f ( unsigned int n ) {
    if (n == 0 || n==1) 
      return 1;
    else 
      return n * f(n-1);
  }

每个函数递归调用一次比自己n小1的函数,然后把所有递归调用次数加起来

4. 

给定一个整数sum，从有N个有序元素的数组中寻找元素a，b，使得a+b的结果最接近sum，最快的平均时间复杂度是（   ）

双指针法：时间复杂度为O(N)，因为每次移动指针的操作都是O(1)的，而在最坏情况下，我们可能需要遍历整个数组，所以时间复杂度为O(N)

 5.

数组nums包含从0到N的所有整数，但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(N)时间内完成吗？

int MissingNumber(int* arr, int N)
{
    int ret,sum;
    ret = sum = ((0 + N) * (N + 1)) / 2;
    for (int i = 0; i < N; i++) {
        ret = ret - arr[i];
    }
    return ret;
}
int main() {
    int arr[] = { 0,1,2,3,5,6,7,8,9 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    int x = MissingNumber(arr, sz);
    printf("%d", x);
    return 0;
}

6. 

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

思路1：实际上需要轮转的次数k=k%N（N为数组元素的个数）

时间复杂度：最好情况  平均情况  最坏情况（需要关注的）

那么最坏情况为N-1  这样的话F(N)=(N-1)*(N-1)  O(N^2)

思路2：假如我们要轮转3次

a.先逆置前n-k个元素

b.再逆置后k个元素

c.最后整体再逆置一次

#include<stdio.h>

void reverse(int* arr, int left, int right)
{
	while (left < right)
	{
		int tmp = arr[left];
		arr[left] = arr[right];
		arr[right] = tmp;
		left++;
		right--;
	}
}
void rotate(int* arr, int N, int k)
{
	k %= N;
	reverse(arr, 0, N - k - 1);
	reverse(arr, N - k, N - 1);
	reverse(arr, 0, N - 1);
}

int main() {
	int arr[] = { 1,2,3,4,5,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	rotate(arr, sz, 3);
	for (int i = 0; i < sz; i++) {
		printf("%d ", arr[i]);
	}
	return 0;
}

空间复杂度计算

1.

//计算冒泡排序函数的空间复杂度
void BubbleSort(int* a, int N)
{
	assert(a);
	for (int i = 0; i < N; i++)
	{
		int exchange = 0;
		for (int j = 0; j < N - 1 - i; j++)
		{
			if (a[j]>a[j + 1])
			{
				int tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}

冒泡排序函数中使用了常数个额外空间（即常数个变量），所以用大O的渐进表示法表示冒泡排序函数的空间复杂度为O（1）。

2.

 

//计算阶乘递归函数的空间复杂度
long long Factorial(size_t N)
{
	return N < 2 ? N : Factorial(N - 1)*N;
}

阶乘递归函数会依次调用Factorial(N),Factorial(N-1),... ...,Factorial(2),Factorial(1),开辟了N个空间，所以空间复杂度为O（N）。

注：递归算法的空间复杂度通常是递归的深度（即递归多少层）。