数据结构与算法笔记第1章 绪论

目录

基本概念

1.数据：数值型和非数值型
2.数据元素：是数据的基本单位
3.数据项：构成数据元素的最小单位
4.数据>数据元素>数据项
5.数据对象：性质相同的数据元素的集合
6.数据结构：数据元素相互之间的关系

逻辑结构

1.线性结构：有且仅有一个开始和一个终端结点，并且所有结点最多只有一个直接前趋和一个直接后继
2.非线性结构：一个结点可能有多个直接前趋和直接后继

存储结构

1.顺序存储结构
2.链式存储结构（指针）

抽象数据类型的表示与实现

例：关于圆的函数
1.抽象 类型定义

ADT Complex{
	数据对象：D={r1,r2|r1,r2都是实数}
	数据关系：S={<r1，r2>|r1是实部,r2是虚部}
	基本操作：
	assign(&C,v1,v2)
			初始条件：空的复数C已存在
			操作结果：构造复数C，r1,r2分别被赋以参数v1,v2的值
	add(Complex *C,Complex *A,Complex *B)
			初始条件：复数A,B已存在
			操作结果：复数A,B被相加,返回复数C
			……
}ADT Complex

2.将上面的抽象类型定义转化为C语言形式

/*定义数据类型*/
typedef struct{
		float realpart;//实部
		float imagpart;//虚部
}Complex               //定义复数抽象类型
/*函数声明*/
void assign(Complex *A,float real,float imag);//赋值
void add(Complex *C,Complex A,Complex B);//销毁
/*具体的构造函数*/
void assign(Complex *A,float real,float imag)
{
	A->realpart=real;//实部赋值
	A->imagpart=imag;//虚部赋值
}
void add(Complex *C,Complex A,Complex B)
{
	C->realpart=A.realpart+B.realpart;//实部相加
	C->imagpart=A.imagpart+B.imagpart;//虚部相加
}

例：求复数 8+6i 和 4+3i 的和以及他们的积？PS：除法运算规则太难

/*
运行结果：
add:12.0+9.0i
multiply:14.0+48.0i
*/
#include<stdio.h>
#include<stdlib.h>
typedef struct
{
	float realpart;//实部
	float imagpart;//虚部
}Complex;
void assign(Complex* C, float real, float imag);
void add(Complex* C, Complex A, Complex B);
void multiply(Complex* C, Complex A, Complex B);
float Getreal(Complex C);
float Getimag(Complex C);
int main()
{
	Complex C, C1, C2, D1, D2;
	float Real = 0, Imag = 0;
	assign(&C1, 8.0, 6.0);
	assign(&C2, 4.0, 3.0);
	add(&D1, C1, C2);
	Real=Getreal(D1);
	Imag=Getimag(D1);
	printf("add:%.1lf+%.1lfi\n", Real, Imag);
	multiply(&D2, C1, C2);
	Real = Getreal(D2);
	Imag = Getimag(D2);
	printf("multiply:%.1lf+%.1lfi\n", Real, Imag);
	return 0;
}
void assign(Complex* C, float real, float imag)
{
	C->realpart = real;
	C->imagpart = imag;
}
void add(Complex* C, Complex A, Complex B)
{
	C->realpart = A.realpart + B.realpart;
	C->imagpart = A.imagpart + B.imagpart;
}
void multiply(Complex* C, Complex A, Complex B)
{
	C->realpart = A.realpart * B.realpart - A.imagpart * B.imagpart;
	C->imagpart = A.imagpart * B.realpart + A.realpart * B.imagpart;
}
float Getreal(Complex C)
{
	return C.realpart;
}
float Getimag(Complex C)
{
	return C.imagpart;
}

算法特性

	 有穷性
	 确定性
 	 可行性
	 输入
	 输出

算法效率

1.时间效率
算法运行时间=∑ _{每条语句的执行次数*该语句执行一次所需的时间}，算法运行时间和算法本身无关，由软硬件环境决定的;

f(1)<f(log₂n)<f(n)<f(nlog₂n)<f(n²)<f(n³)<f(2ⁿ)<f(n!)

例1：两个 n*n 矩阵相乘的算法可描述为？

for(i=1;i<=n;i++)                             //n+1次
	for(j=1;j<=n;j++)                         //n*(n+1)次
	{
		c[i][j]=0;                            //n*n次
		for(k=0;k<n;k++)                      //n*n*(n+1)次
			c[i][j]=c[i][j]+c[i][k]*c[k][i];  //n*n*n次
	}

（1）上述算法的时间消耗T(n)为：T(n)=2n³+3n²+2n+1称O(f(n))为算法的渐进时间复杂度——求出的T(n)函数的数量级，综上所述，T(n)=O(n³)为该算法的时间复杂度;
（2）是用公式计算;

例2：

for(i=1;i<=n;i++)
	for(j=1;j<=i;j++)
		for(k=1;k<=j;k++)
			x=x+1;

公式计算

例3：

i=1;
while(i<=n)
	i=i*2;

若循环执行1次：i=1* 2=2
若循环执行2次：i=2* 2=2²
若循环执行3次：i=2²* 2=2³
……
若循环执行x次：i=2^x
2^x<=n
x<=log₂n
f(n)=log₂n

2.空间效率
空间复杂度：算法所需存储空间的量度记作：S(n)=O(f(n));
例：比较两个代码理解

//代码1 S(n)=O(1)
for(i=0;i<n/2;i++)
{
	a[i]=a[n-1-i];
}
//代码2 S(n)=O(n)
for(i=0;i<n;i++)
{
	b[i]=a[n-1-i];
}
for(i=0;i<n;i++)
{
	a[i]=b[i];
}