最大子数组问题分治法（递归）Java实现

最新推荐文章于 2023-01-30 19:46:48 发布
最新推荐文章于 2023-01-30 19:46:48 发布
阅读量1.1k 收藏
点赞数
分类专栏： 算法 文章标签： 递归 最大子数组
FindMaximumSubArray.java
public class   FindMaximumSubArray{
          private int   low   ;
          private int   high   ;
          private int   sum   ;

          public void   FindMaximumSubArray(   int a[], int low, int high) {
                 int mid;//中间位置
                 //左数组
                 int leftLow;
                 int leftHigh;
                 int leftSum;
                 //右数组
                 int rightLow;
                 int rightHigh;
                 int rightSum;
                 //中间数组
                 int crossLow;
                 int crossHigh;
                 int crossSum;
                 if (high == low) {//只有一个元素
                        this .high   = low;
                        this .low   = low;
                        this .sum   =a[low];
              } else {//至少两个元素
                     mid= (   int )((low + high) / 2);//向下取整
                     FindMaximumSubArraycalLeft = new FindMaximumSubArray();//搜索左边
                     calLeft.FindMaximumSubArray(a,low, mid);
                     leftLow= calLeft.getLow();
                     System.   out .println("FindMaximumSubArray.leftLow="   +leftLow);
                     leftHigh= calLeft.getHigh();
                     System.   out .println("FindMaximumSubArray.leftHgih="   +leftHigh);
                     leftSum= calLeft.getSum();
                     System.   out .println("FindMaximumSubArray.leftLSum="   +leftSum);
                     FindMaximumSubArraycalRight = new FindMaximumSubArray();//搜索右边
                     calRight.FindMaximumSubArray(a,mid + 1, high);
                     rightLow= calRight.getLow();
                     System.   out .println("FindMaximumSubArray.rightLow="   +rightLow);
                     rightHigh= calRight.getHigh();
                     System.   out .println("FindMaximumSubArray.rightHgih="   +rightHigh);
                     rightSum= calRight.getSum();
                     System.   out .println("FindMaximumSubArray.rightSum="   +rightSum);
                     FindMaxCrossingSubArraycalCross = new FindMaxCrossingSubArray();//搜索从中间开始
                     calCross.FindMaxCrossingSubArray(a,low, mid, high);
                     crossLow= calCross.getMaxLeft();
                     System.   out .println("FindMaxCrossingSubArray.crossLow="   +crossLow);
                     crossHigh= calCross.getMaxRight();
                     System.   out .println("FindMaxCrossingSubArray.crossHigh="   +crossHigh);
                     crossSum= calCross.getSum();
                     System.   out .println("FindMaxCrossingSubArray.crossSum="   +crossSum);
                        if ((leftSum >= rightSum) && (leftSum>crossSum)) { //在有零元素的情况下，包含零元素的才是最大子数组，Cross中包含
                              this .low   =leftLow;
                              this .high   =leftHigh;
                              this .sum   =leftSum;
                     } else if   ((rightSum>= leftSum) && (rightSum >crossSum)){//在有零元素的情况下，包含零元素的才是最大子数组，Cross中包含
                              this .low   =rightLow;
                              this .high   =rightHigh;
                              this .sum   =rightSum;
                     } else {
                              this .low   =crossLow;
                              this .high   =crossHigh;
                              this .sum   =crossSum;
                     }
              }
       }

         
          public int   getLow(){
                 return low   ;
       }

         
          public int   getHigh(){
                 return high   ;
       }

         
          public int   getSum(){
                 return sum   ;
       }

}

FindMaxCrossingSubArray.java
public class   FindMaxCrossingSubArray {
          private int   sum   =0;
          private int   sumLeft   =0;
          private int   sumRight   =0;
          private int   maxLeft   ;
          private int   maxRight   ;
       
