递归的空间复杂度

Posted 2023-04-22

递归折半查找的时间复杂度是O(log2n)，空间复杂度是O(log2n)，也是递归的最大深度
非递归的时间复杂度是O(log2n)，空间复杂度是O(1)，仅仅用几个单变量就够。空间复杂度:
是程序运行所以需要的额外消耗存储空间,一般的递归算法就要有o(n)的空间复杂度了,简单说就是递归集算时通常是反复调用同一个方法，递归n次，就需要n个空间。
时间复杂度：
一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f (n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。
按数量级递增排列，常见的时间复杂度有：
常数阶O(1),对数阶O(log2n),线性阶O(n
k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。 参考技术A 空间复杂度:
是程序运行所以需要的额外消耗存储空间,一般的递归算法就要有o(n)的空间复杂度了,简单说就是递归集算时通常是反复调用同一个方法，递归n次，就需要n个空间。
时间复杂度：
一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f (n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。

按数量级递增排列，常见的时间复杂度有：

常数阶O(1),对数阶O(log2n),线性阶O(n),

线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),...，

k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

归并排序(递归+非递归)

(文章目录)

1. 归并排序 递归

1.基本思想

2. 使用两个函数完成归并

3. 递归结束条件

4.时间复杂度与空间复杂度计算

1. 时间复杂度

2. 空间复杂度

5. 代码

void mergesort1(int* a, int left, int right,int* tmp)

if (left >= right)//递归 结束条件

return;

int mid = (left + right) / 2;
// [left ,mid] [mid+1 ,right] 
mergesort1(a, left, mid,tmp);
mergesort1(a, mid + 1, right,tmp);
// 合并两个有序数组，并将其赋给临时数组tmp，最后拷贝原数组中(合并一部分，拷贝一部分)
int begin1 = left;
int end1 = mid;
int begin2 = mid + 1;
int end2 = right;
int i = left;//由于部分合并，所以i从left开始
while (begin1<=end1&&begin2<=end2)

if (a[begin1] < a[begin2])

tmp[i++] = a[begin1++];

else

tmp[i++] = a[begin2++];


 //若出了循环后，也有可能在两个数组有剩余的情况
while (begin1 <= end1)//若 [begin1,end1]数组有剩余，直接赋值到tmp数组

tmp[i++] = a[begin1++];

while (begin2 <= end2)//若 [begin2,end2]数组有剩余，直接赋值到tmp数组

tmp[i++] = a[begin2++];

 //第一种拷贝方式
memcpy(a+left, tmp+left, sizeof(int) * (right - left + 1));
 //第二种拷贝方式
/*for (i = 0; i <= right; i++)

a[i] = tmp[i];
*/

void mergesort(int* a, int n)// 归并排序 递归

int* tmp = (int*)malloc(sizeof(int) * n);
mergesort1(a, 0, n - 1,tmp);
free(tmp);
tmp = NULL;

2. 归并排序 非递归

1. 思想

2. 越界问题

1. .end1 beign2 end2 越界

方式 1

方式 2

整体拷贝与拷贝一部分，归并一部分的区别

2. begin2 end2 越界

方式 1

方式 2

3. end2 越界

3. 代码

void mergesortNonR(int* a, int n)//归并排序 非递归

	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	
		perror("malloc fail");
		exit(-1);
	
	int gap = 1;
	int i = 0;
	int j = 0;
	while (gap < n)
	
		for (i = 0; i < n; i += 2*gap)
		
			//[ i , i+gap-1][i+gap,i+2*gap-1]
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2*gap-1 ;
			j = i;

			//1. end1 begin2 end2 越界
			if (end1 >= n)//end2是下标的存在 ，最多取到 n-1
			
				break;
			
			//if (end1 >= n)//修正区间
			//
			//	end1 = n - 1;
			//	begin2 = n;
			//	end2 = n - 1;
			//
			//2.  begin2 end2 越界
			else if (begin2 >= n)
			
				break;
			
			/*else if (begin2 >= n)
			
				begin2 = n;
				end2 = n - 1;
			*/
			//3. end2 越界
			else if (end2 >= n)
			
				end2 = n - 1;
			
			while (begin1 <= end1 && begin2 <= end2)
			
				if (a[begin1] <= a[begin2])
				
					tmp[j++] = a[begin1++];
				
				else
				
					tmp[j++] = a[begin2++];
				
			
			while (begin1 <= end1)
			
				tmp[j++] = a[begin1++];
			
			while (begin2 <= end2)
			
				tmp[j++] = a[begin2++];
			
			//归并一部分，拷贝一部分
			memcpy(a+i, tmp+i, sizeof(int) * (end2-i+1));
		
		gap *= 2;
	
	free(tmp);
	tmp = NULL;