求子数组的最大和

题目：求子数组的最大和
         输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为 O(n) 。
        例如输入的数组为 1, -2, 3, 10, -4, 7, 2, -5 ，和最大的子数组为 3, 10, -4, 7, 2 ，因此输出为该子数组的和18 。

1、有一个数组a[n],里面的数只有两种：-1或1。i，j是两个整数，假设0<=i<=j<=n-1，找出a[i]到a[j]中连续数之和最大的部分（如果最大部分存在相等的则优先找最短的）。

2、有一个数组a[n],里面含有正数负数，假设0<=i<=j<=n-1，找出a[i]到a[j]中连续数之和最大的部分（如果最大部分存在相等的则优先找最短的）。

算法原理：

贪婪算法，由于要求算法复杂度为 O(n)，所以只能遍历一次数组，即一次for循环。以上面的数组为例，首先初始化子数组和的最大值max为0，数组元素和sum为0，从第一个元素开始计算，若相加后的sum为正，且sum>max，则max=sum，若sum<0，则sum=0，依次计算下去。

有一种特殊情况，即数组的全部元素均为负数，此时最后的max=0，不是子数组和的最大值（应该为数组元素中值最大的一个负数）。巧妙方法在于max初始值的设置，可以通过赋初值max==-(1<<31)，这是32位操作系统的最小整数值；就可以很轻松的搞定特殊情况了。因为此时即使数组元素都为负，那么其中的元素也一定大于等于max，所以就避免了上面所述的特殊情况。代码如下：

bool maxSubarray(int data[], int size,int &max, int* be, int*en) 
{
    if (size<=0) 
    {
        printf("error array size\n");
        return false;
    }

    int  begin = 0, end = 0,sum = 0;

    max=-(1<<31);
    for(int i=0;i<size;i++)
    {

       sum +=data[i];
       if(sum>max)
       {

                begin = j;
                end = i;
             max=sum;
       }
       else if(sum<0)
      {
           sum=0;

           j = i + 1;
      }
   }

   *be = j;

   *en= i;
   return true;
}

补充知识点：

1 << 31和-（1<<31）都是32为x86系统中的最小值！！！

32位x86系统中，分别执行如下两条语句
(1) int num = 1 << 31;
(2) int num = -( 1<<31 );
结果一样，均为-2147483648 。

也就是说1<<31==-(1<<31)=最小负数

原因在于：

1. 0x80 00 00 00 == 1 << 31,即-2147483648（最小负数）
2, 原码与补码之和为0，也就是a + ~a + 1 = 0. 所以 -a = 1+ ~a, -（0x80000000) = 1 + 0x7fffffff（最大正数） = 0x80000000

3.1 << 31 = > -2147483648,最小负数. -(-2147483648) = 2147483647 + 1 => 最大正数 + 1 = 最小负数 = -2147483648
其实问题等价于 为什么最大的正数 + 1 变成最小的负数。

正常使用时可以做如下设置：

// Integer limit values.
const (
    MaxInt8   = 1<<7 - 1
    MinInt8   = -1 << 7
    MaxInt16  = 1<<15 - 1
    MinInt16  = -1 << 15
    MaxInt32  = 1<<31 - 1
    MinInt32  = -1 << 31
    MaxInt64  = 1<<63 - 1
    MinInt64  = -1 << 63
    MaxUint8  = 1<<8 - 1
    MaxUint16 = 1<<16 - 1
    MaxUint32 = 1<<32 - 1
    MaxUint64 = 1<<64 - 1
)