数据结构学习笔记系列3——算法案例分析

数据结构学习笔记系列1
视频网址： https://www.bilibili.com/video/av18586085
汇总贴链接：https://blog.youkuaiyun.com/DX5618258/article/details/104085229

1.3.1 应用实例_算法1&2

案例如下：

算法1：

int MaxSubseqSum1(int A[], int N)
{
	int ThisSum, MaxSum = 0;
	/*i是子列左端位置*/
	for (int i = 0; i < N; i++)
	{
		/*j是子列右端的位置*/
		for (int j = i; j < N; j++)
		{
			/*ThisSum是从A[i]到A[j]的子列和*/
			ThisSum = 0;
			for (int k = i; k <= j; k++) ThisSum += A[k];
			/*如果刚得到的这个子列和更大，更新最大结果*/
			if (ThisSum > MaxSum) MaxSum = ThisSum;
		}/*j循环结束*/
	}/*i循环结束*/
	return MaxSum;
}

时间复杂度 T(N)=O(N^3)

算法2：

int MaxSubseqSum2(int A[],int N) 
{
	int ThisSum, MaxSum = 0;
	/*i是子列左端位置*/
	for (int i = 0; i < N; i++) 
	{
		/*ThisSum是从A[i]到A[j]的子列和*/
		ThisSum = 0;
		/*j是子列右端位置*/
		for (int j = i; j < N; j++) 
		{
			/*对于相同的i，不同的j，只要在j-1次循环的基础上累加1项即可*/
		    ThisSum += A[j];
			/*如果刚得到的这个子列和更大，更新最大结果*/
			if (ThisSum > MaxSum) { MaxSum = ThisSum; }
		}/*j循环结束*/
	}/*i循环结束*/
	return MaxSum;
}

时间复杂度 T(N)=O(N^2)

相比算法1而言，算法2只是将算法1的第三层for循环（依次累加各元素）改进成了只加对应的一项，减少将复杂度从O(N^3 )降为O(N^2) 。

1.3.2 应用实例_算法3

算法3（分而治之->递归分组）：

算法的复杂度见上图，但是采用的递归算法造成空间复杂度较高。

1.3.3 应用实例_算法4

算法4（在线处理）：

int MaxSubseqSum4(int A[], int N) 
{
	int ThisSum, MaxSum = 0;  ThisSum = MaxSum = 0;
	/*i是子列左端位置*/
	for (int i = 0; i < N; i++)
	{
		ThisSum += A[i];
		/*发现更大的和则更新当前结果*/
		if (ThisSum>MaxSum) 	MaxSum = ThisSum;
		/*如果当前子列和为负，则弃之*/
		else if (ThisSum < 0)  ThisSum = 0;
	}
	return MaxSum;
}

时间复杂度 T(N)=O(N)
主要特点是利用else if判断当前子列和如果小于0，则直接放弃，因为在子列中添加一个小于0的元素和导致结果一定是比当前的子列和要小的。
运行时间比较（秒）

全部测试代码如下：

#include <iostream>
#include <time.h>
#include <stdlib.h>

/*宏定义*/
/*定义多项式最大项数*/
#define MAXN 100000
/*定义随机数的最大值和最小值*/
#define MAXNUM 10
#define MINNUM -10

/*函数声明*/
int MaxSubseqSum1(int A[], int N);
int MaxSubseqSum2(int A[], int N);
int MaxSubseqSum4(int A[], int N);


int main()
{
	/*声明并初始化系数数组*/
	int a[MAXN];
	int result = 0;
	for (int i = 0; i < MAXN; i++) 
	{
		a[i] = (rand() % (MAXNUM - MINNUM + 1)) + MINNUM;
		printf("%d   ",a[i]);
	}

	result = MaxSubseqSum4( a , MAXN );
	printf("%d\n",result);

	return 0;
}


int MaxSubseqSum1(int A[], int N)
{
	int ThisSum, MaxSum = 0;
	/*i是子列左端位置*/
	for (int i = 0; i < N; i++)
	{
		/*j是子列右端的位置*/
		for (int j = i; j < N; j++)
		{
			/*ThisSum是从A[i]到A[j]的子列和*/
			ThisSum = 0;
			for (int k = i; k <= j; k++) ThisSum += A[k];
			/*如果刚得到的这个子列和更大，更新最大结果*/
			if (ThisSum > MaxSum) MaxSum = ThisSum;
		}/*j循环结束*/
	}/*i循环结束*/
	return MaxSum;
}


int MaxSubseqSum2(int A[],int N) 
{
	int ThisSum, MaxSum = 0;
	/*i是子列左端位置*/
	for (int i = 0; i < N; i++) 
	{
		/*ThisSum是从A[i]到A[j]的子列和*/
		ThisSum = 0;
		/*j是子列右端位置*/
		for (int j = i; j < N; j++) 
		{
			/*对于相同的i，不同的j，只要在j-1次循环的基础上累加1项即可*/
		    ThisSum += A[j];
			/*如果刚得到的这个子列和更大，更新最大结果*/
			if (ThisSum > MaxSum) { MaxSum = ThisSum; }
		}/*j循环结束*/
	}/*i循环结束*/
	return MaxSum;
}




int MaxSubseqSum4(int A[], int N) 
{
	int ThisSum, MaxSum = 0;
	ThisSum = MaxSum = 0;
	/*i是子列左端位置*/
	for (int i = 0; i < N; i++)
	{
		/*向右累加*/
		ThisSum += A[i];
		/*发现更大的和则更新当前结果*/
		if (ThisSum>MaxSum) 
		{
			MaxSum = ThisSum;
		}
		/*如果当前子列和为负，则弃之*/
		else if (ThisSum < 0) 
		{
			ThisSum = 0;
		}
	}
	return MaxSum;
}