目录
前言:了解算法的时间复杂度和空间复杂度是学习数据结构的一个基础知识。
练习题:C语言【数据结构】算法复杂度【练习题】(含OJ题、选择题等),以及要注意的知识点_糖果雨滴a的博客-CSDN博客
一.算法效率
1.算法的复杂度
2.复杂度用处
当我们做OJ题时,会经常看到有一些题里要求时间复杂度是O(N),空间复杂度是O(1),当然不只有这两种,还有O(N^2)等。这就需要我们了解时间复杂度和空间复杂度的概念,并且要会计算。
二.时间复杂度
1.概念
void Func1(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 M = 10;
while (M--) {
++count;
}
printf("%d\n", count);
}
Func1执行的基本操作次数:F(N) = N^2 + 2 * N + 10
N = 10 F(N) = 130
N = 100 F(N) = 10210
N = 1000 F(N) = 1002010
实际中我们计算时间复杂度时,我们并不需要计算精确的执行次数,只需要大概执行次数。这里我们使用大O的渐进表示法
2.大O的渐进表示法
N = 10 F(N) = 100
N = 100 F(N) = 10000
N = 1000 F(N) = 1000000
3.举例
(1)实例1:
// 计算Func2的时间复杂度?
void Func2(int N)
{
int count = 0;
for (int k = 0; k < 2 * N; ++k)
{
++count;
}
int M = 10;
while (M--)
{
++count;
}
printf("%d\n", count);
}
基本操作执行了2N+10次,通过大O阶得:时间复杂度为O(N)
(2)实例2:
// 计算Func3的时间复杂度?
void Func3(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);
}
基本操作执行了M+N次,有两个未知数M和N,时间复杂度为O(M+N)
(3)实例3:
// 计算Func4的时间复杂度?
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++k)
{
++count;
}
printf("%d\n", count);
}
基本操作执行了100次,通过大O阶得,时间复杂度为O(1)
(4)实例4:
// 计算strchr的时间复杂度?
const char* strchr(const char* str, int character);
基本操作执行 最好情况为1次,最坏情况为N次,时间复杂度一般看最坏情况,时间复杂度O(N)
(5)实例5:
// 计算BubbleSort的时间复杂度?
void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)
{
if (a[i - 1] > a[i])
{
Swap(&a[i - 1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
基本操作执行 最好N次,最坏(N * (N + 1) / 2)次,通过大O阶,得:时间复杂度为O(N^2)
(6)实例6:
// 计算BinarySearch的时间复杂度?
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n - 1;
while (begin < end)
{
int mid = begin + ((end - begin) >> 1);
if (a[mid] < x)
begin = mid + 1;
else if (a[mid] > x)
end = mid;
else
return mid;
}
return -1;
}
基本操作执行 最好1次,最好logN次,时间复杂度为O(logN)
(logN在算法分析中表示底数为2,对数为N)
(7)实例7:
// 计算阶乘递归Fac的时间复杂度?
long long Fac(size_t N)
{
if (0 == N)
return 1;
return Fac(N - 1) * N;
}
基本操作递归了N次,时间复杂度为O(N)
(8)实例8:
// 计算斐波那契递归Fib的时间复杂度?
long long Fib(size_t N)
{
if (N < 3)
return 1;
return Fib(N - 1) + Fib(N - 2);
}
基本操作递归了2^N,时间复杂度为O(2^N)
三.空间复杂度
1.概念
2.举例
(1)实例1:
// 计算BubbleSort的空间复杂度?
void BubbleSort(int* a, int n)
{
assert(a);
for (size_t end = n; end > 0; --end)
{
int exchange = 0;
for (size_t i = 1; i < end; ++i)
{
if (a[i - 1] > a[i])
{
Swap(&a[i - 1], &a[i]);
exchange = 1;
}
}
if (exchange == 0)
break;
}
}
使用常数个额外空间,空间复杂度为O(1)
(2)实例2:
// 计算Fibonacci的空间复杂度?
// 返回斐波那契数列的前n项
long long* Fibonacci(size_t n)
{
if (n == 0)
return NULL;
long long* fibArray = (long long*)malloc((n + 1) * sizeof(long long));
fibArray[0] = 0;
fibArray[1] = 1;
for (int i = 2; i <= n; ++i)
{
fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
}
return fibArray;
}
动态开辟了N + 1个空间,空间复杂度为O(N)
(3)实例3:
// 计算阶乘递归Fac的空间复杂度?
long long Fac(size_t N)
{
if (N == 0)
return 1;
return Fac(N - 1) * N;
}
递归调用了N次,开辟了N个栈帧,每个栈帧使用了常数个空间,空间复杂度为O(N)