          public void   FindMaxCrossingSubArray(   int a[], int low, int mid,   int high){
                 if (low == high){//子数组元素个数为一
                        //sumLeft=a[low];
                        //sumRight=a[low];
                        sum=a[low];
                        maxLeft=low;
                        maxRight=low;
              }   else {//子数组元素个数卜为一
                        sumLeft=a[mid];
                        sumRight=a[mid+1];
                        maxLeft=mid;
                        maxRight=mid+1;
                        for (int   i=mid;i>=0;i--){
                              sum+=a[i];
                              if (sum   >sumLeft   ){
                                     sumLeft=   sum;
                                     maxLeft=i;
                           }
                     }
                        sum=0;
                        for (int   i=mid+1;i<=high;i++){
                              sum+=a[i];
                              if (sum   >sumRight   ){
                                     sumRight=   sum;
                                     maxRight=i;
                           }
                     }
                        sum=   sumLeft+   sumRight;
              }
              
       }
         
          public int   getSum(){
                 return sum   ;
       }
         
          public int   getSumLeft(){
                 return sumLeft   ;
       }
         
          public int   getSumRight(){
                 return sumRight   ;
       }
         
          public int   getMaxLeft(){
                 return maxLeft   ;
       }
         
          public int   getMaxRight(){
                 return maxRight   ;
       }
}

testFindMaxCrossingSubArray.java

import java.util.Random;

public class   testFindMaxCrossingSubArray {
          int a   [];
         
          public int   [] getA(){
                 return a   ;
       }

          int low   ;
          int high   ;
          int mid   ;
          int sum   ;
          int length   =2;
       Random random=   new Random();
         
          private void   initTest1(){
                 a=   new int   [length   ];
                 for (int   i=0;i<</SPAN> length;i++){
                        a[i]=   random.nextInt(40)-20;
              }
                 low=0;
                 high=   length-1;
                 sum=0;
                 mid=(   int )((low   +high   )/2);
       }
         
          private void   cal(){
              FindMaxCrossingSubArraycal=   new FindMaxCrossingSubArray();
              cal.FindMaxCrossingSubArray(   a, low, mid, high);
                 sum=cal.getSum();
                 low=cal.getMaxLeft();
                 high=cal.getMaxRight();
       }
         
          private void   calPrint(){
              System.   out .print("a=["   );
                 for (int   i=0;i<</SPAN> length;i++){
                     System.   out .print(a   [i]+""   );
              }
              System.   out .println("]"   );
              System.   out .print("a["   +(low   +1)+"..."   +high   +"]=["   );
                 for (int   i=low   ;i<=high   ;i++){
                     System.   out .print(a   [i]+""   );
              }
              System.   out .println("]"   );
              System.   out .println("sum="   +sum   );
       }
       
          public void   test(){
              initTest1();
              cal();
              calPrint();
       }
}

testFindMaximumSubArray.java

import java.util.Random;

public class   testFindMaximumSubArray {
          int length   ;//getter &setter
          int a   []= new int[ length]; //setter
          int low   ;
          int high   ;
          int mid   ;
          int sum   ;
       
          //a=new int [length];
       
       Random random=   new Random();
         
          private void   initTest1(){
              
                
                 low=0;
                 high=   length-1;
                 sum=0;
                 //mid=(int )((low+high)/2);
       }
         
          private void   cal(){
              FindMaximumSubArraycal=   new FindMaximumSubArray();
              cal.FindMaximumSubArray(   a, low, high);
                 sum=cal.getSum();
                 low=cal.getLow();
                 high=cal.getHigh();
       }
         
          private void   calPrint(){
                 //输出数组
              System.   out .print("a=["   );
                 for (int   i=0;i<</SPAN> length;i++){
                     System.   out .print(a   [i]+""   );
              }
              System.   out .println("]"   );
                 //输出最大子数组
              System.   out .print("a["   +(low   +1)+"..."   +(high   +1)+"]=["   );
                 for (int   i=low   ;i<=high   ;i++){
                     System.   out .print(a   [i]+""   );
              }
              System.   out .println("]"   );
              System.   out .println("sum="   +sum   );
       }
       
          public void   test(){
              initTest1();
              cal();
              calPrint();
       }
       
         
          public int   getLength(){
                 return length   ;
       }
         
          public void   setLength( int length){
                 this .length   =length;
       }
         
          public void   setA( int[]a) {
                 this .a   =a;
       }
}

main.java

import java.util.Random;


public class   main{

          static Random random   = new Random();

