时间复杂度以及空间复杂度

目录

          时间复杂度以及空间复杂度的概念

          时间复杂度以及空间复杂度的计算方法

          例题练习并计算时间空间复杂度

---

什么是时间复杂度和空间复杂度？

通常用时间复杂度和空间复杂度来衡量一个算法的运行效率.

算法时间复杂度：在进行算法分析时，语句总执行次数T（n）是关于问题规模n的函数，进而分析T（n）随n的变化情况来并T（n）的数量级，算法的时间复杂度，也就是算法的时间量度，记作;T(n)=O(f(n))。他表示问题规模n的增大，算法执行时间的增长率和f（n）的增长率相同，称作算法的渐进时间复杂度，简称为时间复杂度。其中f（n）是问题规模n的某个函数。

空间复杂度：通过计算算法所需要的存储空间实现，算法空间复杂度的计算公式记作：s（n）=o（f（n）），其中，n为问题的规模，f（n）为语句关于n所占存储空间的函数

推导大O阶：

1.用常数1取代代码运行时间中所有加法常数。

2.再修改后的运行次数函数中，只保留最高阶项。

3.如果最高阶存在且不是1，则去除与这个项相乘的常数。

得到的结果就是大O阶。

时间复杂度以及空间复杂度的计算方法

常数阶：

int sum=0,n=100;
sum=n+sum;
printf("%d",sum);

该算法运行次数函数是f（n）=3；根据推导大O阶规则，常数3用1代替，没有最高阶，所以时间复杂度为O(1).

线性阶：

int i;
for(i=0;i<n;i++)
{printf("%d",i);
}

循环语句的循环体无论是几个语句，均为O（1），该代码循环了n次，n*O(1),时间复杂度为O(n)

对数阶：

for(int i=1;i<n；i*=2)
{/*时间复杂度为O(1)的程序步骤序列*/
}

很显然，i每次×2之后就会离n更进一步，也就是多少个2相乘以后大于n会退出循环，(2^x)=n,

x为log2 n，根据推导大O阶规则，得到时间复杂度O（log n）

平方阶：

for(int i=0;i<n;i++)
{for(int j=0;j<n;j++)
{/*时间复杂度为o(1)*/
}
}

该问题规模在双重for循环的内重循环中，所以同时进行两次循环，即为O(n^2);

技巧:时间复杂度:
根据代码求时间复杂度
一般情况下单重循环为o（n），n*=2或者n/=2等除外
一般双重循环为o（n^2）,二分查找除外
根据思路求时间复杂度
访问元素的个数（问题规模）
空间复杂度：额外新开辟的空间复杂度，无开辟空间为o（1）

时间复杂度的例题练习以及计算

以下代码为冒泡排序的算法代码

void swap(int *arr, int a, int b)
{
	int vlan;
	vlan = arr[a];
	arr[a] = arr[b];
	arr[b] = vlan;
}
void px(int *arr, int len)
{
	for (int j = 0; j <len; j++)//j控制次数
	{

		for (int i = 0; i <len-1 ; i++)
		{
			if (arr[i]>arr[i + 1])
			{
				swap(arr, i, i + 1);
				
			}
		
		}
		
		
	}
	
}
int main()
{
	int arr[] = { 1, 4, 2, 4, 7, 3, 0 };
	int len = sizeof(arr) / sizeof(arr[0]);
	px(arr, len);
	for (int k = 0; k < len; k++)
	{
		printf("%3d", arr[k]);
	}
}

该算法，首先将arr数组整体遍历一次，确定数组中最大一位数字的位置，

如此下去，进行n（数组长度）次遍历，所以时间复杂度为O(n^2),因为没有开辟新的空间，所以空间复杂度为O（1）；

奇数在前偶数在后问题

该问题有两种解决办法

第一种：重新定义两个数组，将原数组整体遍历一遍，把其中的奇数和偶数放入新定义的两个数组中，即把原数组整体遍历了一遍，新定义两个数组遍历一次，相加之后为2n，根据大O阶规则计算时间复杂度为O（n），新开辟了两个数组，均遍历了一遍，和为2n，同样根据大O阶规则计算空间复杂度为O（n），此处因为代码运行效率第，不做代码演示

第二种：在数组前后定义两个变量，同时对数组两边进行遍历，数组起始位置开始遍历，找到偶数停止，数组结尾位置开始遍历，找到奇数停止，此时对两数进行交换，交换完成之后，继续遍历，直到两变量即将重合的临界点。该算法只对数组遍历了一次，所以时间复杂度为O（n），因为没有新开辟空间，所以空间复杂度为O（1），代码实现如下，同第一种办法相比较，空间复杂度低，显然代码运行效率更高。

void swap(int *arr, int i, int j)
{
	int vlan=arr[i];
	arr[i] = arr[j];
	arr[j] = vlan;
}
void parr(int* arr,int len)
{
	int i = 0, j = len - 1;
	while (i < j)
	{
		/*while (i<j&&((arr[i] & 1) == 1))//碰见奇数进入循环
		{
			i++;
			
		}
		while (i<j&&((arr[j] & 1) == 0))//碰见偶数进入循环
		{
			j--;
		}*/
		for (; i < j; i++)
		{
			if ((arr[i]&1)== 0)//遇见偶数退出循环
			{
				break;
			}
		}
		for (; j>i; j--)
		{
			if ((arr[j]&1 )== 1)//碰见奇数退出循环
			{
				break;
			}
		}
		if (i<j)
		swap(arr, i, j);
	}


}
int main(){
	int arr[] = { 2,4,5};
	int len = sizeof(arr) / sizeof(arr[0]);
	parr(arr,len);
	for (int i = 0; i < len; i++)
	{
		printf("%3d", arr[i]);
	}


}