数据结构基础：P1-基本概念----编程作业01：最大子列和问题

本系列文章为浙江大学陈越、何钦铭数据结构学习笔记，前面文章链接如下：
数据结构基础：P1-基本概念

---

一、题目描述

题目描述： 给定K个整数组成的序列 { N 1 , N 2 , . . . , N k } \{ {N_1},{N_2},...,{N_k}\} { N1​,N2​,...,Nk​} ，“连续子列”被定义为 { N i , N i + 1 , . . . , N j } \{ {N_i},{N_{i + 1}},...,{N_j}\} { Ni​,Ni+1​,...,Nj​}，其中 $1\le i\le j\le K$。“最大子列和”则被定义为所有连续子列元素的和中最大者。例如给定序列{ -2, 11, -4, 13, -5, -2 }，其连续子列{ 11, -4, 13 }有最大的和20。现要求你编写程序，计算给定整数序列的最大子列和。
本题旨在测试各种不同的算法在各种数据情况下的表现。各组测试数据特点如下：
• 数据1：与样例等价，测试基本正确性；
• 数据2：$10^2$个随机整数；
• 数据3：$10^3$个随机整数；
• 数据4：$10^4$个随机整数；
• 数据5：$10^5$个随机整数；
输入格式：
输入第1行给出正整数 $K(\le 100000)$；第2行给出 $K$ 个整数，其间以空格分隔。
输出格式：
在一行中输出最大子列和。如果序列中所有整数皆为负数，则输出0。
输入样例：
6
-2 11 -4 13 -5 -2
输出样例：
2

二、代码实现

根据第一章的课程内容，使用4种方法实现，复杂度依次递减。具体实现代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int Max3(int A, int B, int C)
{
    
     /* 返回3个整数中的最大值 */
	return A > B ? A > C ? A : C : B > C ? B : C;
}

//1、暴力搜索。算法复杂度：O(N^3)
int MaxSubseqSum1(int A[], int N)
{
    
    
	int ThisSum, MaxSum = 0;
	int i, j, k;
	for (i = 0; i < N; i++)
	{
    
    
		for (j = i; j < N; j++)
		{
    
    
			ThisSum = 0;
			for (k = i; k <= j; k++)
				ThisSum += A[k];
			if(ThisSum > MaxSum)
				MaxSum = ThisSum;
		}
	}
	return MaxSum;
}

//2、改进暴力搜索。算法复杂度：O(N^2)
int MaxSubseqSum2(int A[], int N)
{
    
    
	int ThisSum, MaxSum = 0;
	int i, j, k;
	for (i = 0; i < N; i++)
	{
    
    
		ThisSum = 0;
		for (j = i; j < N; j++)
		{
    
    
			ThisSum += A[j];
			if (ThisSum > MaxSum)
				MaxSum = ThisSum;
		}
	}
	return MaxSum;
}

//3、分而治之。算法复杂度：O(NlogN)
int DivideAndConquer(int List[], int left, int right)
{
    
     /* 分治法求List[left]到List[right]的最大子列和 */
	int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
	int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/

	int LeftBorderSum, RightBorderSum;
	int center, i;

	if (left == right) {
    
     /* 递归的终止条件，子列只有1个数字 */
		if (List[left] > 0)  return List[left];
		else return 0;
	}

	/* 下面是"分"的过程 */
	center = (left + right) / 2; /* 找到中分点 */
	/* 递归求得两边子列的最大和 */
	MaxLeftSum = DivideAndConquer(List, left, center);
	MaxRightSum = DivideAndConquer(List, center + 1, right);

	/* 下面求跨分界线的最大子列和 */
	MaxLeftBorderSum = 0; LeftBorderSum = 0;
	for (i = center; i >= left; i--) {
    
     /* 从中线向左扫描 */
		LeftBorderSum += List[i];
		if (LeftBorderSum > MaxLeftBorderSum)
			MaxLeftBorderSum = LeftBorderSum;
	} /* 左边扫描结束 */

	MaxRightBorderSum = 0; RightBorderSum = 0;
	for (i = center + 1; i <= right; i++) {
    
     /* 从中线向右扫描 */
		RightBorderSum += List[i];
		if (RightBorderSum > MaxRightBorderSum)
			MaxRightBorderSum = RightBorderSum;
	} /* 右边扫描结束 */

	/* 下面返回"治"的结果 */
	return Max3(MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum);
}

int MaxSubseqSum3(int List[], int N)
{
    
     /* 保持与前2种算法相同的函数接口 */
	return DivideAndConquer(List, 0, N - 1);
}

//4、在线处理。算法复杂度：O(N)
int MaxSubseqSum4(int A[], int N)
{
    
    
	int MaxSum = 0, ThisSum = 0;
	for (int i = 0; i < N; i++) {
    
    
		ThisSum += A[i];
		if(ThisSum > MaxSum){
    
    
			MaxSum = ThisSum;
		}
		else {
    
    
			if (ThisSum < 0) {
    
    
				ThisSum = 0;
			}
		}
	}
	return MaxSum;
}

int main()
{
    
    
	int Array[10000];
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
    
    
		scanf("%d", &Array[i]);
	}

	int res = MaxSubseqSum4(Array, n);
	//res = MaxSubseqSum3(Array, n);
	//res = MaxSubseqSum2(Array, n);
	//res = MaxSubseqSum1(Array, n);
	if (res > 0) {
    
    
		printf("%d\n", res);
	}
	else {
    
    
		printf("0\n");
	}

	return 0;
}

运行，结果正确。