数据结构入门——时间复杂度和空间复杂度

> 1. 时间复杂度：

时间复杂度实际上就是一个函数，计算程序执行的总次数（不是计算时间，是计算语句执行次数）；** 在进行时间复杂度计算时要注意：

1）在实际中通常考虑的是算法运行的最坏情况；

2）关注运行时间的增长趋势，关注增长最快的项即可，其他可进行忽略

比如：F（n)=8*n^2+9*n+9;其时间复杂度为O（n^2);

3)递归算法的时间复杂度计算：递归总次数*每次递归操作数

2、空间复杂度

它是对一个算法在运行过程中临时占用存储空间大小的量度，强调的是使用辅助空间的大小，不是所有的数据所占用的空间，不会一直累加。

（计算的不是空间，而是函数中创建的对象的个数） 递归算法的空间复杂度：

递归总次数为n*每次递归的辅助空间大小。若每次递归的辅助空间大小为常数， 则其空间复杂度为O（n)

咱们用以下实例来分析以下时间复杂度与空间复杂度**

折半查找—–非递归

#include<stdio.h>
#include<stdlib.h>
int BinarySearch(int arr[],int sz,int n)
{
int left=0;
int right=sz-1;
while(left<=right)
{
int mid=left+((right-left)>>1);
if(arr[mid]>n)
{
right=right-1;
}
else if(arr[mid]<n)
{
left=left+1;
}
else
{
return mid;
}

}
return -1;
}
int main()
{
int arr[]={1,2,3,4,5,6,7,8,9};
int sz=sizeof(arr)/sizeof(arr[0]);
printf("%d\n", BinarySearch(arr,sz,1));
printf("%d\n",  BinarySearch(arr,sz,2));
printf("%d\n",  BinarySearch(arr,sz,3));
printf("%d\n",  BinarySearch(arr,sz,4));
printf("%d\n",  BinarySearch(arr,sz,5));
printf("%d\n",  BinarySearch(arr,sz,6));
printf("%d\n",  BinarySearch(arr,sz,7));
printf("%d\n",  BinarySearch(arr,sz,8));
printf("%d\n",  BinarySearch(arr,sz,9));
system("pause");
return 0;
}
时间复杂度：O（log2 N)//每次查找缩小一半范围，即每次运行的次数为log2 N所以不难算出时间复杂度为----->O（log2 N）
空间复杂度：O(1)   创建的对象为常数个

折半查找——-递归

#include<stdio.h>
#include<stdlib.h>
int  BinarySearch(int arr[],int left,int right,int n)
{
int mid=left+((right-left)>>1);
while(left<=right)
{
if(arr[mid]==n)
{
return mid;
}
else if(arr[mid]>n)
{
return BinarySearch(arr,left,mid-1,n);
}
else if(arr[mid]<n)
{
return BinarySearch(arr,mid+1,right,n);
}
}
return -1;
}
int main()
{
int arr[]={1,2,3,4,5,6,7,8,9};
int left=0;
int sz=sizeof(arr)/sizeof(arr[0]);
int right=sz-1;
printf("%d\n",  BinarySearch(arr,left,right,1));
printf("%d\n",  BinarySearch(arr,left,right,2));
printf("%d\n", BinarySearch(arr,left,right,3));
printf("%d\n", BinarySearch(arr,left,right,4));
printf("%d\n", BinarySearch(arr,left,right,5));
printf("%d\n", BinarySearch(arr,left,right,6));
printf("%d\n", BinarySearch(arr,left,right,7));
printf("%d\n", BinarySearch(arr,left,right,8));
printf("%d\n", BinarySearch(arr,left,right,9));

system("pause");
return 0;
}
时间复杂度：递归总次数log2 N，每次执行的时间复杂度为O（1）------>O(log2  N)
空间复杂度：递归总次数log2 N，每次创建的对象都是常数个--------->O(log2   N)

斐波那锲数——-非递归

int fib(int n)//1 1 2 3 5 8 13
{
int first=1;
int second=1;
int sum=0;
if(n<3)
{
return 1;
}
while(n>2)
{
sum=first+second;
first=second;
second=sum;
n--;
}

return  sum;
}
时间复杂度：O（N)---程序运行n次
空间复杂度：O(1)---创建的对象为常数个

斐波那锲数—递归

long long fib(int n)
{
if(n<3)
return 1;
else
return fib(n-1)+fib(n-2);
}

每一次的计算都被分成前两个数之和，依次往下递归，类似于二叉树
当n较大时，形成一个满二叉树

时间复杂度：O（2^n)
空间复杂度：O(n)