算法导论——第一部分——基础知识

第二章： 

1/ 插入排序：原址，复杂度为n^2

　　最佳运行时间为线性，最坏情况为n^2　

void sort_array(int  *array )
{
    int size = 7;
    cout << "the size is " << size<<endl;
    int key;
    for (int j = 1; j < size; j++)              
    {
        key = array[j];                   // key is  in  vector as the j's number
        int i = j - 1;
        while (i>=0 && key < array[i])    //  insert the key in the j-1's already sorted number 
        {                                 //  in the right order . 
            array[i + 1] = array[i];
            i = i - 1;            
        }            
        array[i + 1] = key;
    }
    for (int k = 0; k <7; k++)
        cout << array[k] << endl;
    cout << "end of the sort" << endl;
}

2/ 归并排序（merge sort）：需要另外开辟n个存储空间  复杂度： nlgn

　　merge : 假设merge的两个数串都是已经排序好的数

void merge(int *A, int p, const int q, const int r)
{
    if (p > q || q > r )
        cout << "data erro in merge" << endl;
    else
    {
        const int n1 = q - p + 1;
        const int n2 = r - q;
        int *L = new int[n1 + 1];
        int *R = new int[n2 + 1];
        for (int i = 0; i < n1; i++)
            *(L + i) = *(A + p + i);
        for (int j = 0; j < n2; j++)
            *(R + j) = *(A + q + 1 + j);
        *(L + n1) = 0xfffffff;
        *(R + n2) = 0xfffffff;
        int i = 0, j = 0;
        for (int m = 0; m <= r - p; m++)
        {
            if (*(L + i)>*(R + j))
            {
                *(A +p+m) = *(R + j);
                j++;
            }
            else
            {
                *(A+p+m) = *(L + i);
                i++;
            }
        }
        delete[]L;
        delete[]R;
    }
}
void merge_sort(int *A, const int p, const int r)
{
    if (p >r)
        cout << "data error int sort" << endl;
    else 
    {
        int q = (p + r) / 2;
        if (q == p || q == r)
        {
            if (*(A + r) < *(A + p))
            {
                int temp = *(A+r);
                *(A + r) = *(A + p);
                *(A + p) = temp;
            }
            return;
        }
        else
        {
            merge_sort(A, p, q);
            merge_sort(A, q + 1, r);
            merge(A, p, q, r);
        }
    }
}

3、 最大子数组问题：  求一个数组中后一个元素与它之前的任意一个元素的差的最大值（股票最大利润） 假设分别为 m , n

a/   暴力求解： n^2

b/   分治策略： nlgn 采用递归解决

　　将原来数组分解为两个数组，出现两种情况： 

　　　　m在后一个数组，n在前一个数组。  m： 后一个数组的最大值   n：前一个数组的最小值

c/  将原来数组转换为连续值得差值，求子数组和最大的子数组

　　如：  10，11，7,10，6  转换为： 1 ，-4 ，3， -4  定义一个sum如果前面的和为小于0则丢弃，从新开始新的数组

int max(int *a , int n){
    if (n <= 1) return 0;
    int *b = new int(n-1);
    int sum ,max ;
    for (int i = 1; i < n; i++)
        *(b + i - 1) = *(a + i) - *(a+i-1);
    sum = *b;
    max = *b;
    for (int i = 0; i < n - 1; i++){
        if (sum <= 0){
            sum = 0;
        }
        else{
            if (max < sum) max = sum;
            sum = sum + *(b + i);
        }
    }
}

 4、 用主方法求解递归公式

在用递归解决问题时，常会用到递归公式，主定理用于求解递归公式的复杂度。

　　　　T(n)  = aT(n/b) + f(n);

三种情况的判断标准： f(n) 和 n^(lg a / lg b )  的复杂度 大小

                           

证明略， 部分可参考： http://www.cnblogs.com/SBSOI/p/5640663.html