          public static   void main(String[]args) {
                 // TODO 自动生成的方法存根
                 //testFindMaxCrossingSubArray testC=newtestFindMaxCrossingSubArray ();
                 //testC.test();
                 int length=20;//测试的数组长度
              testFindMaximumSubArraytestM=   new testFindMaximumSubArray();
              testM.setLength(length);
                 int a[]=new   int[length];
                 for (int   i=0;i
              a[i]=   random .nextInt(40)-20;
              }
              testM.setA(a);
              testM.test();
       }

}
pjblogs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用分治法实现最大子数组问题（Java）
Jack小站
08-16 1118
终于把这个搞出来了，中间出现了好多小问题，伪代码和算法思想可以参考算法导论。package com.alibaba; public class MaxSubarray { public static void main(String[] args) { int[] array = { 1, -2, -3, 4, 5, 6, -3, 4, -11 }; int[] result =
最大子数组问题的Java实现
BohouZhang的博客
04-16 721
《算法导论》的第四章：分治策略中提到了最大子数组问题。采用分治策略可以得到一个渐进复杂性优于暴力解法的算法。文中使用Java实现该算法。 问题：你被许可可以在某一时刻买进某公司的股票，并在之后某个日期将其卖出，买进卖出都是在当天交易结束后进行。为了补偿这一限制，你可以了解股票将来的价格。你的目标是最大化收益。股票价格变化如下表： 天 0 1 2 3 4 5 ...
算法学习2：分治法解决最大子数组问题（Java实现）
qq_45703204的博客
12-03 431
package experiment.MaxSubArray; /* 使用分治法解决最大子数组问题 输入：数组X、数组下标low,high 输出：最大子数组之和Smax if low = high then return X[low] end else mid = (low+high)/2; S1 = MaxSubArr(X,low,mid); S2 = MaxSubArr(X,mid+1,high); S3 = CrossingSubArr(X,low,mid,hi
算法-java代码分治法求解最大子数组问题
weixin_43694829的博客
04-28 1231
任务解释： 一个整数数组中的元素有正有负，在该数组中找出一个连续子数组，要求该连续子数组中各元素的和最大，这个连续子数组便被称作最大连续子数组。 要求： 随机产生1000以上的数据（有正有负），写入文件input.txt，求出其最大连续子数组 示例： 比如数组{2,4,-7,5,2,-1,2,-4,3}的最大连续子数组为{5,2,-1,2}，最大连续子数组的和为5+2-1+2=8。将结果输出到文件output.txt，并将最大子数组起始元素的索引和结束元素的索引输出到out.txt
算法基础-分治法求解最大子数组(Java)
xclcccvfc的博客
07-26 334
算法，分治法，最大子数组，java
Java——最大子数组和
m0_60867520的博客
01-30 852
使用动态规划解决最大子数组和——给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组 是数组中的一个连续部分。
53. 最大子数组和
lhn的博客
12-16 433
53. 最大子数组和 给你一个整数数组 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 <= nums.length <= 105 -104
最大子段和问题 蛮力法 分治法 动态规划法
11-17
然而，分治法并不适用于这个问题，因为子问题之间存在重叠，导致无法直接递归求解。因此，分治法在此问题上的应用并不常见。 3. **动态规划法**： 动态规划是解决这类问题的有效手段，它通过构建一个表来存储中间...
Algo_DS:向与阵列相关的问题中添加解决方案
05-03
10. **问题解决策略**：在Algo_DS项目中，可能会涵盖如何使用数组和算法来解决各种问题的实例，例如最小路径和、最大子序列和、最短路径问题等。这些策略包括使用贪心法、回溯法、分治法等。 通过这个项目，开发者...
LeetCode-Top-100：我研究LeetCode的前100个面试问题时收集的解决方案集合
03-04
- 滑动窗口：最大子数组和、字符串匹配等。 - 贪心算法：背包问题、活动选择问题等。 3. **复杂度分析** - 时间复杂度：每个解法的时间复杂度分析，优化算法性能。 - 空间复杂度：关注解法的空间占用，尽量降低...
算法学习（一）——分治策略之最大子数组问题（Java实现）
luqiren的博客
08-07 1354
在分治策略中，递归地求解一个问题，在每层递归中应用如下三个步骤： 分解步骤将问题划分为一些子问题，子问题的形式与原问题一样，只是规模更小。 解决步骤递归地求解出子问题，如果子问题的规模足够小，则停止递归，直接求解。 合并步骤将子问题的解组合成原问题的解。 当子问题足够大，需要递归求解时，称之为递归情况，当子问题变得足够小，不再需要递归时，递归已经“触底”，进入了基本情况。有时，除了与原问题形式完全一
最大子数组问题（三种方式，java实现）
Think
04-09 1365
最大子数组问题（三种方式，java实现）
Java 求最大子数组
深刻的博客
02-02 1272
Background 在某天购入股票后抛出，求如何取得最大利润。已知股票趋势如图所示。 Thought 我们都知道——利润 = 售价 - 成本，即两者之差越大则利润越大。要求利润的最大值，不妨先计算出当天与前一天股价的差，得到的股价浮动数组，然后找其最大子数组，即为原问题的解。 对于最大子数组，最简单粗暴的方法就是两层 for，遍历所有子数组后，自然能求出最大子数组。 更好的解决办法是用分...
最大子数组的方法java版本 简单易懂。
qq_57852637的博客
03-11 512
前提：新手最能理解新手~~。 一、暴力遍历。 核心思想：暴力遍历每一个子数组从而找到最大的直 时间复杂度经过优化的为O（n²）。设置两个和 sum和thissum，sum里面永远存放最大值，thissum存放阶段性和。只有当thissum大于sum才将其交换。 public class 练习题5 { //最大子数组遍历版 public static void main(String[] args) { // TODO Auto-generated method stub S
512、java-求最大子数组
风子的博客
03-22 1185
求最大子数组 方式一：穷举出所有子数组 public static void main(String[] args) { int[] arr = new int[]{1,2,-4,5,-3,5,3,-9,3}; querySubArr(arr); querySubArrExhaustively(arr); } /** 　　* @description: 穷举的方式，罗列出所有子数组 　　* @param ${tags}
分治算法-java求最大子数组问题
Dalton2017的博客
07-11 939
今天看算法导论的时候,就想着动纸和笔来思考分治算法求最大子数组的方案首先我们分析问题,我们把数组看成 a [ low, high] ,将要用分治法求出其最大的子数组,用分治法相当于我们要把数组分成两个规模尽量相等的子数组 (因为有时候数组长度是奇数,无法区分)，找到数组的中间位置mid，这样最大值出现的可能情况分为以下三种,a [low ,mid ] , a[mid + 1 , high], a[...
分治策略(最大子数组问题)-java
4396的博客
11-21 449
问题描述： 有这么一个整数数组，A={13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7};找出数组A的和最大的非空连续子数组。 限制条件：求出的子数组必须跨越中点。 分析： 假设求出的子数组是A[low…high]任何跨越终点的子数组都由两个子数组A[i…mid]和A[mid+1…j]组成，其中low&amp;lt;=i&amp;lt;=mid且mid&amp;lt;=...
最大子数组和（java实现）
超悦人生
09-23 1271
给定一个数组，求该数组最大子数组和，动态规划的方法。
最大子数组问题分治法python
最新发布
04-01
以下是使用分治法解决最大子数组问题的Python代码： ```python def max_subarray(arr): if len(arr) == 1: return arr[0] else: mid = len(arr) // 2 left_arr = arr[:mid] right_arr = arr[mid:] left_max = max_subarray(left_arr) right_max = max_subarray(right_arr) cross_max = max_cross_subarray(arr, mid) return max(left_max, right_max, cross_max) def max_cross_subarray(arr, mid): left_sum = -float('inf') right_sum = -float('inf') sum = 0 for i in range(mid - 1, -1, -1): sum += arr[i] if sum > left_sum: left_sum = sum sum = 0 for i in range(mid, len(arr)): sum += arr[i] if sum > right_sum: right_sum = sum return left_sum + right_sum ``` 该代码中，`max_subarray`函数使用递归的方式将数组分成左半部分、右半部分和跨越中心的部分，然后返回这三个部分中最大的子数组和。`max_cross_subarray`函数计算跨越中心部分的最大子数组和，具体实现方式是从中心点向左、向右分别计算最大子数组和。 该代码的时间复杂度是$O(n\log n)$，其中$n$是数组的长度，因为每次递归都会将数组长度减半，所以递归深度是$O(\log n)$，而`max_cross_subarray`函数的时间复杂度是$O(n)$。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值