数据结构笔记（一）

1.1.1——关于数据组织

解决问题方法的效率跟数据结构的组织方式有关。

1.1.2——关于空间使用

例：写一程序实现一个函数PrintN，使得传入一个正整数N的参数后，能顺序打印从1到N的全部正整数。

主函数：

#include <stdio.h>
int main()
{
    int N;
    scanf("%d",&N);
    PrintN(N);
    return 0;
}

（1）循环实现：

void PrintN(int N)
{	
	int i;
	for(i=1;i<=N;i++){
		printf("%d\n",i);
	}
	return ;
}

（2）递归实现：

void PrintN(int N)
{
	if(N){
		PrintN(N-1);
		printf("%d\n",N);
	}
	return;
}

//占用空间太大，导致非正常终止。
总结：解决问题方法的效率，跟空间的利用效率有关。

1.1.3——关于算法的效率

例：写程序计算给定多项式在定点x处的值  

（1）f（x）=a0+a1x+......+anx^n

double f(int n,double a[],double x)
{			
	int i;
	double p=a[0];
	for(i=1;i<=n;i++)
		p+=(a[i]*pow(x,i));
	return p;
}

（2）f(x)=a0+x(a1+x(...(a(n-1)+x(an))...))

double f(int n,double a[],double x)
{	
	int i;
	double p=a[n];
	for(i=n;i>0;i--)
		p=a[i-1]+x*p;
	return p;
}

两种方式为什么说下面的方法更好呢？因为第二种的运行时间更短。

那为什么第二种更短，可以用一个clock()函数来计算

clock()函数介绍:

clock():捕捉从程序开始运行到clock（）被调用时所需要耗费的事件。这个时间单位是clock tick，即“时钟打点”。
常数CLK_TCK：机器时钟每秒所走的时钟打点数。

#include<stdio.h>
#include<time.h>
clock_t start,stop;                           //clock_t是clock()函数返回的变量类型
double duration;                             //记录被测函数的运行时间，以秒为单位
int main()
{
    //不在测试返回内的准备工作写在clock()调用之前
    start = clock();
    MyFunction();                                   //调用函数
    stop = clock();
    duration =((double)(stop-start))/CLK_TCK;
    //其他不在测试范围内的处理写在后面，例如输出duration的值
    printf("%lf\n",duration);
    return 0;
}

下面拿回多项式来举例：

例：写程序计算给定多项式f（x）=（9）∑（i=0）i*x^i，在给定点x=1.1处的值f（1.1)

#include<stdio.h>
#include<time.h>
#include<math.h>
#define MAXN 10																				//多项式最大项数，即多项式阶数+1
clock_t start,stop;
double duration;
double f1(int n,double a[],double x);
double f2(int n,double a[],double x);
int main()
{
    int i;
    double a[MAXN];              													 //存储多项式的系数
    for(i=0; i<MAXN; i++)
    {
        a[i]=(double)i;
    }
    start = clock();
    f1(MAXN-1,a,1.1);           															   //调用函数
    stop = clock();
    duration =((double)(stop-start))/CLK_TCK;
    //其他不在测试范围内的处理写在后面，例如输出duration的值
    printf("ticks1=%f\n",(double)(stop-start));
    printf("duration1=%6.2e\n",duration);
    
    start = clock();
    f2(MAXN-1,a,1.1);																								//调用函数
    stop = clock();
    duration =((double)(stop-start))/CLK_TCK;
    //其他不在测试范围内的处理写在后面，例如输出duration的值
    printf("ticks2=%f\n",(double)(stop-start));
    printf("duration1=%6.2e\n",duration);
    return 0;
}
double f1(int n,double a[],double x)
{
    int i;
    double p=a[0];
    for(i=1; i<=n; i++)
    {
        p+=(a[i]*pow(x,i));
    }
    return p;
}
double f2(int n,double a[],double x)
{
    int i;
    double p=a[n];
    for(i=n; i>0; i--)
    {
        p=a[i-1]+x*p;
    }
    return p;
}

