数据结构与算法设计（读书笔记）：2.算法分析

数学基础：
定义：

如果只是小量输入的情况，那么花费大量时间去努力设计聪明的算法恐怕并不值得。因此，好的算法应该是因地制宜的，不能盲目。
算法分析的基本策略是从内部（或最深层部分）向外展开的。
正常的用递归解法求解Fib的算法之所以缓慢，是因为有大量的多余的工作量，重复计算较多，可以通过保留一个简单的数组并使用一个for循环将运行时间降下来。

接下来，我们比较四种不同的求解最大子序列和问题的算法。
算法1。

public static int maxSubSum1(int[] a){
            int maxSum = 0;
            for (int i = 0; i < a.length; i++) {
                for (int j = i; j < a.length; j++) {
                    int thisSum = 0;
                    for (int k = i;  k<= j; k++) {
                        thisSum+=a[k];
                    }
                    if(thisSum>maxSum){
                        maxSum = thisSum;
                    }
                }
            }
            return maxSum;
        }
//该算法的思想比较直接。i从0到length，j从i到length，再用k（位于i与j之间）将i与j之间的sum计算出来。这样取最大的sum即为所求。

时间复杂度为N的3次方。
算法2.

public static int maxSubSum2(int[] a){
            int maxSum = 0;
            for (int i = 0; i < a.length; i++) {
                int thisSum = 0;
                for (int j = i; j < a.length; j++) {
                        thisSum+=a[j];
                    if(thisSum>maxSum){
                        maxSum = thisSum;
                    }
                }
            }
            return maxSum;
        }
    //这里的算法2只是1的一个小改动，将原来的：
    for (int k = i;  k<= j; k++) {
                        thisSum+=a[k];
                    }
    换成了：
    thisSum+=a[j];并将thisSum提出（显然的）
    //事实上也应该是这样。最大子序列和问题的本质，就是每个子序列的首与尾的位置不固定，那么我们只需要循环两次，每次得到确定首尾的sum值，然后取最大就可以了

时间复杂度为N的2次方。

“分治”策略：
把问题分成两个大致相等的子问题，然后递归地对他们求解，这是分。
“治”是将两个子问题的解合到一起，并可能做些少量的附加工作，最后得到整个问题的解。
在我们的例子中，最大子序列只可能在3处出现。1.整个出现在输入数据的左半部2.整个出现在输入数据的右半部。针对这两种情况都可以用递归求解。3.最大和可以通过求出前半部分最大和（包含前半部分最后一个元素）以及后半部分的最大和（包含后半部分的第一个元素）而得到，然后将这两个和加在一起。
算法3.

public static int maxSubSum3(int[] a,int left,int right){
            //基本情况
            if(left==right){
                if(a[left]>0){
                    return a[left];//最大子序列
                }else{
                    return 0;//不选取该值作为最大子序列的一部分，所以应该返回0
                }
            }

            //分治
            int center = (left+right)/2;
            int leftMaxSum = maxSubSum3(a, left, center);
            int rightMaxSum = maxSubSum3(a, center+1, right);

            int leftBorderSum = 0,leftBorderMaxSum=0;
            //固定一端center，达到前面的最大子序列
            for (int i = center; i >= left; i--) {
                leftBorderSum+=a[i];
                if(leftBorderSum>leftBorderMaxSum){
                    leftBorderMaxSum = leftBorderSum;
                }
            }

            int rightBorderSum = 0,rightBorderMaxSum=0;
            //固定一端center，达到后面的最大子序列
            for (int i = center+1; i <= right; i++) {
                rightBorderSum+=a[i];
                if(rightBorderSum>rightBorderMaxSum){
                    rightBorderMaxSum = rightBorderSum;
                }
            }

            int twoBorderMaxSum = leftBorderMaxSum+rightBorderMaxSum;
            int maxSum1 = Math.max(leftMaxSum,rightMaxSum);
            int maxSum = Math.max(maxSum1, twoBorderMaxSum);
            return maxSum;
        }

时间复杂度为NlogN.都是用递归，Fib低效而本例却比较高效，是因为每次递归降低问题的维度不一样，前者维度下降慢，后者则是对半的下降。

算法4.

public static int maxSubSum4(int[] a){
            int maxSum =0,thisSum = 0;
            for (int i = 0; i < a.length; i++) {
                thisSum+=a[i];
                if(thisSum>maxSum){
                    maxSum = thisSum;
                }
                if(thisSum<0){
                    thisSum = 0;
                }
            }
            return maxSum;
        }
//分析原因，注意，像算法1和算法2一样，j代表当前序列的终点，而i代表当前序列的起点。碰巧的是，如果我们确实不需要知道最佳的子序列在哪里，那么i的使用可以脱离程序进行优化，我们要改进算法2。
//一个重要结论是，如果a[i]是负的，那么它不可能代表最优序列的起点。类似的，任何负的子序列不可能是最优子序列的前缀。

时间复杂度为N。
该算法的一个附带优点是，它只对数据进行一次扫描，一旦a[i]被读入并被处理，他就不再需要被记忆。因此，如果数组在磁盘上，他就可以被顺序读入，在主存中不必存储数组的任何部分。不仅如此，在任意时刻，算法都能对它已经读入的数据给出子序列问题的正确答案（其他算法不具有这种特性）。具有这种特性的算法叫做联机算法（on-line algorithm）。仅需要常量空间并以线性时间运行的联机算法几乎是完美的算法。

运行时间中的对数：
分析算法最混乱的方面集中在对数上，我们已经看到某些分治算法将以NlogN时间运行。除分治算法外，对数最常出现的规律概括为下列一般法则：
如果一个算法用常数时间将问题的大小削减为其一部分（通常是一半），那么该算法就是logN。
另一方面，如果使用常数时间只是把问题减少一个常数（如将问题减少1），那么这种算法就是N的。

具有对数特点的三个例子：
1.对分查找（Binary Search）,在数据稳定（即不允许插入操作和删除操作）的应用中，Binary Search非常有用。此时输入数据需要一次排序（前提），但是此后访问就很快了。
2.计算最大公因数的欧几里得算法。

public static long gcd(long M,long N){
            while(N!=0){
                long rem = M%N;
                M = N;
                N = rem;
            }
            return M;
        }

3.幂运算