最大子数组的和并确定子数组的位置 数对之差的最大值

最新推荐文章于 2022-05-08 14:23:57 发布
最新推荐文章于 2022-05-08 14:23:57 发布
阅读量264 收藏
点赞数
分类专栏： 数组操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hd12370/article/details/81079157
版权

求最大子数组之和

蛮力法：

算法思路：找出所有子数组，然后求出子数组的和然后，在所有子数组的和中取最大值

时间复杂度：O(n^3)  优化后O(n^2)

代码实现：

 /**
     *
     *  暴力法求最大子数组的和问题
     *  时间复杂度n(n^3)
     * @return
     */
    public static int maxSubArray(int arr[]){
        int n = arr.length;//数组大小
        int ThisSum = 0;//记录主数组的和
        int MaxSum = 0;//记录最大子数组的和
        int i,j,k;
        for (i=0;i<n;i++){//记录子数组的底
            for(j=0;j<n;j++){//记录子数组的高
                ThisSum =0;
                for (k=0;k<j;k++){//计算所遍历出来的子数组的和
                    ThisSum+=arr[k];
                }
                if (ThisSum > MaxSum){//找出最大的子数组
                    MaxSum = ThisSum;
                }
            }

        }
        return MaxSum;
    }

    /**
     * 时间复杂度O(n^2)
     * @param arr
     * @return
     */
    public static int maxSubArray1(int arr[]){
        int size = arr.length;
        int maxSum = Integer.MIN_VALUE;
        for(int i = 0; i<size; i++){
            int sum = 0;
            for (int j=i;j<size;j++){
                sum+=arr[j];
                if (sum>maxSum){
                    maxSum = sum;
                }
            }
        }
        return maxSum;
    }

动态规划法：

算法思路：根据数组中最后一个元素arr[n-1]与最大子数组的关系分为以下三种情况：
   1、最大子数组中包含arr[n-1],以arr[n-1]结尾
   2、arr[n-1]单独构成最大子数组
   3、最大子数组中不包含arr[n-1],求arr[1,...,n-1]的最大子数组转化为求arr[1,...,n-2]的最大子数组
   假设：
   (arr[0],...,arr[i-1])的最大的一段数组和为nAll
   (arr[0],...,arr[i-1])包含arr[i-1]的最大的一段数组和为nEnd
   得出关系：
   nAll = max{arr[i-1],nEnd(i-1),nAll(不包括arr[i-1]的最大子数组)}

时间复杂度： O(n)

空间·复杂度O(n)

代码实现：

/**
   *  时间复杂度O(n)
   *  空间复杂度O(n)
   * 方法描述：
   * 根据数组中最后一个元素arr[n-1]与最大子数组的关系分为以下三种情况：
   * 1、最大子数组中包含arr[n-1],以arr[n-1]结尾
   * 2、arr[n-1]单独构成最大子数组
   * 3、最大子数组中不包含arr[n-1],求arr[1,...,n-1]的最大子数组转化为求arr[1,...,n-2]的最大子数组
   * 
   * 假设：
   * (arr[0],...,arr[i-1])的最大的一段数组和为nAll
   * (arr[0],...,arr[i-1])包含arr[i-1]的最大的一段数组和为nEnd
   * 得出关系：
   * nAll = max{arr[i-1],nEnd(i-1),nAll(不包括arr[i-1]的最大子数组)}
   *
   * @param arr
   * @return
   */

    public static int maxSubArray2(int arr[]){
    	int n = arr.length;
    	int End[] = new int[n];
    	int All[] = new int[n];
    	End[n-1] = arr[n-1];
    	All[n-1] = arr[n-1];
    	End[0]=All[0]=arr[0];
    	for (int i = 0; i < n; i++) {
			End[i] = max(End[i-1], End[i-1]+arr[i]);
			All[i] = max(End[i], All[i-1]);
		}
    	return All[n-1];
    }

    /**
     * 思路同上
     * 上述思路只用到End[i-1]和All[i-1],而不是数组中全部的值，
     * 所以可以定义两个变量来保存End[i-1]和All[i-1]的值，
     * 并可以反复调用
     * 空间复杂度降低
     * @param arr maxSubArray22
     * @return
     */
    public static int maxSubArray22(int[] arr){
    	int n = arr.length;
    	int nAll = arr[0];
    	int nEnd = arr[0];
    	for (int i = 0; i < n; i++) {
			nEnd = max(nEnd+arr[i], arr[i]);//单独的arr[i]与包含arr[i]的最大子数组和比较，较大值赋给nEnd
			nAll = max(nEnd, nAll);//nEnd与不包含arr[i]的数组进行比较得出最终的最大值
		}
    	return nAll;
    }

    /**
     * 获取较大的值
     * @param m
     * @param n
     * @return
     */
    public static int max(int m ,int n){
    	return m>n?m:n;
    }

