一、算法的复杂度
衡量一个算法的好坏,一般是从时间和空间两个维度来衡量的,即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢,而空间复杂度主要衡量一个算法运行所需要的额外空间。
算法的时间复杂度
算法中的基本操作的执行次数,为算法的时间复杂度。
算法的空间复杂度
空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。
时间复杂度和空间复杂度都是由大O的渐近表示法来表示
推导大O阶方法:
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中,只保留最高阶项。
3、如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。
二、常见复杂度对比
三、常见的时间复杂度和空间复杂度的计算
一、时间复杂度计算举例
// 计算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);
}
O(N*2+10),Func2的时间复杂度为O(N)
// 计算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);
}
O(M+N),若M>>N 则时间复杂度为 O(M),反之则为O(N).
若M==N则时间复杂度为O(N)或O(M).
// 计算Func4的时间复杂度?
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf("%d\n", count);
}
O(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((N+1)*(N)/2) 时间复杂度为O(N^2)
// 计算BinarySearch的时间复杂度?
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n-1;
// [begin, end]:begin和end是左闭右闭区间,因此有=号
while (begin <= end)
{
int mid = begin + ((end-begin)>>1);
if (a[mid] < x)
begin = mid+1;
else if (a[mid] > x)
end = mid-1;
else
return mid;
}
return -1;
}
二分查找 O(logn);ps:logN在算法分析中表示是底数为2,对数为N。
// 计算阶乘递归Fac的时间复杂度?
long long Fac(size_t N)
{
if(0 == N)
return 1;
return Fac(N-1)*N;
}
O(N)
// 计算斐波那契递归Fib的时间复杂度?
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}
O(logN)
二、空间复杂度计算举例
// 计算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),开了常数个
// 计算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;
}
O(N)
// 计算阶乘递归Fac的空间复杂度?
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}
O(N)
四、复杂度的oj练习
一、消失的数字
. - 力扣(LeetCode). - 备战技术面试?力扣提供海量技术面试资源,帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。https://leetcode-cn.com/problems/missing-number-lcci
大家看这道题是不是感觉有些熟悉呢??
有没有想到之前的那个单身狗问题呢?
这个题也跟那个题类似,先定义一个int类数,然后先与n个数异或,再与数组中的数异或
最后这个数就是数组中缺少的值.
因为1^1=0
int missingNumber(int* nums, int numsSize){
int num=0;
for(int i=0;i<=numsSize;i++){
num^=i;
}
for(int i=0;i<numsSize;i++){
num^=nums[i];
}
return num;
}
int missingNumber(int* nums, int numsSize){
int num=0;
for(int i=0;i<=numsSize;i++){
num+=i;
}
for(int i=0;i<numsSize;i++){
num-=nums[i];
}
return num;
}
二、旋转数组
. - 力扣(LeetCode). - 备战技术面试?力扣提供海量技术面试资源,帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。https://leetcode-cn.com/problems/rotate-array
这个题有两种思路:
思路一:先将n-k个逆置,再将后k个逆置,最后直接整体逆置。(妙啊!!!)
void rotate(int* nums, int numsSize, int k) {
k%=numsSize;
int tmp[numsSize];
int n=numsSize;
memcpy(tmp,nums+n-k,sizeof(int)*k);
memcpy(tmp+k,nums,sizeof(int)*(n-k));
memcpy(nums,tmp,sizeof(int)*(n));
}
文章来源:https://www.toymoban.com/news/detail-847886.html
void Reverse(int*a,int left,int right){
int tmp=a[left];
a[left]=a[right];
a[right]=tmp;
right--;
left++;
}
void rotate(int* nums, int numsSize, int k) {
k%=numsSize;
//[0,numssize-k-1]
Reverse(nums,0,numsSize-k-1);
//[numssize-k,numssize-1]
Reverse(nums,numsSize-k,numsSize-1);
Reverse(nums,0,numsSize-1);
}
今天的内容就到此位置了,谢谢各位大佬观看!!!
文章来源地址https://www.toymoban.com/news/detail-847886.html
到了这里,关于学习数据结构:算法的时间复杂度和空间复杂度的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!