算法总结（一） 算法分析

算法分析

算法 数据结构 算法分析 算法复杂度

---

• 什么是算法
• 算法复杂度表示方法
• 例题分析

什么是算法

算法（algorithm）就是解决一个问题需要遵循的，被清楚的指定的简单指令的集合。简而言之就是解决一个问题的方法。解决问题的方法有很多种，如何最好最快的解决问题就是算法的美妙之处。我更喜欢把算法当做一种艺术，一种智慧之美

算法复杂度表示方法

四个定义：
1.如果存在正整数 c 和 $n_{0}$ 使得当 $N\geq n_{0}$ 时 $T\left( N\right)\leq cf\left( N\right)$ ,则记为$T\left( N\right) =O \left( f\left( N\right) \right)$

2.如果存在正整数 c 和 $n_{0}$ 使得当 $N\geq n_{0}$ 时 $T\left( N\right)\geq cg\left( N\right)$ ,则记为$T\left( N\right) =\Omega \left( g\left( N\right) \right)$

3.$T\left( N\right) =\theta \left( h\left( N\right) \right)$ 当且仅当 $T\left( N\right) =O \left( f\left( N\right) \right)$ 且 $T\left( N\right) =\Omega \left( g\left( N\right) \right)$

4.如果 $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_A(N) = 1000 N$$
$$T_B(N) = N^2$$
$$T_A 和 T_B谁更快呢？$$

程序运行时间分析

得到：

$$If \ N<1000\quad T_A(N) > T_B(N)$$
$$If\ N>1000\quad T_B(N) > T_A(N)$$

所以我们要根据不同的实际情况应用相应的算法去解决问题

从上也可以看出在数据大的时候算法优化的必要性

算法复杂度例题分析

最大区间和算法分析

题目要求:

在一串数中找到最大的区间和

算法一：

for each i (0 to N-1)
for each j (i to N-1)
    compute the sum of subsequence for (i to j)
    check if it is maximum

        int MaxSubsequenceSum( const int A[ ], int N )
        {
            int ThisSum, MaxSum, i, j, k;

/* 1*/      MaxSum = 0;
/* 2*/      for( i = 0; i < N; i++ )
/* 3*/          for( j = i; j < N; j++ )
                {
/* 4*/              ThisSum = 0;
/* 5*/              for( k = i; k <= j; k++ )
/* 6*/                  ThisSum += A[ k ];

/* 7*/              if( ThisSum > MaxSum )
/* 8*/                  MaxSum = ThisSum;
                }
/* 9*/      return MaxSum;

$$算法复杂度：T(N) = O(N^3)$$

算法二：

通过已经计算过的区间和求出下一个区间和

        int MaxSubsequenceSum( const int A[ ], int N )
        {
            int ThisSum, MaxSum, i, j;

/* 1*/      MaxSum = 0;
/* 2*/      for( i = 0; i < N; i++ )
            {
/* 3*/          ThisSum = 0;
/* 4*/          for( j = i; j < N; j++ )
                {
/* 5*/              ThisSum += A[ j ];

/* 6*/              if( ThisSum > MaxSum )
/* 7*/                  MaxSum = ThisSum;
                }
            }
/* 8*/      return MaxSum;
        }

$$算法复杂度：T(N) = O(N^2)$$

算法三：

通过二分法

 static int
        Max3( int A, int B, int C )
        {
            return A > B ? A > C ? A : C : B > C ? B : C;
        }
        static int
        MaxSubSum( const int A[ ], int Left, int Right )
        {
            int MaxLeftSum, MaxRightSum;
            int MaxLeftBorderSum, MaxRightBorderSum;
            int LeftBorderSum, RightBorderSum;
            int Center, i;

/* 1*/      if( Left == Right )  /* Base case */
/* 2*/          if( A[ Left ] > 0 )
/* 3*/              return A[ Left ];
                else
/* 4*/              return 0;

/* 5*/      Center = ( Left + Right ) / 2;
/* 6*/      MaxLeftSum = MaxSubSum( A, Left, Center );
/* 7*/      MaxRightSum = MaxSubSum( A, Center + 1, Right );

/* 8*/      MaxLeftBorderSum = 0; LeftBorderSum = 0;
/* 9*/      for( i = Center; i >= Left; i-- )
            {
/*10*/          LeftBorderSum += A[ i ];
/*11*/          if( LeftBorderSum > MaxLeftBorderSum )
/*12*/              MaxLeftBorderSum = LeftBorderSum;
            }

/*13*/      MaxRightBorderSum = 0; RightBorderSum = 0;
/*14*/      for( i = Center + 1; i <= Right; i++ )
            {
/*15*/          RightBorderSum += A[ i ];
/*16*/          if( RightBorderSum > MaxRightBorderSum )
/*17*/              MaxRightBorderSum = RightBorderSum;
            }

/*18*/      return Max3( MaxLeftSum, MaxRightSum,
/*19*/                          MaxLeftBorderSum + MaxRightBorderSum );
        }

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

$$算法复杂度：O(NlogN)$$