数据结构与算法分析：算法分析

1.数学模型

①4个重要的定义：如果存在正常数c和n使得N>=n时

$T\left ( N \right )\leq cf\left (N \right )$ ，记作 $T\left ( N \right )=O\left (f\left (N \right ) \right )$

$T\left ( N \right )\geq cg\left ( N \right )$ ，记作 $T\left ( N \right )=\Omega \left ( g\left ( N \right )\right )$

当且仅当 $T\left ( N \right )=O \left (h \left ( N \right ) \right )$ 且 $T\left ( N \right )=\Omega \left ( h\left ( N \right ) \right )$ 有 $T\left ( N \right )=\Theta \left ( h \left (N \right )\right )$

如果 $T\left ( N \right )=O\left ( p\left ( N \right ) \right )$ 且 $T\left ( N \right )\neq \Theta \left ( p\left ( N \right ) \right )$ 有 $T\left ( N \right )=o\left ( p\left ( N \right ) \right )$

②

$T\left ( N \right )=O\left ( f\left ( N \right ) \right )$ ：f（N）是 T（N）的上界

$T\left ( N \right )=\Omega \left ( f\left ( N \right ) \right )$ ：f（N）是T（N）的下界

③ 我们需要掌握的重要结论：

法则1：如果 $T_{1}\left ( N \right )=O\left ( f\left ( N \right ) \right )$ 且 $T_{2}=O\left ( g\left ( N \right ) )$

(a) $T_{1}\left ( N \right )+T_{2}\left ( N \right )=max\left ( O\left ( f\left ( N \right ) \right ),O\left ( g\left ( N \right ) \right ) \right )$

(b) $T_{1}\left ( N \right )*T_{2}\left ( N \right )=O\left ( f\left ( N \right )*g\left ( N \right ) \right )$

法则2：如果T（N）是一个k次多项式， $T\left ( N \right )=\Theta \left ( N^{k} \right )$

法则3：对任意常数k， $\log^{k}N=O\left ( N \right )$ 。它告诉我们对数增长得非常缓慢

函数	名称
c	常数
$\log N$	对数级
$\log ^{2}N$	对数平方根
N	线性级
$N\log N$
$N^{2}$	平方级
$N^{3}$	立方级
$2^{N}$	指数级

2.要分析的问题

影响着程序的运行时间的主要因素：所使用的算法以及对该算法的输入

①输入的大小

$T_{worst}\left ( N \right )$ ：最坏情况下的运行时间（通常情况，以这个为判别算法好坏的标准）

$T_{avg}\left ( N \right )$ ：平均运行时间

②最大的子序列和问题：

给定整数 $A_{1}$ ， $A_{2}$ ·····， $A_{N}$ （可能有负数），求 $\sum_{k=i}^{j}A_{k}$ 的最大值。

3.运行时间的计算

①一般法则：从内向外展开（基本策略）

for循环：一次for循环的时间至多是该for循环内语句的运行时间乘以迭代的次数

嵌套的for循环：从里向外分析这些循环，运行时间为该语句的运行时间乘以改组所有for循环的大小的乘积

顺序语句：各语句的运行时间求和

if/else语句：不超过判断再加上if中的语句和else中语句中运行时间最长者的总的运行时间

②一个例子：

    long int Fib(int N){
          if(N<=1)
               return 1;
          else
               retrun Fib(n-1)+Fib(n-2);
     }

$Fib\left ( N \right )$ 的运行时间公式： $T\left ( N \right )=T\left ( N-1 \right )+T\left ( N-2 \right )+2$

可见这个程序的运行时间以指数的速度增长：注意在调用Fib（n-1）实际上计算了Fib（n-2）。这个信息被抛弃在第二次调用时又重新计算了一遍。

“计算任何事情不要超过一次”

③最大子序列和问题的解

算法1：穷举地尝试所有的可能

int MaxSequenceSum(const int A[],int N){
      int ThisSum,MaxSum,i,j,k;
      MaxSum=0;
      for(i=0;i<N;i++)
        for(j=i;j<N;j++)
         { ThisSum=0;
            for(k=i;k<=j;k++)
               ThisSum+=A[k];
            if(ThisSum>MaxSum)
                 MaxSum=ThisSum;
          }
       return MaxSum;
  }

$T\left ( N \right )=\sum_{i=0}^{N-1}\sum _{j=i}^{N-1}\sum _{k=i}^{j}=\frac{N^{3}+3N^{2}+2N}{6}$

算法2：撤销一个for循环避免立方运行时间

   int MaxSequenceSum(const int A[],int N){
        int ThisSum,MaxSum,i,j;
        MaxSum=0;
        for(i=0;i<N;i++){
             ThisSum=0;
             for(j=i;j<N;j++){
                ThisSum+=A[j];
                if(ThisSum>MaxSum)
                  MaxSum=ThisSum;
               }
         }
      return MaxSum;
  }

