返回一个整数数组中最大子数组的和（数组首尾相连）

最新推荐文章于 2024-09-30 10:56:43 发布
最新推荐文章于 2024-09-30 10:56:43 发布
阅读量96 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/wangzongze/p/5325305.html
版权

一：题目内容及设计思路

1.题目：

　　返回一个整数数组中最大数组的和（数组首尾相连）

2.要求：

　　（1）输入一个整型数组，数组里有正数也有负数。

　　（2）数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

　　（3）如果数组A[0],......,A[n-1]首尾相邻，允许A[i-1],......,A[n-1],A[0],......,A[i-2]之和最大。

　　（4）同时返回最大子数组的位置。

3.设计思路：

　　（1）利用while循环输入各个整数，用getchar()函数判断while循环是否结束，当用户按下回车键时，即getchar()=='\n'时，跳出while循环；

　　（2）记录下循环的次数，即数组长度；

　　（3）构造子数组结构SArray，包含属性Sdata、start、end分别表示子数组中的数、子数组的起始位置、子数组的终止位置；

　　（4）构造链表的存储结构LNode,包含属性data、position、*next分别表示链表结点中的数据、数据在原整数数组中的位置、指向结点的指针；

　　（5）在主函数中调用void CreateList(LinkList &L, int Group[], int n)函数将整数数组存入循环链表中；

　　（6）在主函数中调用SArray Divide(LinkList L, int length)函数，将含n个数的循环数组依次从各个点断开，产生n个含n个数组的单链数组；

　　（7）在SArray Divide(LinkList L, int length)函数中调用SArray Compare(LinkList L, int Length)函数，返回最大子数组。

4.结对开发伙伴：

　　姓名：程思敏

　　博客名：鹏程万里之思

　　博客地址链接：http://home.cnblogs.com/u/pengchengwanli/

二：具体实现

1.实验代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
//返回一个整数数组中最大子数组的和（数组首尾相连）
#include<iostream>
#define N 100
using  namespace  std;
 
//构造子数组结构
typedef  struct  SArray
{
     int  Sdata;   //子数组中的数
     int  start;   //子数组的起始位置
     int  end;     //子数组的终止位置
}SArray;
 
//构造链表的存储结构
typedef  struct  LNode
{
     int  data;    //数
     int  position;    //数所在数组中的位置
     struct  LNode *next;  //指针
}LNode, *LinkList;
 
//创建循环链表
void  CreateList(LinkList &L,  int  Group[],  int  n)
{
     L =  new  LNode;
     L->next = NULL;
     LNode *r;
     r = L;
     for  ( int  i = 0; i < n - 1; i++)
     {
         LNode *p;
         p =  new  LNode;
         p->data = Group[i];
         p->position = i + 1;
         p->next = NULL;
         r->next = p;
         r = p;
     }
     LNode *p;
     p =  new  LNode;
     p->data = Group[n - 1];
     p->position = n;
     p->next = L->next;
     r->next = p;
}
 
//返回最大子数组
SArray Compare(LinkList L,  int  Length)
{
     SArray MaxSum[N][2];
     //MaxSum[N][0].Sdata表示前N-1个数中，最大的子数组
     //MaxSum[N][1].Sdata表示前N-1个数的最大的子数组和加第N个数的和与第N个数相比的最大值
     LNode *r;
     r = L->next;
     MaxSum[0][0].Sdata = MaxSum[0][1].Sdata = r->data;
     MaxSum[0][0].start = MaxSum[0][1].start = r->position;
     MaxSum[0][0].end = MaxSum[0][1].end = r->position;
     for  ( int  i = 1; i < Length; i++)
     {
         if  (MaxSum[i - 1][0].Sdata > MaxSum[i - 1][1].Sdata)
         {
             MaxSum[i][0].Sdata = MaxSum[i - 1][0].Sdata;
             MaxSum[i][0].start = MaxSum[i - 1][0].start;
             MaxSum[i][0].end = MaxSum[i - 1][0].end;
         }
         else
         {
             MaxSum[i][0].Sdata = MaxSum[i - 1][1].Sdata;
             MaxSum[i][0].start = MaxSum[i - 1][1].start;
             MaxSum[i][0].end = MaxSum[i - 1][1].end;
         }
         if  (MaxSum[i - 1][1].Sdata + r->next->data > r->next->data)
         {
             MaxSum[i][1].Sdata = MaxSum[i - 1][1].Sdata + r->next->data;
             MaxSum[i][1].start = MaxSum[i - 1][1].start;
             MaxSum[i][1].end = r->next->position;
         }
         else
         {
             MaxSum[i][1].Sdata = r->next->data;
             MaxSum[i][1].start = r->next->position;
             MaxSum[i][1].end = r->next->position;
         }
         r = r->next;
     }
     if  (MaxSum[Length - 1][0].Sdata > MaxSum[Length - 1][1].Sdata)
     {
         return  MaxSum[Length - 1][0];
     }
     else
     {
         return  MaxSum[Length - 1][1];
     }
}
 