扩展：确定最大子数组的位置

算法思路：当End[i-1]<0时，End[i]=array[i]；子数组从i开始

代码实现：

         private static int begin = 0;//最大子数组起始位置
	 private static int end = 0;//最大子数组结束位置
	 
	 /**
	  * 确定最大子数组的位置
	  * @param arr
	  * @return
	  */
	 public static int maxSubArray3(int arr[]){
		 int maxSum = Integer.MIN_VALUE;
		 int nSum = 0;
		 int nStart = 0;
		 for (int i = 0; i < arr.length; i++) {
			if (nSum<0) {//End[i-1]<0，子数组从i重新开始
				nSum = arr[i];
				nStart = i;
			}
			else {
				nSum += arr[i];
			}
			if (nSum > maxSum) {
				maxSum = nSum;//记录最大子数组
				begin = nStart;//此时子数组的开始值
				end = i;//此时子数组的结束值
			}
		}
		 return maxSum;
	 }
	 }

完整代码为：

package JBArray;


public class MaxSubArrary {


	 private static int begin = 0;//最大子数组起始位置
	 private static int end = 0;//最大子数组结束位置
	 
	 /**
	  * 确定最大子数组的位置
	  * @param arr
	  * @return
	  */
	 public static int maxSubArray3(int arr[]){
		 int maxSum = Integer.MIN_VALUE;
		 int nSum = 0;
		 int nStart = 0;
		 for (int i = 0; i < arr.length; i++) {
			if (nSum<0) {//End[i-1]<0，子数组从i重新开始
				nSum = arr[i];
				nStart = i;
			}
			else {
				nSum += arr[i];
			}
			if (nSum > maxSum) {
				maxSum = nSum;//记录最大子数组
				begin = nStart;//此时子数组的开始值
				end = i;//此时子数组的结束值
			}
		}
		 return maxSum;
	 }
   
    /**
     *
     *  暴力法求最大子数组的和问题
     *  时间复杂度n(n^3)
     * @return
     */
    public static int maxSubArray(int arr[]){
        int n = arr.length;//数组大小
        int ThisSum = 0;//记录主数组的和
        int MaxSum = 0;//记录最大子数组的和
        int i,j,k;
        for (i=0;i<n;i++){//记录子数组的底
            for(j=0;j<n;j++){//记录子数组的高
                ThisSum =0;
                for (k=0;k<j;k++){//计算所遍历出来的子数组的和
                    ThisSum+=arr[k];
                }
                if (ThisSum > MaxSum){//找出最大的子数组
                    MaxSum = ThisSum;
                }
            }

        }
        return MaxSum;
    }

    /**
     * 时间复杂度O(n^2)
     * @param arr
     * @return
     */
    public static int maxSubArray1(int arr[]){
        int size = arr.length;
        int maxSum = Integer.MIN_VALUE;
        for(int i = 0; i<size; i++){
            int sum = 0;
            for (int j=i;j<size;j++){
                sum+=arr[j];
                if (sum>maxSum){
                    maxSum = sum;
                }
            }
        }
        return maxSum;
    }
    
  /**
   * 时间复杂度O(n)
   * 方法描述：
   * 根据数组中最后一个元素arr[n-1]与最大子数组的关系分为以下三种情况：
   * 1、最大子数组中包含arr[n-1],以arr[n-1]结尾
   * 2、arr[n-1]单独构成最大子数组
   * 3、最大子数组中不包含arr[n-1],求arr[1,...,n-1]的最大子数组转化为求arr[1,...,n-2]的最大子数组
   * 
   * 假设：
   * (arr[0],...,arr[i-1])的最大的一段数组和为nAll
   * (arr[0],...,arr[i-1])包含arr[i-1]的最大的一段数组和为nEnd
   * 得出关系：
   * nAll = max{arr[i-1],nEnd(i-1),nAll(不包括arr[i-1]的最大子数组)}
   * 
   * @param arr
   * @return
   */
    public static int maxSubArray2(int[] arr){
    	int n = arr.length;
    	int nAll = arr[0];
    	int nEnd = arr[0];
    	for (int i = 0; i < n; i++) {
			nEnd = max(nEnd+arr[i], arr[i]);//单独的arr[i]与包含arr[i]的最大子数组和比较，较大值赋给nEnd
			nAll = max(nEnd, nAll);//nEnd与不包含arr[i]的数组进行比较得出最终的最大值
		}
    	return nAll;
    }

