结对开发2

一 题目：返回二维数组最大子数组和的最大值

二：思路：看到这个题目时，可能是编程思维不足，没有任何头绪，后来课上有同学讲了先把行相加合成一位数组再进行处理，所以受到启发那也可以先把各列压缩，换成一维数组再进行处理，但由于能力以及精力的不足，未能按时完成任务，

三：体会：上次结对开发写到由于队友具有一定的编程能力，基本没遇到什么困难，这次则截然不同，很长时间也没能写出正确的代码，没办法了就在网上查资料，找到类似的题目，认真阅读了别人写好的代码，通过这次的作业，切实体会到结对开发的不易，尤其遇到困难，导致任务长时间停滞不前时，自然会有烦躁的心情，但是能力是一天一天积累的，所以遇到困难时保持心态平和最重要，以下为参考的别人的代码（该代码来自cqs_2012的博客）

// 求出二维数组的最大子二维数组
    int Array::Max_Sum_Sub_Double_Array(int **data,const unsigned int row,const unsigned int column)
    {
    // 异常输入
        if(data == NULL || row == 0 || column == 0)
        {
            cout<<"异常输入 Max_Max_Sub_Double_Array"<<endl;
            return -1;
        }

    // 正常输入
        else
        {
        // 核心算法数据初始化
        // 按照一位数组来处理列,把每一列作为一个数
            int * OneArray = new int[column];
            for( unsigned int i=1;i <= column;i++ )
            {
                OneArray[i-1] = Sum_Sub_Column_Double_Array(data,row,column,i,1,row);
            }
            unsigned int L,R;
            Border_Max_Sum_Sub_Array(OneArray,column,L,R);
            delete [] OneArray;

        // 按照一位数组来处理行，把每一行作为一个数
            OneArray = new int[row];
            for(unsigned int i=1;i <= row;i++)
            {
                OneArray[i-1] = Sum_Sub_Row_Double_Array(data,row,column,i,L,R);
            }
            unsigned int U,D;
            Border_Max_Sum_Sub_Array(OneArray,row,U,D);
            cout<<U<<" "<<D<<" "<<L<<" "<<R<<endl;
            return Max_Sum_Sub_Array(OneArray,row);     
        }
    }
    

// 求出二维数组中的某一列的子数组的和
    int Array::Sum_Sub_Column_Double_Array(int ** data,const unsigned int row,const unsigned int column,unsigned int mycolumn,unsigned int s,unsigned int e)
    {
    // 异常输入
        if(data == NULL || row == 0 || column == 0 || mycolumn > column || s>e || e>row)
        {
            cout<<"异常输入 Sum_Sub_Column_Double_Array"<<endl;
            return -1;
        }

    // 正常输入
        else
        {
            int sum = 0;
            for(unsigned int i = s;i <= e;i++)
            {
                sum += data[i-1][mycolumn-1];
            }
            return sum;
        }
    }


// 求出二维数组中的某一行的子数组的和
    int Array::Sum_Sub_Row_Double_Array(int **data,const unsigned int row,const unsigned int column,unsigned int myrow,unsigned int s,unsigned int e)
    {
    // 异常输入
        if(data == NULL || row == 0 || column == 0 || myrow > row || s>e || e> column)
        {
            cout<<"异常输入 Sum_Sub_Row_Double_Array"<<endl;
        }

    // 正常输入
        else{
            int sum = 0;
            for(unsigned int i=s;i <= e;i++)
            {
                sum += data[myrow-1][i-1];
            }
            return sum;
        }
    }



// 求数组的子数组之和最大的边界
    void Array::Border_Max_Sum_Sub_Array(int *data,unsigned int const length,unsigned int & L,unsigned int & R)
    {
    // 异常输入
        if(data == NULL || length == 0 )
        {
            cout<<"异常输入 Border_Max_Sum_Sub_Array"<<endl;
            return void(0);
        }

    // 正常输入
        else
        {
            bool all_fushu = true ;
            unsigned int max = 0;

        // 检查是否所有的数是否都是负数,并记录最大值的下表
            for( unsigned int i = 0;i < length;i++ )
            {
                if( data[i] >= 0 )
                {
                    all_fushu = false ;
                    break ;
                }
                else if( data[i] > data[max] )
                {
                    max = i ;
                }
            }

        // 如果都是负数
            if(all_fushu == true)
            {
                R = L = max+1;
                return void(0);
            }

            // 如果不都是负数
            else
            {
            // 核心算法 初始化
                int left_sum = data[0],right_sum = data[length-1] ;
                int left = 0,right =length-1;
                L = left; R = right ;

            // 选择前进方向
                while(left < right-1)
                {
                    if(left_sum < right_sum)
                    {
                        if(left_sum < 0)
                        {
                            left_sum = 0 ;
                            L = left+1 ;
                        }
                        left++;
                        left_sum += data[left];
                    }
                    else
                    {
                        if(right_sum < 0)
                        {
                            right_sum = 0;
                            R = right -1;
                        }
                        right--;
                        right_sum += data[right];
                    }
                }

            // 寻求结果

            // 如果舍弃左半个数组，保留右半个数组
                if(left_sum <= 0)
                {
                    L = right + 1;
                    R++ ;
                }

            // 如果舍弃右半个数组，保留左半个数组
                else if(right_sum <= 0){
                    L++;
                    R = left+1;
                }

            // 两边都不舍弃
                else{
                    L++;R++;
                }

                return void(0);
            }    
        }
    }