//将含n个数的循环数组依次从各个点断开，产生n个含n个数组的单链数组
SArray Divide(LinkList L,  int  length)
{
     LinkList LGroup[N];  //头节点集合
     LNode *r;
     r = L;
     for  ( int  i = 0; i < length; i++)
     {
         LGroup[i] = r;
         r = r->next;
     }
     SArray MaxGroup[N];  //分成的各个数组的最大子数组的集合
     for  ( int  i = 0; i < length; i++)
     {
         MaxGroup[i].Sdata = Compare(LGroup[i], length).Sdata;
         MaxGroup[i].start = Compare(LGroup[i], length).start;
         MaxGroup[i].end = Compare(LGroup[i], length).end;
     }
     SArray Max = MaxGroup[0];    //各个数组的最大子数组和的最大值
     for  ( int  i = 1; i < length; i++)
     {
         if  (Max.Sdata < MaxGroup[i].Sdata)
         {
             Max.Sdata = MaxGroup[i].Sdata;
             Max.start = MaxGroup[i].start;
             Max.end = MaxGroup[i].end;
 
         }
     }
     return  Max;
}
 
int  main()
{
     int  Number[N];   //整数数组
     int  length;  //数组长度
     cout <<  "请输入一个整型数组："  << endl;
     cin >> Number[0];
     length = 1;
     while  ( getchar () !=  '\n' )
     {
         cin >> Number[length++];
     }
     LinkList L;
     CreateList(L, Number, length);
     cout <<  "该数组中的最大的子数组和为：" ;
     cout << Divide(L, length).Sdata << endl;
     cout <<  "该最大子数组的起始位置为：" ;
     cout << Divide(L, length).start << endl;
     cout <<  "该最大子数组的终止位置为：" ;
     cout << Divide(L, length).end << endl;
     return  0;
}

2.运行结果截图

三：总结

本次实验是在上一次实验的基础上完成的，由于思路清晰，模块划分得当，所以花的时间并不是很多。

项目计划总结：

日期\任务听课编写程序查阅资料日总计
星期一2 13
星期二    
星期三  1 1
星期四2  2
星期五 1 1
星期六 2 2
星期日 2 2
周总计452

11

 

时间记录日志：

日期开始时间结束时间中断时间静时间活动备注
3/2114：0015：5010100听课软件工程
 19:  3020:  401060查阅资料查阅数据结构课本
3/22      
       
3/2319：20　20：20 60查阅资料查阅数据结构课本
 14：2015：301060编写程序编写周二的程序
3/2414：0015：5010100听课软件工程
       
3/2519：30　20：401060编写程序编写周二的程序
       
3/269：20　11：4010130编写程序编写周四的程序
 13：2014：20 60写博客写博客
3/277：309：30 120编写程序编写周四的程序
 9：3010：10 40写博客写博客

缺陷记录日志：

日期编号引入阶段排除阶段修复时间&问题描述
3/211   
3/222   
3/233编码查询资料　　编写程序，没弄明白getchar()函数，半小时后解决问题 
3/244   
3/255编码调试编写程序，调试，解决递归问题，程序完成
3/266编码调试顺利将数组存入循环链表中，发现不能将循环链表分开
3/277编码调试

花了30分钟调试循环链表问题解决，用另外的指针代替头结点移动去分开循环链表。

然后再构造子数组结构来解决输出最大子数组位置问题。

