数据结构-绪论(Ⅰ)

数据结构-绪论(第一章)的整理笔记，若有错误，欢迎指正。
框架图
$$数据结构\{\begin{array}{l}三要素\{\begin{array}{l}逻辑结构\{\begin{array}{l}线性结构\begin{array}{l}\{\begin{array}{l}一对一的关系\\ 除第一个元素，其余都有唯一前驱\\ 除最后一个元素，其余都有唯一后继\end{array}\end{array}\}(如：线性表、栈、队列、数组、串)\\ 非线性结构\begin{array}{l}\{\begin{array}{l}树形结构：一对多的关系\\ 图形结构：多对多的关系\end{array}\end{array}\}(如：二维/多维数组、广义表、树、图）\end{array}\\ 存储结构\{\begin{array}{l}顺序存储结构\\ \begin{array}{l}链式存储结构\\ 索引存储结构\\ 哈希存储结构\end{array}\}非顺序存储结构\end{array}\\ 数据的运算\{\begin{array}{l}运算描述\\ 运算实现\end{array}\end{array}\\ 数据类型\{\begin{array}{l}原子类型：值不可再分(如：整型、字符型)\\ 结构类型：值可以再分解(如：结构体)\\ 抽象数据类型\end{array}\\ 算法\{\begin{array}{l}算法的五个特征\{\begin{array}{l}有穷性：有限步之后结束，有限时间内完成\\ 确定性：相同的输入只能对应相同的输出\\ 可行性：可通过有限次执行输出某个结果\\ 输入：零个或多个\\ 输出：一个或多个\end{array}\\ 好算法的特质\{\begin{array}{l}正确性：输出正确的结果，能解决实际问题\\ 可读性：便于更好的理解\\ 健壮性：输入非法数据时，能够适当做出反应或进行处理\\ 高效率与低存储量需求：执行速度快并且不费内存\end{array}\\ 算法描述\{\begin{array}{l}输入型参数的描述\\ 输出型参数的描述\end{array}\\ 算法分析\{\begin{array}{l}时间复杂度分析\\ 空间复杂度分析\\ 递归算法的时、空分析\end{array}\end{array}\\ 数据结构+算法=程序\{\begin{array}{l}数据结构和算法的关系\\ 算法和程序的关系\\ 从数据结构角度求解问题的步骤\end{array}\end{array}$$

四种数据存储结构的优缺点对比

存储结构	简介	优点	缺点
顺序存储	把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现	可以实现随机存取，每个元素占用最少的存储空间(存储效率高)	只能使用相邻的一整块存储单元， 因此可能产生较多的外部碎片；不便于数据修改，对元素的插入或删除操作可能要移动一系列的元素
链式存储	不要求逻辑上相邻的元素在物理位置上也相邻，借助指示元素存储地址的指针来表示元素之间的逻辑关系	不会出现碎片现象，能充分利用所有存储单元；便于修改数据，插入或删除操作时仅需修改相应结点的指针域，不必移动结点	每个元素因存储指针而占用额外的存储空间，且只能实现顺序存取
索引存储	在存储元素信息的同时，还建立附加的索引表。索引表中的每项称为索引项，索引项的一般形式是(关键字，地址)	检索速度快，查找效率高	附加的索引表额外占用存储空间
散列存储	根据元素的关键字直接计算出该元素的存储地址，又称哈希(Hash) 存储	检索、增加和删除结点的操作都很快	若散列函数不好，则可能出现元素存储单元的冲突，而解决冲突会增加时间和空间开销

• 顺序存储
  

• 不便于数据修改，对元素的插入或删除操作可能需要移动一系列的元素，逻辑上连续的元素在存储位置上也连续。

• 链式存储
  

• 便于修改数据，对元素进行插入或删除操作时，修改相应结点的指针域即可。逻辑上连续的元素在存储位置上可以不连续。
• ！链式存储设计时，结点内的存储单元地址一定连续。不同结点的存储空间可以不连续。

• 索引存储
  

• 通过创建索引表，利用关键字的有序性可以快速查找到该关键字的地址，从而找到对应元素。逻辑上连续的元素在物理上可以不连续。

• 数据与数据元素的区别与联系
  数据：是信息的载体，能被计算机程序识别和处理（数字、字符、图像等），是一个集合。
  数据元素：是组成数据的基本单位，是数据的个体。
  联系：数据元素与数据的关系是元素与集合的关系。

• 数据逻辑结构与存储结构的区别与联系
  区别：在数据结构中，逻辑结构指数据元素之间的逻辑关系，它与数据的存储无关，独立于计算机，而存储结构是数据元素之间的逻辑关系在计算机中的表示，它依赖于计算机。
  联系：逻辑结构和存储结构都属于数据结构三要素之一，存储结构不仅要将逻辑结构中的所有数据元素存储到计算内存中，而且还要在内存中存储各数据元素间的逻辑关系。通常情况下，一种逻辑结构可以有多种存储结构，例如线性结构可以采用顺序存储结构或链式存储结构表示。
  ！数据的存储结构会影响存储空间分配的方便程度以及数据运算的速度

• 数据结构、数据类型、抽象数据结构的区别
  数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。在任何问题中，数据元素都不是孤立存在的，它们之间存在某种关系，这种数据元素相互之间的关系成为结构(Structure)。
  数据类型： 是一个值的集合+定义在此集合上的一组操作的总称。
  例：bool类型，它是逻辑型变量的定义符，取值为true或false(值的集合)。
  可进行逻辑与(&&)、逻辑或(||)、逻辑非(!)的运算(定义在此集合上的操作)。
  抽象数据类型(ADT)：是一个数学模型+定义在模型上的一组操作。由用户定义，用以表示应用问题的数据模型。它由基本的数据类型构成，与数据类型实质上是一个概念，但它的特征是使用与实现分离，实行封装和信息隐蔽(独立于计算机)。
  抽象数据类型=逻辑结构+抽象运算，通常用(数据对象，数据关系，基本操作集)这样的三元组来表示，从而构成一个完整的数据结构定义。

• 运算描述和运算实现的区别与联系
  联系：运算描述和运算实现都属于数据的运算，而数据的运算又属于数据结构三要素之一。运算描述和运算实现都能完成对数据的“处理"或某种特定的操作。
  区别：运算描述是指逻辑结构施加的操作，它只是描述处理功能，不包括处理步骤和方法，而运算实现是指一个完成该运算功能的算法，它的核心是设计处理步骤。

• 时间复杂度
  ①加法规则
  $T(n)=T_1(n)+T_2(n)=O(f(n))+O(g(n))=O(maxf(n),g(n))$
  ！多项相加，只保留最高阶的项，且系数变为1
  例：$T(n)=3n^3+n^2\Rightarrow O(n^3)$
  ②乘法规则
  $T(n)=T_1(n)\times T_2(n)=O(f(n))\times O(g(n))=O(f(n\times g(n))$
  ！多项相乘，都保留
  例：$T(n)=n^2\cdot lo{g}_2^n\Rightarrow O(n^{2}lo{g}_2^n)$
  ！若同时含有加法和乘法，则要进行比较
  例：$T(n)=n^3+n^{2}lo{g}_2^n=n^2\cdot n+n^2\cdot nlo{g}_2^n$，而$O(lo{g}_2^n)<O(n)\Rightarrow O(n^3)$
  常见的几种时间复杂度的顺序为：
  $O(1)<O(lo{g}_2^n)<O(n)<O(nlo{g}_2^n)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)$
  几种常见的时间复杂度的相关曲线如图：
  
  推导(洛必达法则)：
  ①$O(lo{g}_2^n)<O(n)$ $$\underset{n\to \infty }{\lim }\frac{lo{g}_2^n}{n}\Rightarrow \underset{n\to \infty }{\lim }\frac{1}{n\cdot ln2}=0$$
  (当$n\to \infty$，$n$比$lo{g}_2^n$变大的速度快很多)
  ②$O(n^2)<O(2^n)$ $$\underset{n\to \infty }{\lim }\frac{n^2}{2^n}\Rightarrow \underset{n\to \infty }{\lim }\frac{2n}{2^n\cdot ln2}\Rightarrow \underset{n\to \infty }{\lim }\frac{2}{2^n\cdot l{n}^{2}2}=0$$

• 时间复杂度例题
  例①

void fun(int n){
int i=1;
while(i<=n)
	i=i*2;
}

！第1次循环：$i=2=2^1$；第2次循环：$i=4=2^2$；第3次循环：$i=8=2^3$…第t次循环：$i=2=2^t$，当$i>n$时循环结束。
$2^t\le n$，即$t\le lo{g}_2^n$。因此时间复杂度$T(n)=O(lo{g}_2^n)$。
例②

int fact(int n){
	if(n<=1) return 1;
	return n*fact(n-1);//求整数n(n大于等于0)的阶乘
}

！递归代码，每次递归调用时，fact()的参数减1，递归出口为fact(1)，一共执行n次递归调用。
因此时间复杂度$T(n)=O(n)。$
例③

count=0;
for(k=1;k<=n;k*=2)   
   for(j=1;j<=n;j++)     
      count++;

！外层循环参见例①，时间复杂度$T_1(n)=O(lo{g}_2^n)$，外层循环(1~n)共循环$n$次，时间复杂度$T_2(n)=O(n)$
乘法规则， $T(n)=T_1(n)\times T_2(n)=O(lo{g}_2^n)\times O(n)=O(nlo{g}_2^n)$
例④

int func(int n){
	int i=0,sum=0;
	while(sum<n) sum += ++i;
	return i;
}

！第1次循环：$sum=0+1=1$；第2次循环：$sum=1+2=3$；第3次循环：$sum=3+3=6$…第t次循环：$sum=0+1+2+\cdots +t$，当$sum\ge n$时循环结束。
$\frac{(0+t)(t+1)}{2}<n$，因此时间复杂度$T(n)=O(\sqrt{n})$。
例⑤

void fun(int n){
	int i=0;
	while(i*i*i<n){
		i++;
}

！第1次循环：判断$1^3<n?$；第2次循环：判断$2^3<n?$；第3次循环：判断$3^3<n?$…第t次循环：判断$t^3<n?$，当$t^3\ge n$时循环结束。
$t^3<n$，因此时间复杂度$T(n)=O(\sqrt[3]{n})$
例⑥

for(i=n-1;i>1;i--)
   for(j=1;j<i;j++)
      if(a[j]>a[j+1])
        a[j]与a[j+1]交换;
//其中n为整数，则最后一行语句的频度在最坏情况下是?

！最坏情况下为：每一次都进行交换
$$\begin{array}{rl}T(n)& =\sum _{i=2}^{n-1}\sum _{j=1}^{i-1}1\\ & =\sum _{i=2}^{n-1}(i-1)[累加上标-累加下标+1=(i-1)\bcancel{-1}\bcancel{+1}]\\ & =\frac{[1+(n-2)](n-2)}{2}(\frac{[首项+末项]\times 项数}{2})\\ & (首项将i=2带入，末项将n-1带入，项数为：累加上标-累加下标+1)\end{array}$$
因此时间复杂度$T(n)=O(n^2)$
例⑦

void fun(int n)
{	int s=0,i,j,k;
	for(i=0;i<=n;i++)
		for(j=0;j<=i;j++)
			for(k=0;k<j;k++)
				s++;
}

$$\begin{array}{rl}T(n)& =\sum _{i=0}^n\sum _{j=0}^i\sum _{k=0}^{j-1}1\\ & =\sum _{i=0}^n\sum _{j=0}^{i}j\\ & =\sum _{i=0}^n\frac{(0+i)\cdot (i+1)}{2}\\ & =\frac{1}{2}(\sum _{i=0}^n{i}^2+\sum _{i=0}^{n}i)\\ & =\frac{1}{2}(\frac{n(n+1)(n+2)}{6}+\frac{n(n+1)}{2})\\ & =\frac{2n^3+6n^2+4n}{12}\end{array}$$
因此时间复杂度$T(n)=O(n^3)$
例⑧

void fun(int n)
{	int i,j,k;
	for(i=0;i<n;i++) //语句①
		for(j=0;j<n;j++) //语句②
			{	c[i][j]=0; //语句③
					for(k=0;k<n;k++) //语句④
						c[i][j]=c[i][j]+a[i][k]*b[k][i]; //语句⑤
			}
}
//分析语句①~⑤的频度

！
语句①：循环控制变量i要从0增加到n，测试i=n时才会终止。故它的频度是n+1。
语句②：语句②作为语句①循环体内的语句应该只执行n次，但语句②本身也要执行n+1次(原因同语句①)。$$\sum _{i=0}^{n-1}(n+1)=n(n+1)$$
语句③： 语句③作为语句②循环体内的语句应该只执行n次，而语句③本身也要执行n次。$$\sum _{i=0}^{n-1}\sum _{j=0}^{n-1}1=n^2$$
语句④： $$\sum _{i=0}^{n-1}\sum _{j=0}^{n-1}(n+1)=n^3+n^2$$
语句⑤： $$\sum _{i=0}^{n-1}\sum _{j=0}^{n-1}\sum _{k=0}^{n-1}1=n^3$$

语句①的频度：$n+1$
语句②的频度：$n(n+1)$
语句③的频度：$n^2$
语句④的频度：$n^3+n^2$
语句⑤的频度：$n^3$