迭代和递归

递归：
1. 减而治之：
为求解一个大规模问题，可以将其规划为两个子问题：其一平凡，另一规模缩减
分别求解子问题
由子问题的解，得到原问题的解

数组求和：线性递归

int sum(int A[], int n){
    return (n < 1) ? 0 : sum(A, n-1) + A[n-1];
}

数组倒置：
任给数组A[0， n),将其前后颠倒
统一接口：void reverse (int *A, int lo, int hi)

void reverse(int *A, int lo, int hi){
    if(lo < hi){
        swap(A[lo], A[hi]);
        reverse(A, lo + 1, hi - 1); 
    }
    //else隐含了两个递归基：剩余元素为最小偶数0或最小基数1
}

2. 分而治之
为求一个大规模的问题，可以将其划分为若干（通常为两个）子问题，规模大体相当
分别求解子问题
由子问题的解，得到原问题的解

数组求和：二分递归

int sum（int A[], int lo, int hi）{
    if(lo == hi) //递归基
        return A[lo]; 
    int mi = (lo + hi) / 2;
    return sum(A, lo, mi) + sum(A, mi + 1, hi);
}

迭代：

从数组区间A[lo, hi)中找出最大的两个整数A[x1] 和 A[x2]

void max2(int A[], int lo, int hi, int &x1, int &x2){
    for(x1 = lo, int i = lo + 1; i < hi; i++){
        if(A[x1] < A[i]) x1 = i;
    }   
    for(x2 = lo, int i = lo + 1; i < x1; i++){
        if(A[x2] < A[i]) x2 = i;
    }   
    for(int i = x1 + 1; i < hi; i++){
        if(A[x2] < A[i]) x2 = i;
    }   
}

复杂度分析：
比较次数恒定为2n - 3;

改进一：

void max2(int A[], int lo, int hi, int &x1, int &x2){
    if（A[x2 = lo] < A[x1 = lo + 1]）
        swap(x1, x2);
    for(int i = lo + 2; i < hi; i++){
        if(A[x1] < A[i])
            if(A[x2] < A[x1 = i])
                swap(x1, x2);
    }
}

最好情况：1 + (n - 2) 1 = n - 1;*
最坏情况： 1 + （n - 2） 2 = 2n - 3;* //没有实质性改进

改进二： 递归 + 分治

递归：分别找出左右两个区间的最大值与次大值，然后通过比较这四个值的大小，确定整个数组的最大值与次大值；
递归基：区间元素为连个或三个的情况。

void max2(int A[], int lo, int hi, int &x1, int &x2)
{
    //只有两个元素的情况
    if (lo + 1 == hi) {
        if (A[lo] < A[hi]) {
            x1 = A[lo];
            x2 = A[hi];
            return;
        }
        else {
            x1 = A[hi];
            x2 = A[lo];
            return;
        }
    }
    //只有三个元素的情况
    if (lo + 2 == hi) {
        if (A[lo] < A[lo + 1]) {
            x1 = A[lo];
            x2 = A[lo + 1];
            if (A[hi] > x2) {
                x1 = x2;
                x2 = A[hi];
                return;
            }
            else {
                if (A[hi] > A[lo]) {
                    x1 = A[hi];
                    return;
                }
            }
        }
        else {
            x1 = A[lo + 1];
            x2 = A[lo];
            if (A[hi] > x2) {
                x1 = x2;
                x2 = A[hi];
                return;
            }
            else {
                if (A[hi] > x1) {
                    x1 = A[hi];
                    return;
                }
            }

        }
    }

    //**有四个及四个以上的元素可以通过分治递归的方式划分为上面两种情况**
    int mid = (lo + hi) / 2;
    int x1L, x2L, x1R, x2R;
    max2(A, lo, mid, x1L, x2L);
    max2(A, mid + 1, hi, x1R, x2R);

    if (A[x2L] > A[x2R]) {
        x2 = x2L;
        x1 = A[x1L] > A[x2R] ? x1L : x2R;
        return;
    }
    else {
        x2 = x2R;
        x1 = A[x1R] > A[x2L] ? x1R : x2L;
        return;
    }

}