转载于:https://www.cnblogs.com/wangzongze/p/5325305.html

weixin_30371469
关注
整型数组——首尾相连
weixin_30748995的博客
03-23 421
上次的数组代码基础上，增加要求，数组首尾相连输出最大子数组，例如 1，1，-5，1，1获得的最大子数组应为：1，1，1，1；不是1，1； 初步想法为新建数组，将原来的数组加到末尾获得新的更长的数组。 package shuzu; import java.util.Scanner; public class shuzu2 { public static void main...
返回一个整数数组中最大子数组的和
diezibei2833的博客
11-04 183
要求： 　　1.输入一个整形数组，数组里有整数有负数 　　2.数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和 　　3.如果数组A[0].........A[j-1]首尾相邻，允许A[i-1],..........A[n-1],A[0].......A[j-1]之和最大 　　4.同时返回最大子数组的位置 　　5.求所有子数组的和的最大值 实验思路： 　　将一维...
返回一个整数数组中最大子数组的和，首尾相接
11-04 106
设计思想 遍历数组的时候将数组中第一个数变成最后一个数，这样就得到了好几个新的数组，然后输出每个数组的最大子数组的和，在比较每个输出结果，找到最大的子数组和。 代码 #include <iostream> #include<ctime> #define Num 10000 using namespace std; int DTGH_Sum(...
返回一个整数数组中最大子数组的和（首尾相连）
weixin_30483013的博客
11-04 104
题目:返回一个整数数组中最大子数组的和。要求：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。如果数组A[0]……A[j-1]首尾相邻，允许A[i-1]，……A[n-1]，A[0]……A[j-1]之和最大。同时返回最大子数组的位置。求所有子数组的和的最大值。 设计思路：随机生成一个数组，然后求其最大子数组，从第一个元素开始排列，然后第...
题目:返回一个整数数组中最大子数组的和。
03-28 108
一 题目要求（合并题目） 1 要求程序必须能处理1000 个元素； 2 每个元素是int32 类型的； 3 输入一个整形数组，数组里有正数也有负数。 4 数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 5如果数组A[0]……A[j-1]首尾相邻，允许A[i-1]， …… A[n-1]， A[0]……A[j-1]之和最大。 6同时返回最大子数组...
最大子数组下标java_返回一个整数数组中最大子数组的和——java程序设计
weixin_36365795的博客
02-25 478
一、题目要求1、输入一个整形数组，数组里有正数也有负数。2、数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。3、求所有子数组的和的最大值。要求时间复杂度为O(n)二、设计思想解决方案一：1、通过用户输入数组容量，随机产生一个整型数组2、将数组元素依次相加进行判断，当遇到小于0的数时停止相加(因为要求最大子数组的和，加上小于0的数会让子数组和变小)3、遍历相加的过程中不断更新子数组的...
返回一个整数数组中最大子数组的和。
weixin_34059951的博客
11-04 87
要求：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。如果数组A[0]……A[j-1]首尾相邻，允许A[i-1]，……A[n-1]，A[0]……A[j-1]之和最大。同时返回最大子数组的位置。求所有子数组的和的最大值。 设计思路：随机生成一个数组，然后求其最大子数组，从第一个元素开始排列，然后第二元素排列，依次排列，因为要求的是首尾相...
返回一个二维整数数组中最大子数组的和
weixin_34349320的博客
10-16 100
、题目及要求： 题目: 返回一个二维整数数组中最大子数组的和。 要求： 输入一个二维整形数组，数组里有正数也有负数。 二维数组首尾相接，象个一条首尾相接带子一样。 数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 求所有子数组的和的最大值。 二、解题思路： 因为是二维数组首尾相连，所以将两个同样...
返回一个整数数组最大子数组的和（数组首尾相连）
weixin_30527143的博客
11-04 132
要求 1，输入一个整型数组，数组里有正数也有负数。 2，数组中连续的一个或多个整数组组成一个子数组，每个子数组都有一个和。 3，如果数组A[0].......A[j-1]首尾相邻，允许A[i-1],.........A[n-1],A[0],.........A[j-1]之和最大。 4，同时返回最大子数组的位置。 5，求所有子数组的和的最大值。 设计思路 1， 很容易理解，当我们加上...
连续子数组的最大和（含返回最大子数组起始位置、全负数组、数组跨界问题）
godric_star的博客
08-24 1010
连续子数组的最大和（含返回最大子数组起始位置、全负数组、数组跨界问题）题目：输入一个整型数组，数组里有正数也有负数。数组中一个或连续的多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。 Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加
给定一个正整数数组，找出数组各元素连接后形成的最小的数
kite1003的专栏
05-06 860
#include <iostream> #include <cstdlib> #include <cmath> #include <cstring> using namespace std; int bitNum(int a) { int i=0; for(; a!=0; i++) a/=10; return i; } int...
求数组的连续子数组之和的最大值（一维二维）
承续缘的信仰
07-22 5189
求数组的连续子数组之和的最大值 输入一个N个元素的整型数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。 例如输入的数组为-9  -3  -2  2  -1  2  5  -7  1  5，和最大的子数组为2  -1  2  5。因此输出为该子数组的和8。 可是如果都是负数的话，要返回0？还是返回最小的负数？，这个数时
leetcode566（重塑矩阵：二维数组向一维转化）
CY2333333的博客
02-17 332
在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。 给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。 重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。 如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。 示例 1: 输入: nums = [[1,2], [3,4]] r = 1, c = 4 输出: [[1,2,3,4]] 解释: 行遍历num
NOIP学习之一维数组:30.约瑟夫问题
wlxiong的博客
02-17 701
递推公式：f(N,M)=(f(N−1,M)+M)%N 实际上是求最后一个猴子编号在当前取的约瑟夫环所在位置，每次编号都随着取出的编号而发生变化，直到最后一个出现位置为0时就是所取的编号值。取模是要当m>n时，也就是取得数据多余剩余猴子时，要相当于折返取编号值，也就是对n取模。
反光柱定位算法-经典三边定位最小二乘法-直接法
苏凯的博客
09-26 198
（二）计算姿态方式是我们已经通过最小二乘得到了小车在地图中的位置或者是雷达在地图中的位置，又因为我们知道雷达与小车的安装坐标，所以可以求解出一其中一个坐标的知量，通过小车在地图中坐标与雷达在地图中坐标可以得到一条向量，通过计算向量在地图中的角度就能得到姿态了。与最小二乘三边测量法相比，新算法在动态调整、优化过程和鲁棒性方面优势明显，尤其适合动态环境下的机器人定位，而最小二乘三边测量法在动态复杂环境中精度相对较低。（一）与（二）的区别主要是在计算姿态上的算法不同。经典三边定位最小二乘法 (法一)
每日算法2（翻转链表）
wdnmdfky的博客
09-25 231
接着进入循环，我们选不探讨循环条件，先研究循环语句，n2的next要存储n1，就是为了使最后的链表的next的空，n1=n2,n2=n3,if(n3)n3=n3->， n1是整个链表，n2=n3是为了指向后面的元素，在将后面的元素插入到n1前面，然后再让n1是指向头节点，最后5就是新的头节点。先来讲下最简单的算法，创建一个新链表，将原链表的元素挨个头插到新链表上，就实现了顺序表的逆转，这里就不示例代码了，在之前的链表有提及。让n1指向空，n2指向头，n3指向head->next。
编程题 7-14 求整数段和【PAT】
最新发布
绯樱殇雪的博客
09-30 943
编程题 7-14 求整数段和
数据结构讲解二叉树 【一】
2401_85388078的博客
09-25 1206
在数据结构中，二叉树作为步入实现复杂结构的门栏，为后续的图，排序衔接紧密，因此我将详细讲解二叉树，初定分为三至五篇文章讲解。文章干货满满，还请您细细品读，如果您觉得作者写得不错，抑或对您有所帮助，不妨给俺点个免费的赞和玩玩呢？关注作者不迷路，后续将有更多原创内容更新哟点点点点点点点点点点点点。
经典算法面试题解析：二元查找树、最小栈、最大子数组和等
我们用一个变量记录当前子数组的最大和，并且维护全局最大值。遍历数组，如果当前元素大于当前子数组和加上当前元素，那么继续累加；否则，更新子数组和为当前元素。这样可以在一次遍历中找到最大子数组和，时间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值