go语言实现寻找最大子数组

题目：给定一个数字序列，寻找其中各元素相加和最大的子数组

 /*
 寻找最大子数组go语言实现
 */

 package main

 import fmt "fmt"

 func main() {
     /*
     需要查找的数组
     */
     A:=[]int{-,,-,-,,,}
     low:=
     high:=len(A)-
     sum:=
     low,high,sum=find_max_array(A,,len(A)-)
     /*
     返回数组边界
     */
     fmt.Println(low," ",high," ",sum)
 }
 /*
 返回越过中间点的最大数组
 */
 func Find_max_acrossing(Array []int,low int,mid int,high int)(int,int,int) {
     /*
     现设定左最小值，寻找左边最小数组边界
     */
     left_sum:=-
     sum:=
     max_left:=mid
     for i := mid; i>=low; i-- {
         sum+=Array[i]
         if sum>left_sum {
             left_sum=sum
             max_left=i
         }
     }

     /*
     现设定右最小值，寻找右边最小数组边界
     */
     right_sum:=-
     sum=
     max_right:=mid+
     for i := mid+; i <=high; i++ {
         sum+=Array[i]
         if sum>right_sum {
             right_sum=sum
             max_right=i
         }
     }
     return max_left,max_right,left_sum+right_sum
 }

 func find_max_array(Array []int,low int,high int)(int,int,int){
     max_left:=low
     max_right:=high
     sum:=
     if low==high {
         max_left=low
         max_right=high
         sum=Array[high]
     }else{
         mid:=
         if (high-low+)%== {
             mid=(high+low-)/
         }else{
             mid=(high+low)/
         }

         max_left_low:=low
         max_left_high:=mid
         left_sum:=
         max_left_low,max_left_high,left_sum=find_max_array(Array,low,mid)

         max_right_low:=mid+
         max_right_high:=high
         right_sum:=
         max_right_low,max_right_high,right_sum=find_max_array(Array,mid+,high)

         max_across_low:=low
         max_across_high:=high
         across_sum:=
         max_across_low,max_across_high,across_sum=Find_max_acrossing(Array,low,mid,high)

         if left_sum>right_sum && left_sum>across_sum{
             max_left=max_left_low
             max_right=max_left_high
             sum=left_sum
         }else if right_sum>left_sum && right_sum>across_sum {
             max_left=max_right_low
             max_right=max_right_high
             sum=right_sum
         }else if across_sum>left_sum && across_sum>right_sum {
             max_left=max_across_low
             max_right=max_across_high
             sum=across_sum
         }
     }
     return max_left,max_right,sum
 }