但是，最终程序运行后显示都是0，为什么呢？因为两个程序的时间都太短了，那现在有什么方法计算呢？

在物理上有一个方法，计算一张纸的厚度，往往不是只量一张，是把多张纸叠起来，计算总和后除纸张数，求出平均厚度，即单张纸的厚度。

类似的，让被测函数重复运行充分多次，使得测出的总的时钟打点间隔充分长，最后计算被测函数平均每次运行的时间即可。

#include<stdio.h>
#include<time.h>
#include<math.h>
#define MAXN  1e7                                                   //被测函数调用的最大次数
clock_t start,stop;
double duration;
double f1(int n,double a[],double x);
double f2(int n,double a[],double x);
int main()
{
    int i;
    double a[MAXN];                                                         //存储多项式的系数
    for(i=0; i<MAXN; i++)																				//重复调用函数以获得充分多的时钟打点数
    {
        a[i]=(double)i;
    }
    start = clock();
    f1(MAXN-1,a,1.1);                                                              //调用函数
    stop = clock();
    duration =((double)(stop-start))/CLK_TCK/MAXN;				//计算函数单词运行的时间
    //其他不在测试范围内的处理写在后面，例如输出duration的值
    printf("ticks1=%f\n",(double)(stop-start));
    printf("duration1=%6.2e\n",duration);
    
    start = clock();
    f2(MAXN-1,a,1.1);                                															//调用函数
    stop = clock();
    duration =((double)(stop-start))/CLK_TCK/MAXN;
    //其他不在测试范围内的处理写在后面，例如输出duration的值
    printf("ticks2=%f\n",(double)(stop-start));
    printf("duration1=%6.2e\n",duration);
    return 0;
}
double f1(int n,double a[],double x)
{
    int i;
    double p=a[0];
    for(i=1; i<=n; i++)
    {
        p+=(a[i]*pow(x,i));
    }
    return p;
}
double f2(int n,double a[],double x)
{
    int i;
    double p=a[n];
    for(i=n; i>0; i--)
    {
        p=a[i-1]+x*p;
    }
    return p;
}

就是把MAXN的个数加大，最后计算duration时，除MAXN。

最后可以得出两个方法的时间，第二种的时间比第一种的时间要小一个数量级。

（作者没有电脑，只能撸代码，没有运行结果，大家自己运行）

1.1.4——抽象数据类型

数据对象在计算机中的组织方式
逻辑结构
物理存储结构
数据对象必定与一系列加在其上的操作相关联
完成这些操作所用的方法就是算法

抽象数据类型（ADT）

数据类型
数据对象集
数据集合相关联的操作集
抽象：描述数据类型的方法不依赖于具体实现
与存放数据的机器无关。
与数据存储的物理结构无关。
与实现操作的算法和编程语言均无关。
只描述数据对象集合相关操作集“是什么”，并不涉及“如何做到”的问题。

例：“矩阵”的抽象数据类型定义（红色标记均为抽象）

类型名称：矩阵（Matrix）
数据对象集：一个M×N的矩阵A（M×N)=(aij)(i=1,...,M;j=1,....,N)由M×N个三元组<a，i，j>构成，其中a是矩阵元素的值，i是元素所在的行号，j是元素所在的列号。
操作集：对于任意矩阵A，B，C∈Matrix，以及整数i、j、M、N
Matrix Create(int M,int N)：返回一个M×N的空矩阵；
int GetMaxRow(Matrix A)：返回矩阵A的总行数；
int GetMaxCol(Matrix A)：返回矩阵A的列数；
ElementType GestEntry(Matrix A,int i,int j)：返回矩阵A的第i行、第j列的元素；
Matrix Add(Matrix A,Matrix B)：如果A和B的行、列数一致，则返回矩阵C=A+B，否则返回错误标志；
Matrix Multiply(Matrix A,Matrix B)：如果A的列数等于B的行数，则返回矩阵C=AB，否则返回错误标志；

....