    /**
     * 获取较大的值
     * @param m
     * @param n
     * @return
     */
    public static int max(int m ,int n){
    	return m>n?m:n;
    }
    
    
   

    public static  void main(String[] args){
        int[] arr = {1,-2,4,8,-4,7,-1,-5};
        System.out.println(maxSubArray(arr));
        System.out.println(maxSubArray2(arr));
    }

}

求数对之差的最大值（与上述类似）

暴力法：：

动态规划：
     *  时间复杂度O(n)
     *  空间复杂度O(n)
     *  a：数组
     *  diff[i] 以i为减数的所有对数之差的最大值
     *  max[i] 前i+1个数的最大值
     *  diff[i+1]有两种可能性：
     *        diff[i];
     *        max[i]-a[i]
     *  动态规划的计算表达式为：
     *        diff[i+1] = max(diff[i],max[i]-a[i])
     *        max[i+1]= max(max[i],a[i+1])

动态规划的空间优化：
     * 思路同上
     * 上述思路只用到diff[i]和max[i],而不是数组中全部的值，
     * 所以可以定义两个变量来保存diff[i]和max[i]的值，
     * 并可以反复调用
     * 空间复杂度降低

package JBArray;
/**
 * 求数对之差的最大值
 * @author Dan
 *
 */

public class Maxnum {
	
	/**
	 * 蛮力法
	 */
	public static int getMax(int[] a){
		if(a==null){
			return Integer.MIN_VALUE;
		}
		int len = a.length;
		if (len<=1) {
			return Integer.MIN_VALUE;
		}
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < len-1; i++) {
			for (int j = i+1; j < len; j++) {
				if (a[i]-a[j]>max) {
					max = a[i]-a[j];
				}
			}
		}
		return max;
	}

	/**
	 *  动态规划法
	 *  时间复杂度O(n)
	 *  空间复杂度O(n)
	 *  a：数组
	 *  diff[i] 以i为减数的所有对数之差的最大值
	 *  max[i] 前i+1个数的最大值
	 *  diff[i+1]有两种可能性：
	 *        diff[i];
	 *        max[i]-a[i]
	 *  动态规划的计算表达式为：
	 *        diff[i+1] = max(diff[i],max[i]-a[i])
	 *        max[i+1]= max(max[i],a[i+1])
	 * @param a
	 * @return
	 */
	public static int getMax1(int[] a){
		if(a == null)
			return Integer.MIN_VALUE;
		int len = a.length;
		if (len<=1) {
			return Integer.MIN_VALUE;
		}
		int[] diff = new int[len];
		int[] max = new int[len];
		diff[0]=Integer.MIN_VALUE;
		max[0] = a[0];
		for(int i = 1;i < len; i++){
			diff[i]= Max(diff[i-1],max[i-1] - a[i]);
			max[i] = Max(max[i-1],a[i]);
		}
		return diff[len-1];
	}
	
	/**
	 * 思路同上
     * 上述思路只用到diff[i]和max[i],而不是数组中全部的值，
     * 所以可以定义两个变量来保存diff[i]和max[i]的值，
     * 并可以反复调用
     * 空间复杂度降低
	 * @param a
	 * @return
	 */
	public static int getMax2(int[] a){
		if(a == null)
			return Integer.MIN_VALUE;
		int len = a.length;
		if (len<=1) {
			return Integer.MIN_VALUE;
		}
		int diff = 0;
		int  max = a[0];
		for(int i = 1;i < len; i++){
			diff= Max(diff,max - a[i]);
			max = Max(max,a[i]);
		}
		return diff;
	}
	
	
	public static int Max(int a ,int b){
		return a > b ? a : b;
	}
	
	public static void main(String[] args) {
		int[] a = {1,4,17,3,2,9};
		System.out.println(getMax(a));
		System.out.println(getMax1(a));
		System.out.println(getMax2(a));
	}
}

 

