最大子序列（4种解决算法）

fitpolo

已于 2022-07-08 14:46:48 修改

阅读量196

点赞数 1

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签：算法数据结构 c++

于 2022-06-21 10:00:38 首次发布

本文链接：https://blog.csdn.net/qq_31806069/article/details/125385617

数据结构专栏收录该内容

14 篇文章

订阅专栏

这篇博客探讨了四种不同的算法实现，用于找到一个整数数组中的最大子序列和。第一种和第二种算法使用双重循环计算所有可能的子序列和，然后选取最大值。第三种算法采用了递归的方法，将问题分解为更小的部分。第四种算法是最高效的，它使用前缀和策略，遍历数组一次即可找到最大子序列和。在效率上，第四种算法优于其他三种。测试代码展示了如何应用这些算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

//这种比较直观，但执行速度最慢

int MaxSubsequenceSum1(const int a[],int n)
{
	int this_sum,max_sum,i,j,k;
	
	max_sum = 0;
	for (i=0; i<n; i++)
	{
		for (j=i; j<n; j++)
		{
			this_sum = 0;
			for (k=i; k<=j ;k++)
			{
				this_sum += a[k];
			}
			
			if (this_sum > max_sum)
			{
				max_sum = this_sum;
			}
		}
	}
	return max_sum;
}

//在第一种算法，优化

int MaxSubsequenceSum2(const int a[],int n)
{
	int this_sum,max_sum,i,j,k;
	
	max_sum = 0;
	for (i=0; i<n; i++)
	{
		for (j=i; j<n; j++)
		{
			this_sum = 0;
			for (k=i; k<=j ;k++)
			{
				this_sum += a[k];
				if (this_sum > max_sum)
				{
					max_sum = this_sum;
				}
			}
		}
	}
	return max_sum;
}

//使用递归方法来处理。

static int max3(int a,int b,int c)
{
	if (a>=b && a>=c)
	return a;
	if (b>=a && b>=c)
	return b;
	return c;
}
int MaxSubsequenceSum3(const int a[],int left,int right)
{
	int max_left_sum,max_right_sum;
	int max_left_border_sum,max_right_border_sum;
	int left_border_sum,right_border_sum;
	int center,i;
	
	if (left == right)
	{
		if (a[left] > 0)
		{
			return a[left];
		}else
		{
			return 0;	
		}
	}
	
	center = (left + right )/2;
	max_left_sum = MaxSubsequenceSum3(a,left,center);
	max_right_sum = MaxSubsequenceSum3(a,center+1,right);
	
	max_left_border_sum = 0;
	left_border_sum = 0;
	for (i=center; i>=left; i--)
	{
		left_border_sum += a[i];
		if (left_border_sum > max_left_border_sum)
			max_left_border_sum = left_border_sum;
	}
	
	max_right_border_sum = 0;
	right_border_sum = 0;
	for (i=center+1; i<=right; i++)
	{
		right_border_sum += a[i];
		if (right_border_sum > max_right_border_sum)
	 		max_right_border_sum = right_border_sum;
	}
	
	return max3(max_left_sum,max_right_sum,max_left_border_sum+max_right_border_sum);
	
}

//在这四种算法中，解决最大子序列最高效（最完美的）。


int MaxSubsequenceSum4(const int a[],int n)
{
	int this_sum,max_sum,i,j,k;
	
	this_sum = 0;
	max_sum = 0;
	for (i=0; i<n; i++)
	{
		this_sum += a[i];
		if (this_sum > max_sum)
			max_sum = this_sum;
		else if (this_sum < 0)
			this_sum = 0;
	}
	return max_sum;
}

//测试代码

int main(int argc, char *argv[])
{
	int max_sum = 0;
	#define BUF_SIZE 6
	int buf[BUF_SIZE]={-2,11,-4,13,-5,-2};
	//max_sum = MaxSubsequenceSum2(buf,BUF_SIZE);
	
	//max_sum = MaxSubsequenceSum3(buf,0,BUF_SIZE-1);
	
	max_sum = MaxSubsequenceSum4(buf,BUF_SIZE);
	
	printf("max_sum:%d\r\n",max_sum);
	return 0;
}