衡量一个算法的好坏,一般是从时间和空间两个维度来衡量的,即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢,而空间复杂度主要衡量一个算法运行所需要的额外空间。
一、时间复杂度
int function(int n)
{
int count = 0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
count++;
}
}
for (int k = 0; k < 2 * n; k++)
{
count++;
}
int mum = 10;
while (mum)
{
count++;
mum--;
}
}
function函数里执行的基本操作次数:F(N) = N*N + 2*N + 10
1.大O的渐进表示法
大O的渐进表示法 去掉了那些对结果影响不大的项 ,简洁明了的表示出了执行次数。有些算法的时间复杂度存在最好、平均和最坏情况:最坏情况:任意输入规模的最大运行次数(上界)平均情况:任意输入规模的期望运行次数最好情况:任意输入规模的最小运行次数(下界)在实际中一般情况关注的是算法的最坏运行情况
2. 常见时间复杂度计算举例
1.
void function(int N, int M)
{
int count = 0;
for (int k = 0; k < M; k++)
{
count++;
}
for (int k = 0; k < N; k++)
{
count++;
}
printf("%d\n", count);
}
时间复杂度:O(N+M)
注意:
1. M (N) 远大于N (M) 时,时间复杂度为O(M) (O(N))
2. M和N差不多大时 ,时间复杂度为O(M) 或 O(N)
2.
void function(int N)
{
int count = 0;
for (int k = 0; k < 100; k++)
{
count++;
}
printf("%d\n", count);
}
时间复杂度: O(1)
3. 计算strchr函数的时间复杂度
const char * strchr ( const char * str, int character );
完整的strchr函数:
const char* strchr(const char* str, int character)
{
while (*str)
{
if (*str == character)
{
return str;
}
else
str++;
}
return NULL;
}
时间复杂度:O(N)
4. 计算BubbleSort函数的时间复杂度
void BubbleSort(int* a, int n) {
assert(a);
for (int i = 0; i < n; i--)
{
int exchange = 0;
for (int j = 1; j < i; j++)
{
if (a[i - 1] > a[i])
{
int tmp = a[i - 1];
a[i - 1] = a[i];
a[i] = tmp;
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
F(N) = (1+2+3......+N) = N(N-1)/2 = N²/2 - N/2 等差数列求和
时间复杂度:O(N²)
5.计算BinarySearch的时间复杂度
int BinarySearch(int* a, int n, int x)
{
assert(a);
int left = 0;
int right = n - 1;
while (left <= right)
{
int mid = left + ((right - left) >> 1);//防止相加数据过大溢出
//原 mid = (left +right)/2
//((right - left) >>1 ) = ((right - left) * 2)
//left + ((right - left) >> 1) = left + right/2 - left/2 = left/2 + right/2 = (right +left)/2
if (a[mid] < x)
left = mid + 1;
else if (a[mid] > x)
right = mid - 1;
else
return mid;
}
return -1;
}
F(N) = ㏒₂N
时间复杂度:O(logN) (有的资料会简写成 O( lgN ) ,这个是不太对,存在误区)
二分法查找还有注意区间问题而改变
左闭右闭
int BinarySearch(int* a, int n, int x)
{
assert(a);
int left = 0;
int right = n - 1;
while (left <= right)
{
int mid = left + ((right - left) >> 1);
if (a[mid] < x)
left = mid + 1;
else if (a[mid] > x)
right = mid - 1;
else
return mid;
}
return -1;
}
左闭右开
int BinarySearch(int* a, int n, int x)
{
assert(a);
int left = 0;
int right = n ;//此处右区间为开,所以数组下标不取n-1,往后取一位
while (left < right)
{
int mid = left + ((right - left) >> 1);
if (a[mid] < x)
left = mid + 1;
else if (a[mid] > x)
right = mid ;//此处右区间为开,数组下标往后取一位,以便能取到原 mid-1
else
return mid;
}
return -1;
}
6.计算阶乘递归Fac的时间复杂度
long long Fac(size_t N) {
if(0 == N)
return 1;
return Fac(N-1)*N; }
时间复杂度:O(N)
递归算法时间复杂度计算规则:
1.每次函数调用时O(1),那么就看它的递归次数
2.每次函数调用不是O(1),那么就看他的递归调用中次数的累加
改造后:
long long Fac(size_t N)
{
if (0 == N)
return 1;
for (int i = 0; i < N; i++)
{
printf("%d ", i);
}
return Fac(N - 1) * N;
}
改造后符合上面规则2 , F(N) = N+(N-1)+(N-2)+(N-3)......+1 = N*(N-1)/2
时间复杂度:O(N²)
7.计算斐波那契递归Fib的时间复杂度
long long Fib(size_t N) {
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}
时间复杂度:O(2ⁿ) (二叉树)
二、空间复杂度
空间复杂度也是一个数学表达式,是对一个算法在运行过程中 临时占用存储空间大小的量度空间复杂度不是程序占用了多少 bytes 的空间,因为这个也没太大意义,所以空间复杂度算的是 变量的个数空间复杂度计算规则基本跟实践复杂度类似,也使用 大 O 渐进表示法
常见空间复杂度计算举例
1.
void BubbleSort(int* a, int n) {
assert(a);
for (int j = n; j > 0; j--) //创建变量 j
{
int exchange = 0; //创建变量 exchange
for (int i = 1; i < j; i++) //创建变量 i
{
if (a[i - 1] > a[i])
{
int tmp = a[i - 1]; //创建变量 tmp
a[i - 1] = a[i];
a[i] = tmp;
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
空间复杂度:O(1)
使用了常数个额外空间,所以空间复杂度为 O(1)
2.
int test(int* nums, int numsSize)
{
int* a = (int*)malloc(sizeof(int) * numsSize);//numsSize未确定
return 0;
}
时间复杂度:O(N)
int test(int* nums, int numsSize)
{
int* a = (int*)malloc(sizeof(int) * 20);//20是常数
return 0;
}
时间复杂度:O(1)
3.计算Fibonacci的空间复杂度
//返回斐波那契数列的前n项
long long* Fibonacci(int n) {
if (n == 0)
return NULL;
long long* fibArray = (long long*)malloc((n + 1) * sizeof(long long));//n+1未确定
fibArray[0] = 0;
fibArray[1] = 1;
for (int i = 2; i <= n; ++i)
{
fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
}
return fibArray;
}
空间复杂度:O(N)
动态开辟了N个空间,空间复杂度为 O(N)
4.计算阶乘递归Fac的空间复杂度
long long Fac(int N) {
if(N == 0)
return 1;
return Fac(N-1)*N; }
空间复杂度:O(N)