时间空间复杂度分析

空间复杂度作为算法所需存储空间的量度。S(n)=O(f(n))。
程序运行所需的存储空间包括两部分：
1.固定空间需求：这部分空间大小与所处理的规模无关，
主要包括算法本身的程序带代码、常量、变量所占的空间。
2.可变空间需求：与处理的规模有关，主要包括输入的元素所占的存储空间和运行程序过程中需要的额外空间，
例如：临时工作单元和运行递归算法是的栈空间。

算法设计举例：
给定一个整数序列A1，A2，A3，…An，求A1-An的一个子序列Ai~Aj,使得Ai到Aj实我和最大。

穷举法：
public class 空间算法 {    
public static int  maxSub_1(int [] sequence){    
    int max = 0;     
    int n=sequence.length;    
    int sum=0;      
    for(int i=1;i<=n;i++)    
    for(int j=0;j<n;j++){       
             sum=0;           
    for(int k=j;k<j+i&&k<n;k++)         
     sum +=sequence[k];        
                 if(sum>max)            
                 max=sum;    
                         }
        return max;   
         }
         }

由于该算法存在三重for循环O(n^3)，当n较大时是不行的，对上述穷举进行一些修改，利用一个递推，可以撤除一个for循环：

public class 空间算法 { 
 public static int maxSub_2(int[] sequence) {      
     int max = 0;      
      int n = sequence.length;    
      int sum = 0;    
               for (int i = 1; i <= n; i++) {    
                       sum = 0;         
                for (int j = i; j < n; j++) {     
                         sum += sequence[j];       
                if (sum > max)      
              max = sum;     
      }      
      }     
              return max;   
                                                                                 }
    }

重复执行的次数为：n(n+1)/2=O(n^2)

下面采用"分治法"的策略解决这个问题，

其思想是：
把问题分成两个大致相等的子问题，然后递归的对它们求解，这是分的部分；
"治"阶段将两个子这问题的解合并到一起并做一些调整后得到整个问题的解。

public static int maxSum(int[] sequence, int left, int right) {     
   if (left == right)     
 if (sequence[left] > 0)       
     return sequence[left];      
  else        
      return 0;  
  int mid = (left + right) / 2;    
  
int maxLeftSum = maxSum(sequence, left, mid); 
int maxRightSum = maxSum(sequence, mid + 1, right);      

                  int maxLeftBorderSum = 0,        
                  
                   leftBorderSum = 0;     
                   
    for (int i = mid; i >= left; i--) {       
    
                      leftBorderSum += sequence[i];     
                      
           if (leftBorderSum > maxLeftBorderSum)       
                
                       maxLeftBorderSum = leftBorderSum;     
                       
                       
                               }   
                               
         int maxRightBorderSum = 0,         
             
                     rightBorderSum = 0; 
                     
    for (int i = mid + 1; i <= right; i++) {      
    
                rightBorderSum += sequence[i];     
                
                
     if (rightBorderSum > maxRightBorderSum)             
            maxRightBorderSum = rightBorderSum;      
     
                        }     

 return max3(maxLeftSum, maxRightSum, maxLeftBorderSum + maxRightBorderSum);  
           }
            public static int max3(int a, int b, int c) {     
               int max = a > b ? a : b;   
                    max = max > c ? max : c;     
                       return max; 


  }


public static int maxSub_3(int[] sequence) {      
              return maxSum(a,0,sequence.length-1);  
               }
        
 }
        
 

   
此算法：T(1)=1;T(n)=2T(n /2)+O(n);

动态规划的思想：

  public class 算法2 {   
 public static int maxSub_4(int [] squence){     
  int max=0;     
  int n=squence.length;       
int sum=0;    
  for(int i=0;i<n;i++){      
    sum+=squence[i];        
        if(sum>sum)        
         max=sum;      
        else if(sum<0)           
            sum=0;    
      }    
           return max;
                }
                }
           

 
        此算法时间复杂度O(n)。

最后有什么问题和建议，请给位大佬多多指教。