第一章 数据结构绪论
1.4 基本概念和术语
1.4.1 数据
数据：描述客观事物的符号，是计算机中可以操作的对象，是能被极端及识别，并输入给计算机处理的符号集合。
1.4.2 数据元素
数据元素：是组成数据的、有一定意义的基本单位，在计算机中通常作为整体处理（也叫记录）
1.4.3 数据项
数据项：一个数据元素可以由若干个数据项组成
数据项是数据不可分割的最小单位
1.4.4 数据对象
数据对象：是性质相同的数据元素的集合，是数据的子集。
1.4.5 数据结构
1）不同元素之间不是独立的，而是存在特定的关系，我将这些关系称为结构
2）数据结构：是相互之间存在一种或多种特定关系的数据元素的集合
1.5 逻辑结构和物理结构
1.5.1 逻辑结构
逻辑结构：指数据对象中数据元素之间的相互关系。分4种：
1）集合结构：同属于一个集合，没有其他的关系
2）线性结构：线性结构中的数据元素的一对一的关系
3）树形结构：数据元素存在一对多的层次关系
2）图形结构：数据元素的多对多的关系
1.5.2 物理结构
物理结构：值数据的逻辑结构在计算机中的存储形式。分2种：
1）顺序存储结构：把数据元素存放在连续的存储单元里，其数据间的逻辑关系和物理关系的一致的。
2）链式存储结构：把数据存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的
1.6 抽象数据类型
1.6.1 数据类型
数据类型：指一组性质相同的值的集合及定义在此集合上的一些操作的总称
C语言中，数据类型分两类：
1）原子类型：不可以再分割的，包括整型，实型，字符型
2）结构类型：由若干个类型组合而成，可以再分解。
抽象是指抽取出事物具有的普遍性的本质
1.6.2 抽象数据类型
抽象数据类型：指一个数学模型及定义在该模型上的一组操作
“抽象”的意义在于数据类型的数学抽象特性
抽象数据类型体现了程序设计中问题分解、抽象和信息隐藏的特性。
第二章 算法
定义：算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作
2.5 算法的特性
五个基本特性：输入、输出、有穷性，确定性、可行性
2.5.1 输入输出
算法具有零个或多个输入
算法具有一个或多个输出
2.5.2 有穷性
指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每个步骤可在可接受的时间内完成
2.5.3 确定性
算法的每一步骤都具有确定的含义，不会出现二义性。
2.5.4 可行性
算法的每一步都必须是可行的，每一步都能通过执行有限次数完成。
2.6 算法设计的要求
2.6.1 正确性
指算法至少应该具有输入、输出和加工的无歧义性，能正确反映问题的需求，能够得到问题的正确答案。
没有语法错误，对于合法输入能满足要求，对于非法输入和对于精心选择的刁难的测试数据都能满足要求。
2.6.2 可读性
算法设计的另一目的就是便于阅读、理解和交流
2.6.3 健壮性
当输入不合法时，算法也能做相应的处理，而不是产生莫名其妙的结果。
2.6.4 时间效率高 存储量低
尽量满足时间效率高和存储量低的要求
2.7 算法效率的度量方法
2.7.1 事后统计方法
通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率的高低。
有很大缺陷：费时费力，依赖软硬件、测试程序设计困难，一版不采纳
2.7.2 事先分析估算方法
指在计算机程序编制前，依照统计方法对算法进行估算。
一个程序的运行时间，依赖于算法的好坏和问题的输入规模（输入量的多少）
2.8 函数的渐进增长
判断一个算法的效率时，函数中的常数和其他次要项常常可以忽略，而应该关注主项的阶数（最高阶项）
2.9 算法时间复杂度
2.9.1 定义
语句执行总数T(n)是关于问题规模n的函数。进而分析T(n)随n的变化情况并确定T(n)的数量级。
也就是算法的时间量度，记作：T(n) = O(f(n));它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同。称作算法的渐进时间复杂度，简称时间复杂度。
其中f(n)是问题规模n的某个函数。
这样用大写O()来体现算法时间复杂度的记法，称为大O记法。
一般随着n的增大，T(n)增长最慢的算法称为最优算法
比如
O(n)，线性阶
O(1)，常数阶
O(n2)，平方阶
2.9.2 推导大O阶方法
如下：
1）用常数1取代运行时间中所有加法常数
2）在修改后的运行次数函数中，只保留最高阶项
3）若最高阶项存在且不是1，则去除这个像相乘的常数
2.9.3 常数阶
与n的大小无关，执行时间恒定的算法，我们称之为具有O(1)的时间复杂度。也叫常数阶
2.9.4 线性阶
随着n增大，执行次数线性增大。比如一个for循环。
要分析算法的复杂度，关键是要分析循环结构的运行情况
for(i = 0; i<n; i++ ){……}
2.9.5 对数阶
比如：
int count = 1;
while(count < n)
{
count = count * 2;
}
每次乘以2之后，就巨鹿n更近了一分。
也就是说有多少个2相乘大于n就会退出循环。2x=n，x=log2n;
所以这个循环的时间复杂度为O(logn)
2.9.6 平方阶
注意只需要计算最高阶就好了，两个for循环嵌套就是O(n2)。
如果两个for循环嵌套再加上一个嵌套的for循环，时间复杂度依然是 O(n2)。
2.10 常见的时间复杂度
O(n3) O(2n) O(n!) 过大的n会使得结果变得非常大。这样是不现实的，一般不去讨论它。
2.11 最坏情况与平均情况
最坏情况运行时间是一种保证，那就是运行时间将不会再坏了。在应用中，这是一种最重要的需求，通常，除非特别指定，我们提到的运行时间都是最坏情况的运行时间
平均运行时间是所有情况中最有意义的，因为它是期望的运行时间。
对时间复杂度的分析主要有上面两种，一般在没有特殊说明的情况下都是指最坏时间复杂度。
2.12 算法空间复杂度
算法的空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记作：S(n)=O(f(n))。n为问题的规模，f(n)为语句关于n所占存储空间的函数。
第三章 线性表
3.2 线性表的定义
线性表：零个或多个数据元素的有限序列
首先，是一个序列（元素之间是有顺序的），而且是有限的。
比如：a1,a2,a3……an-1,an。
ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素
n定义为线性表的长度，当n为0 的时候，称为空表
3.3 线性表的抽象数据类型
上面这些是最基本的一些操作，实际情况会复杂一点。
3.4 线性表的顺序存储结构
定义：指用一段地址连续的存储单元依次存储线性表的数据元素
3.4.2 顺序存储方式
可以用C语言的一维数组来实现顺序存储结构
顺序存储结构需要三个属性：
1）存储空间的起始位置：数组data，它的位置就是存储空间的存储位置
2）线性表的最大存储容量：数组长度
3）线性表的当前长度：
3.4.3 数据长度和线性表长度的区别
数组的长度是存放线性表的存储空间的长度，存储分配后一般就不变了。
线性表的长度是线性表中数据元素的个数，插入删除会影响这个值。
3.4.4 地址计算方法
存储器中每个存储单元都有自己的编号，这个编号称为地址。
3.5 顺序存储结构的插入与删除
3.5.1 获得元素操作
就是将线性表中的第i个位置元素值返回
3.5.2 插入操作
基本思路：
1）插入位置不合理，抛出异常
2）线性表长度大于等于数组长度，抛异常或者动态增加容量
3）从最后一个开始往前遍历，分别将它们向后挪一位。arr[i+1] = a[i];
4）将要插入元素填入位置i处
5）表长加1
3.5.3 删除操作
基本思路：
1）若位置不合理，抛异常
2）取出删除元素
3）从删除元素的位置到末尾，全部往前移动一个位置
4）表长减1
3.5.4 线性表顺序存储的优缺点
优点：速度快 无需为表示表中元素之间的逻辑关系增加额外的存储空间（链表需要next）
缺点：插入删除都需要移动大量元素 长度变化大时难以缺点存储空间 造成存储空间的碎片
3.6 线性表的链式存储结构
3.6.1 顺序存储结构不足的解决方法
让每个元素知道它下一个元素的位置
3.6.2 线性表链式存储结构定义
顺序结构中每个数据元素只要存数据元素信息就可以了。
链式结构还需要存储它的后继元素的地址。
存储数据元素信息的域称为数据域，存储后继位置的域称为指针域
链表中第一个节点的存储位置叫做头指针。
有时会在单链表的第一个节点前附设一个节点，称为头结点。头结点的数据域可以不存储任何信息。
3.6.3 头指针与头结点的异同
头指针：
1）头指针是链表指向第一个节点的指针。（若链表有头结点，则是指向头结点的指针）
2）头指针具有标识作用，座椅常用头指针冠以链表的名字
3）无论链表是否为空，头指针均不为空。头指针是链表的必要元素
头结点：
1）为了操作的同一个方便而设立的，放在第一元素的节点之前，其数据域一般无意义
2）有了头结点，对在第一元素节点前插入节点和删除第一节点，就跟对其他结点一样了
3）头结点不一定是链表必须要素。
头结点的指针域存储执行第一个节点的指针。我觉得这个指针就是头指针。
3.7 单链表的读取
获得链表第i个数据的算法思路：
1）声明一个节点p指向链表的第一个节点，初始化j从1 开始
2）j<i时就遍历链表，p向后移动，不断指向下一结点。j++
3）若到链表末尾p为空，则第i个元素不存在。
4）否则查找成功
3.8 单链表的插入与删除
注意插入和删除都需要找到对应位置的那个结点，这个很重要
3.8.1 单链表的插入
大概是这样子：
先将p的后继结点改成s的后继结点。再把s变成p的后继结点
s->next = p->next;
p->next = s;
3.8.2 单链表的删除
大概是这样子，假设需要删除q：
将p的后继结点指向q的后继结点，再把q的资源回收了。
p->next=q->next;
free(q);
对于插入或删除数据越频繁的操作，单链表的效率优势就越明显。
时间复杂度是O(1)。
顺序存储的则是O(n)
3.9 单链表的整表创建
基本思路：
1）声明一结点p和计数器变量i
2）初始化空链表L
3）L 的头结点的指针指向NULL（建立带头结点的单链表）
4）循环，就可以插入数据了
3.10 单链表的整体删除
思路：
1）声明结点p和q
2）将第一个节点赋给p
3）循环：将下一结点赋给q，释放q，将q赋给p。
Node *p = L->head;
Node *temp;
while(p)
{
q = p->next;
free(p);
p=q;
}
free(head);
3.11 单链表结构顺序存储和链式存储的优缺点
经验性结论：
1）需要频繁查找，很少插入删除。可以用顺序存储。
需要频繁插入删除，则用链式存储
2）对于未知元素个数，最好用单链表
3.12 静态链表
用数组描述的链表叫做静态链表。这种描述方法还被叫做游标实现法。
数组里的元素由两个数据域组成，data和next。也就是说数组的每个下标都对应一个data和一个next。
数据域data用来存放数据元素。
而游标next相当于单链表中的next指针。
以int为例：
结点是
struct Node
{
int data; // 数据域
int next; // 游标next，相当于next指针，指向下一个结点再数组的下标。
};
一个静态链表就是相当于一个结构体数组。
Node slink[1000];
这样对链表的操作就变成了移动游标了。
插入数据还是放在末尾，但是插入位置的那个结点的游标就要指向最后，要插入的结点的游标指向之前插入位置的那个结点指向的下一个。
注意：这个链表的通过游标排序的。
第一个结点的游标在数组的最后一个位置的next。
链表的最后一个节点的next为0；
数组的第一个存储空间存的是（当前数据个数+1）：若有1个数据，这里的next为2.
2个数据，则为3. 3个数据则为4。用来插入数据时找空间存放。
遍历是这样遍历的：
int count = 0；
int first = arr[MAXSIZE - 1];
while(first)
{
// printf arr[first].data;
first = arr[first].next; // 这里相当于往下移动
cout++; // 统计个数
}
插入操作：
假设在需要在链表的第i个位置插入（注意这里是链表的位置，而不是数组的下标）：
需要找到它前一个结点的next。
int k = MAXSIXE – 1; //这里是起点
for(int I = 1; I < index; I++)
{
k = arr[k].next;
}
找到了之后找位置存放新的结点，就是
j = arr[0].next;
更新
if(arr[0].next)
{
arr[0].next = arr[j].next;
}
这里插入数据
arr[j].data = inputdata;
arr[j].next = arr[k].next;
arr[k].next = j;
优点：插入删除时只需要修改游标，不需要移动元素。改进了顺序结构中插入删除需要大量移动元素的缺点
缺点：还是难以确定长度，失去了顺序存储结构随机存取的特性。
下面是一个双链表的例子：
http://www.cnblogs.com/xcywt/p/8039607.html