$T\left ( N \right )=O\left ( N^{2} \right )$

算法3：“分治”的策略。把问题分成两个大致相等的子问题，然后递归地对它们求解。这是“分”的部分。“治”阶段将两个子问题的解合并在一起并可能地做少量的附加地工作

说明:递归过程的调用的一般形式是传递输入的数组以及左边界和有边界，它们界定了数组要处理的部分。

前半部分	后半部分
4 -3 5 -2	-1 2 6 -2

不难得到前半部分最大子序列和为6，后半部分最大子序列和为8，横跨两部分的中间部分的最大子序列和则为11。

  static int MaxSubSum(const int A[],int Left,int Right){
        int MaxLeftSum,MaxRightSum;
        int MaxLeftBorderSum,MaxRightBorderSum;
        int LeftBorderSum,RightBorderSum;
        int Center,i;
 
        /* Base Case */
        if(Left==Right){
           if(A[Left]>0)
               return A[left];
        else 
               return 0;
         }

        Center=(Left+Right)/2;
        MaxLefeSum=MaxSubSum(A,Left,Center);
        MaxRightSum=MaxSubSum(A,Center,Right);
     
        MaxLeftBorderSum=0;LeftBorderSum=0;
        for(i=Center;i>=Left;i--){
           LeftBorderSum+=A[i];
           if(LeftBorderSum>MaxLeftBorderSum)
                  MaxLeftBorderSum=LeftBorderSum;
           }
    
   
        MaxRightBorderSum=0;RightBorderSum=0;
        for(i=Center+1;i<=Right;i++){
           RightBorderSum+=A[i];
           if(RightBorderSum>MaxRightBorderSum)
                  MaxRightBorderSum=RightBorderSum;
           }

        return Max3(MaxLeftSum,MaxRightSum,LeftBorderSum+RightBorderSum);
        /*     Max3返回三者中的最大数   */
}


   int MaxSequenceSum(const int A[],int N){
        return MaxSubSum(A,0,N-1);
  }

得到运行时间的方程组：

$T\left ( 1 \right )=1$

$T\left ( N \right )=2T\left ( \frac{N}{2}\right )+O\left ( N \right )$

解得 $T\left ( N \right )=O\left ( N\log N\right )$

算法4：只对数据进行一次扫描，一旦A[i]读入并被处理，它就不再需要被记忆

   int MaxSequenceMax(const int A[],int N){
          int ThisSum,MaxSum,j;
          ThisSum=MaxSum=0;
          for(j=0;j<N;j++){
                  ThisSum+=A[j];
                  
                  if(ThisSum>MaxSum)
                    MaxSum=ThisSum;
                  else if(ThisSum<0)
                      ThisSum=0;
           }
          return MaxSum;
  }

④运行时间中的对数

将对数最常出现的规律归纳为下列一般法则：

如果一个算法常用常数时间将问题的大小消减为其一部分，那么该算法就是 $O\left ( \log N \right )$

如果使用常数时间把问题减少一个常数，那么该算法就是 $O\left ( N \right )$

对分查找：

循环在High-Low=N-1开始，在High-Low>=-1时结束。每次循环后High-Low的值至少将该次循环前的值折半。于是循环的次数最多是 $\left \lceil \log \left ( N-1 \right ) \right \rceil+2$

  int BinarySearch(const ElementType A[],ElementType X,int N){
         int Low,Hight,Mid;
         Low=0;
         Hight=N-1;
        
         while(Low<=High){
            Mid=(Low+High)/2;
            if(A[Mid]<X)
                Low=Mid+1;
            else if([Mid]>X)
                 High=Mid-1;
            else 
                 return Mid;
          }
          return NotFound;
  }

欧几里得算法：计算最大公因子

我们可以证明，在两次迭代后，余数最多是原始值的一半。

$T\left ( N \right )=O\left ( \log N \right )$

  unsigned ind Gcd(unsigned int M,unsigned int N){
      unsigned int Rem;
      
      while(N>0)
    {  
       Rem=M%N;
       M=N;
       N=Rem;
    }

     return M;
  }

定理2：

如果M>N，则M mod N < M/2;

幂运算：

计算 $X^{N}$ 最常见的方法就是使用N-1次乘法自乘。

  long int Pow(long int X,unsigned int N){
            if(N==0)
                 return 1;
            if(N==1)
                 return X;
            if(IsEven(X)) 
                 return Pow(X*X,N/2);
            else 
                 return Pow(X*X，N/2)*X;
          }

⑤ 检验你的分析

⑥分析结果的准确性