数据结构学习日记一：绪论

数据结构学习笔记

该文章中的代码非我本人所写。只是借鉴。由于很多出处的代码千篇一律，就不标明代码来源了。

一、绪论

1、c语言测试函数运行时间

clock()：捕捉从程序开始运行到clock() 被调用时所耗费的时间。这个时间单位是clock tick，即”时钟打点“。

常数CLK_TCK：机器时钟每秒所走的时钟打点数。

模板如下：

#include <stdio.h>
#include <time.h>

clock_t start, stop;//clock_t是clock()函数的返回值类型
double duration;//记录被测函数运行时间，单位秒

int main(){
    //前面代码（省）
    start = clock();
    MyFunction();//这里调用需要测试的函数
    stop = clock();
    duration = ((double)(stop - start))/CLK_TCK;//得出时间
    //输出（省）
    return 0;
}

2、时间复杂度

对于常见时间复杂度的直观体验。

可以看到 logn 是增长最慢的时间复杂度，然后一般碰到 n²，可以考虑一下修改算法变成 nlogn。

复杂度分析技巧

假设两段算法的复杂度分别是 O1 和 O2。复杂度里的式子分别是n1和n2。

1. 两段算法分别处理，总的复杂度 = MAX（O1, O2）；
2. 两段算法嵌套在一起，总的复杂度 = O(n1*n2)；
3. 如果复杂度里的关于n的式子是一个k阶多项式，那么只保留n^k；
4. for循环的时间复杂度 = 循环次数 * 循环体代码的复杂度；
5. if-else的复杂度 = MAX(条件判断的复杂度，每个分支内部代码的复杂度)

3、最大子列和问题

算法1

全部子列和都遍历了一遍，时间复杂度O(n²)。

int MaxSubseqSum1(int A[], int N){
    int ThisSum, MaxSum = 0;
    int i, j, k;
    for(i = 0; i < N; i++){//i是子列的左端位置
        ThisSum = 0;
        for(j = i; j < N; j++){//j是子列右端位置
                ThisSum += A[j];//这里是在j-1的基础上增加的
            if(ThisSum > MaxSum)
                MaxSum = ThisSum;
        }//j循环结束
    }//i循环结束
    return MaxSum;
}

算法2：分治法

每次递归过程，把当前数组分两段，左段求最大子列和，右段求最大子列和，跨界情况 = 中间往左的最大子列和 + 中间往右的最大子列和。然后三个子列和求最大。

关于该分治法的时间复杂度

看不太懂上面的推导为啥就得出O(NlogN)，我在网上查找到的一种解释是：枚举的复杂度是O(N)，递归的复杂度是O(logN)，所以是O(NlogN)。

int Max( int A, int B, int C )
{ /* 返回3个整数中的最大值 */
    return A > B ? A > C ? A : C : B > C ? B : C;
}

int DivideAndConquer( int List[], int left, int right )
{ /* 分治法求List[left]到List[right]的最大子列和 */
    int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
    int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/

    int LeftBorderSum, RightBorderSum;
    int center, i;

    if( left == right )  { /* 递归的终止条件，子列只有1个数字 */
        if( List[left] > 0 )  return List[left];
        else return 0;
    }

    /* 下面是"分"的过程 */
    center = ( left + right ) / 2; /* 找到中分点 */
    /* 递归求得两边子列的最大和 */
    MaxLeftSum = DivideAndConquer( List, left, center );
    MaxRightSum = DivideAndConquer( List, center+1, right );

    /* 下面求跨分界线的最大子列和 */
    MaxLeftBorderSum = 0; LeftBorderSum = 0;
    for( i=center; i>=left; i-- ) { /* 从中线向左扫描 */
        LeftBorderSum += List[i];
        if( LeftBorderSum > MaxLeftBorderSum )
            MaxLeftBorderSum = LeftBorderSum;
    } /* 左边扫描结束 */

    MaxRightBorderSum = 0; RightBorderSum = 0;
    for( i=center+1; i<=right; i++ ) { /* 从中线向右扫描 */
        RightBorderSum += List[i];
        if( RightBorderSum > MaxRightBorderSum )
            MaxRightBorderSum = RightBorderSum;
    } /* 右边扫描结束 */

    /* 下面返回"治"的结果 */
    return Max( MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum );
}

int MaxSubseqSum2( int List[], int N )
{ 	//方便调用
    return DivideAndConquer( List, 0, N-1 );
}

算法3：在线处理

该算法只是刚好针对这个问题。时间复杂度为O(n)。

int MaxSubseqSum3(int A[], int N){
    int ThisSum, MaxSum;
    int i;
    ThisSum = 0; 
    MaxSum = 0;
    for(i = 0; i < N; i++){
        ThisSum += A[j];
        if(ThisSum > MaxSum)//正的情况，巧妙地把劣种排除了
            MaxSum = ThisSum;
        else if(ThisSum < 0) //如果当前子列和为负
            ThisSum = 0;	//说明加上后面的数，只会变小，所以抛弃。
        }
    }//i循环结束
    return MaxSum;
}

显然（记录前一轮，再此基础上计算）的算法，会比回回重新计算来得高效。