AddoilDan
关注
专栏目录
求最大子数组的和，以及求该最大子数组的起始位置和末尾位置
大风的专栏
05-08 2642
问题描述： 一个数组，长度为N，数组元素有负有正，如{-1， 4， 6， -3， 7， -3， -3， 9}；我们可以清楚的知道最大的子数组应该是4到9，也就是下标1到下标7，和为17。 求解思路： 第一种方法：我们可以用定义1、两个数ThisSum和MaxSum来记录当前数组的和，以及数组的最大和。 2、我们可以用两个for循环来来遍历数组，每一次求出子数组的最大和，每个子数组从
连续子数组的最大和（含返回最大子数组起始位置、全负数组、数组跨界问题）
godric_star的博客
08-24 1029
连续子数组的最大和（含返回最大子数组起始位置、全负数组、数组跨界问题）题目：输入一个整型数组，数组里有正数也有负数。数组中一个或连续的多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。 Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加
求数组中最大子数组和及坐标
faral的专栏
05-30 429
<br />给定数组（内含正负数）， 求其中和最大的子数组。<br />如  { 8,-9,7,1,2,2,-9}   应返回 12<br /> <br />代码如下：<br />int maxSummaryClear_DP(int arr[], int length) { assert( arr && length); int sum = arr[0]; int maxSum = arr[0]; int b=0, e=0; // begin and end int bb=b, ee=
最大子数组问题
xingsh123的博客
11-05 1696
在leetcode上看到的求最大子数组问题，在算法导论上分治策略章节中也有相同的问题，在这里介绍两种算法。 第一种，用分治法的思想去求解，先将数组对半分，那么，最大子数组的位置有三种情况，1.子数组全部在中点的右边，2.子数组全部在中点的左边。3.子数组部分在中点的左边，另一部分在中点的右边。 只要分别求出这三种情况的最大值比较，取最大的即为最大子数组。 第三种情况最简单只要从中点出发，向左递
算法——求数组中最大子数组和
关注 Linux c/c++ 数据存储 网络 算法......
11-20 1887
题目 有一输入数组，数组里面的数字都是整数，可能为正，可能为负，也可能是0，要求该输入数组中最大子数组的和。 题目分析 面对这样的一个问题，首先需要仔细分析问题的条件与问题所求。这个问题提供了一个输入数组，里面会有若干个元素，每个元素可以为正数，可以为负数，也可以为0。而题目要求输出该数组中最大子数组的和，注意是要求连续相邻的若干元素组成的子数组，并且保证该子数组的和最大。
最大子数组和js解法
G1useppE的博客
05-08 558
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组 是数组中的一个连续部分。 示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组[4,-1,2,1] 的和最大，为6 。 示例 2： 输入：nums = [1] 输出：1 示例 3： 输入：nums = [5,4,-1,7,8] 输出：23 题解1：(贪心) 解题思路： 贪心就是从局部最优解中，推出全局最优解。 局部最..
数组：求最大子数组之和
weixin_38108266的博客
07-29 2947
题目描述： 一个有N个元素的数组，这N个元素可以是正数也可以是负数，数组中连续的一个或多个元素可以组成一个连续的子数组，一个数组可能有多个这种连续的子数组，求子数组和的最大值 实现思路： 1.蛮力法： 找到所有的子数组，然后求出子数组的和，取所有子数组和中的最大值。时间复杂度为O(n^3)。分析发现，许多子数组都重复计算了。 代码： /**方法一： * 进行了3次循环，第三次的循...
数组中最大和的子数组
12-23
这样，每次迭代后，current_sum都包含了一个以当前元素结尾的最大子数组的和，而max_sum则始终记录了遍历过程中的最大子数组和。 以下是用C++实现Kadane算法的代码示例（对应MaxSum.cpp文件）： ```cpp #include ...
最大子数组的线性时间求解问题
筱羊冰冰
01-04 299
之前有一个博客说的是使用分治的方式处理问题，但是我们可以看到实际上是将问题复杂化了。 链接：最大子数组问题 动态规划 dp说白了就是一个个的不断尝试，来找到问题的最优解，那么动态规划就应该有一个状态转移方程，我们来看看这道题用动态规划能不能解决？ 算法导论还是很良心的，至少给了我们以下的思路： 使用如下思想为最大子数组问题设计一个非递归的、线性时间的算法。从数组的左边界开始，从左至右处理，记录到目前为止已经处理过的最大子数组。若已知A[1…j]的最大子数组，基于如下性质将解扩展为A[1…j+1]的最大子数
C++解OJ题--最大子数组和（第一次尝试动态规划，很烧脑）
老胡的博客
12-06 810
烧脑的一天
一个数组子数组的最大和
05-08
求一个数组子数组的最大和，这是一道非常经典的公司面试或笔试题目，我分别使用了暴力枚举、分枝界定、动态规划三种算法实现。
分治算法-最大子数组问题
weixin_30663391的博客
01-02 120
1.蛮力法求解 总体思路： 　　蛮力法是最简单的实现方法，只要列出数组所有可能的组合，然后找出其中和最大的组合即可； 　　蛮力法分三层循环实现： 　　　　1）第一层循环用于固定子数组的起始位置； 　　　　2）第二层循环用于确定子数组的结束位置； 　　　　3）第三层循环用于子数组和的计算，从子数组的头开始遍历到其尾，累加起来就是该子数组的和。 实现： ...
数组中的子数组、子序列，以及字符串的子串、子序列解释
热门推荐
chl183的博客
08-09 2万+
数组中的子数组、子序列，以及字符串的子串、子序列解释数组子数组子序列字符串子串子序列 数组 子数组 子数组的定义：一个或连续多个数组中的元素组成一个子数组(子数组最少包含一个元素) 子序列 子序列的定义：子序列就是在原来序列中找出一部分组成的序列（子序列不一定连续） 在数学中，某个序列的子序列是从最初序列通过去除某些元素但不破坏余下元素的相对位置（在前或在后）而形成的新序列。 例如：数组：[1,2,3,4,5,6] ；其中一个子序列可为[2，3，6] 字符串 子串 子串定义：字符串中任意个连续的字符组成
求数组内子数组最大的和（Maximum Subarray ）
w514175575的专栏
03-30 1200
来源：https://leetcode.com/problems/maximum-subarray/#/descriptionFind the contiguous subarray within an array (containing at least one number) which has the largest sum.For example, given the array [-2,
java如何求最大子数组的和 蛮力算法 动态规划算法
迎着风飞翔的IT
05-03 1331
求解最大子数组的和五种解法,其中包含蛮力算法，以及其优化；动态规划算法，以及其优化算法
寻找一个数组的最大子数组（子数组之和最大）
weixin_41768753的博客
01-20 1691
寻找一个数组的最大子数组（子数组之和最大） Max_Crossing_Arr(int a[], int low, int high, int mid) 该函数寻找一个跨越中点的最大子数组。 Max_Arr(int a[],int low,int high) 该函数寻找一个数组的最大子数组：先找左半边的最大子数组，再找右半边最大子数组，再找跨越中点的最大子数组，（其中递归调用自身于寻找左右两边的最大...
最大子数组问题的两种解法
T-tian的博客
07-20 7956
所谓最大子数组就是连续的若干数组元素，如果其和是最大的，那么这个子数组就称为该数组的最大子数组。最大子数组是很多问题的抽象，比如购买股票。如果把相邻两天的股价之差作为数组元素，那么求在连续的某个时间段内买入股票的最佳时间和卖出股票的最佳时间就可以抽象为计算最大子数组的问题。下面分别介绍两种算法求解最大子数组问题，算法思想均来自算法导论这本程序员的圣经。 分治法 分治法实现思路比较简单。如果把一...
Java求数组所有子数组的两种方法
SinvanChong的博客
10-26 1万+
一个包含n个元素的集合,求它的所有子集。比如集合A= {1,2,3}, 它的所有子集是: { {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}, @}(@表示空集)。这种问题一般有两种思路，先说说第一种，递归。递归肯定要基于一个归纳法的思想，这个思想用到了二叉树的遍历，如下图所示： 可以这样理解这张图，从集合A的每个元素自身分析，它只有两种状态，或是某个
78. Subsets 求数组的子数组
李白-2017的博客
04-07 557
难度：【medium】 for ex. 输出的子数组的顺序没有限制。 Input: nums = [1,2,3] Output: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ] 主要由两种方法： 方法1：深度优先搜索 vector<vector<int>> subs...
序列 [3,4,0,4,3,2,0,5,4,5,4,8,2,3,5,4,8,9]用分治法求出最大非空子数组（子数组 和最大，且为连续序列），确定首末位置，输出为首末位置、最大子数组序列，及子序列的和。加注释，子数组的长度约定为6个
最新发布
06-12
以下是使用分治法求解该问题的Python代码，其中设定子数组长度为6个： ```Python def max_subarray(arr, start, ...其中，最大子数组的起始位置为10，终止位置为15，最大子数组为[4, 8, 2, 3, 5, 4]，子数组和为26。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值