线性表-----数据结构和算法04

线性表（List）：由零个或多个数据元素组成的有限序列。

这里需要强调几个关键的地方：

首先它是一个序列，也就是说元素之间是有个先来后到的。

若元素存在多个，则第一个元素无前驱，而最后一个元素无后继，其他元素都有且只有一个前驱和后继。

另外，线性表强调是有限的，事实上无论计算机发展到多强大，它所处理的元素都是有限的。

如果用数学语言来进行定义，可如下：

若将线性表记为（a1,…,ai-1,ai,ai+1,…an）,则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素。

线性表的定义

所以线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。

定义线性表

抽象数据类型

数据类型：是指一组性质相同的值的集合及定义在此集合上的一些操作的总称。

例如很多编程语言的整型，浮点型，字符型这些指的就是数据类型。

当年那些设计计算机语言的人，为什么会考虑到数据类型呢？

比如，大家都需要住房子，也都希望房子越大越好。但显然，没有多少钱的话考虑房子是没啥意义的。

于是商品房就出现了各种各样的房型，有别墅的，有错层的，有单间的，甚至在北京还出现了胶囊公寓——只有两平方米的房间。

这样子就满足了大家的不同需求。

同样，在计算机中，内存也不是无限大的，你要计算入1+1=2这样的整型数字的加减乘除运算，显然不需要开辟很大的内存空间。

而如果要计算1.23456789+2.987654321这样带大量小数的，就需要开辟比较大的空间才存放的下。

于是计算机的研究者们就考虑，要对数据类型进行分类，分出多种数据类型来适合各种不同的计算条件差异。

例如在C语言中，按照取值的不同，数据类型可以分为两类：

原子类型：不可以再分解的基本类型，例如整型、浮点型、字符型等。

结构类型：由若干个类型组合而成，是可以再分解的，例如整型数组是由若干整型数据组成的。

抽象：是指抽取出事物具有的普遍性的本质。它要求抽出问题的特征而忽略非本质的细节，是对具体事物的一个概括。抽象是一种思考问题的方式，它隐藏了繁杂的细节。

我们对已有的数据类型进行抽象，就有了抽象数据类型。

抽象数据类型（Abstract Data Type，ADT）是指一个数学模型及定义在该模型上的一组操作。

抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。

比如1+1=2这样一个操作，在不同CPU的处理上可能不一样，但由于其定义的数学特性相同，所以在计算机编程者看来，它们都是相同的。

“抽象”的意义在于数据类型的数学抽象特性。

而且，抽象数据类型不仅仅指那些已经定义并实现的数据类型，还可以是计算机编程者在设计软件程序时自己定义的数据类型。。

抽象数据类型

为了便于在之后的讲解中对抽象数据类型进行规范的描述，我们给出了描述抽象数据类型的标准格式：

Source code ( By http://www.fishc.com )

ADT 抽象数据类型名
Data
    数据元素之间逻辑关系的定义
Operation
    操作
endADT

线性表的抽象数据类型

线性表的抽象数据类型定义：

Source code ( By http://www.fishc.com )

ADT 线性表（List）
 
Data
    线性表的数据对象集合为{a1,a2,…,an}，每个元素的类型均为DataType。
    其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。
    数据元素之间的关系是一对一的关系。
 
Operation
    InitList(*L): 初始化操作，建立一个空的线性表L。
    ListEmpty(L): 判断线性表是否为空表，若线性表为空，返回true，否则返回false。
    ClearList(*L): 将线性表清空。
    GetElem(L,i,*e): 将线性表L中的第i个位置元素值返回给e。
    LocateElem(L,e): 在线性表L中查找与给定值e相等的元素，如果查找成功，返回该元素在表中序号表示成功；否则，返回0表示失败。
    ListInsert(*L,i,e): 在线性表L中第i个位置插入新元素e。
    ListDelete(*L,i,*e): 删除线性表L中第i个位置元素，并用e返回其值。
    ListLength(L): 返回线性表L的元素个数。
 
endADT

对于不同的应用，线性表的基本操作是不同的，上述操作是最基本的。

对于实际问题中涉及的关于线性表的更复杂操作，完全可以用这些基本操作的组合来实现。

线性表，并集原理

其实仔细思考一下，我们只需要循环遍历集合B中的每个元素，判断当前元素是否存在A中，弱不存在，则插入A中即可。

综合分析，我们需要运用到几个基本的操作组合即可：

ListLength(L);

GetElem(L,i,*e);

LocateElem(L,e);

ListInsert(*L,i,e);

 

线性表的顺序存储结构

我们可以想象，线性表有两种物理存储结构：顺序存储结构和链式存储结构。

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。

线性表（a1,a2,…,an）的顺序存储如下：

线性表

上边的图片大家想到了什么？

是不是跟丫的数组一样一样的？！

物理上的存储方式事实上就是在内存中找个初始地址，然后通过占位的形式，把一定的内存空间给占了，然后把相同数据类型的数据元素依次放在这块空地中。

接下来看线性表顺序存储的结构代码：

Source code ( By http://www.fishc.com )

#define MAXSIZE 20    
 
typedef int ElemType;
 
typedef struct
{
    ElemType data[MAXSIZE];
    int length;    // 线性表当前长度
} SqList;

大家看到了，这里我们封装了一个结构，事实上就是对数组进行封装，增加了个当前长度的变量罢了。

总结下，顺序存储结构封装需要三个属性：

存储空间的起始位置，数组data，它的存储位置就是线性表存储空间的存储位置。

线性表的最大存储容量：数组的长度MaxSize。

线性表的当前长度：length。

注意，数组的长度与线性表的当前长度需要区分一下：

数组的长度是存放线性表的存储空间的总长度，一般初始化后不变。

而线性表的当前长度是线性表中元素的个数，是会变化的。

地址计算方法

线性表的定义充分考虑到很多军师级别领导的智商指数，所以决定从1开始回归正常思维。

假设ElemType占用的是c个存储单元（字节），那么线性表中第i+1个数据元素和第i个数据元素的存储位置的关系是（LOC表示获得存储位置的函数）：LOC(ai+1) = LOC(ai) + c

所以对于第i个数据元素ai的存储位置可以由a1推算得出：LOC(ai) = LOC(a1) + (i-1)*c

结合下图来理解：

线性表

通过这个公式，我们可以随时计算出线性表中任意位置的地址，不管它是第一个还是最后一个，都是相同的时间。

那么它的存储时间性能当然就为O(1)，我们通常称为随机存储结构。

获得元素操作

实现GetElem的具体操作，即将线性表L中的第i个位置元素值返回。

就程序而言非常简单了，我们只需要把数组第i-1下标的值返回即可。

插入操作

刚才我们也谈到，线性表的顺序存储结构具有随机存储结构的特点，时间复杂度为O(1)。

大家现在来考虑下，如果我们要实现ListInsert(*L, i, e)，即在线性表L中的第i个位置插入新元素e，代码应该如何写？

所以插入算法的思路：

如果插入位置不合理，抛出异常；

如果线性表长度大于等于数组长度，则抛出异常或动态增加数组容量；

从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置；

将要插入元素填入位置i处；

线性表长+1。

删除操作

删除算法的思路：

如果删除位置不合理，抛出异常；

取出删除元素；

从删除元素位置开始遍历到最后一个元素位置，分别将它们都向前移动一个位置；

表长-1。

现在我们分析一下，插入和删除的时间复杂度。

最好的情况：插入和删除操作刚好要求在最后一个位置操作，因为不需要移动任何元素，所以此时的时间复杂度为O(1)。

最坏的情况：如果要插入和删除的位置是第一个元素，那就意味着要移动所有的元素向后或者向前，所以这个时间复杂度为O(n)。

至于平均情况，就取中间值O((n-1)/2)。

线性表顺序存储结构的优缺点

线性表的顺序存储结构，在存、读数据时，不管是哪个位置，时间复杂度都是O(1)。而在插入或删除时，时间复杂度都是O(n)。

这就说明，它比较适合元素个数比较稳定，不经常插入和删除元素，而更多的操作是存取数据的应用。

那我们接下来给大家简单总结下线性表的顺序存储结构的优缺点：

优点：

无须为表示表中元素之间的逻辑关系而增加额外的存储空间。

可以快速地存取表中任意位置的元素。

缺点：

插入和删除操作需要移动大量元素。

当线性表长度变化较大时，难以确定存储空间的容量。

容易造成存储空间的“碎片”。

线性表的链式存储结构

前面我们讲的线性表的顺序存储结构，它最大的缺点就是插入和删除时需要移动大量元素，这显然就需要耗费时间。

那我们能不能针对这个缺陷或者说遗憾提出解决的方法呢？要解决这个问题，我们就得考虑一下导致这个问题的原因！

为什么当插入和删除时，就要移动大量的元素？

线性表链式存储结构定义

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以存在内存中未被占用的任意位置。

比起顺序存储结构每个数据元素只需要存储一个位置就可以了。

单链表

现在链式存储结构中，除了要存储数据元素信息外，还要存储它的后继元素的存储地址（指针）。

也就是说除了存储其本身的信息外，还需存储一个指示其直接后继的存储位置的信息。

我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。

指针域中存储的信息称为指针或链。

这两部分信息组成数据元素称为存储映像，称为结点(Node)。

n个结点链接成一个链表，即为线性表(a1, a2, a3, …, an)的链式存储结构。

因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

线性表的链式存储结构

对于线性表来说，总得有个头有个尾，链表也不例外。

我们把链表中的第一个结点的存储位置叫做头指针，最后一个结点指针为空(NULL)。

线性表的链式存储结构

头指针与头结点的异同

上节课我们提到了，头结点的数据域一般不存储任何信息，谁叫它是第一个呢，有这个特权。

拿个小旗子即可：

头指针与头结点的异同

那有童鞋就疑惑了，既然头结点的数据域不存储任何信息，那么头指针和头结点又有何异同呢？

头指针

头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。

头指针具有标识作用，所以常用头指针冠以链表的名字（指针变量的名字）。

无论链表是否为空，头指针均不为空。

头指针是链表的必要元素。

头结点

头结点是为了操作的统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义（但也可以用来存放链表的长度）。

有了头结点，对在第一元素结点前插入结点和删除第一结点起操作与其它结点的操作就统一了。

头结点不一定是链表的必须要素。

单链表存储结构

单链表图例：

空链表图例：

我们在C语言中可以用结构指针来描述单链表：

Source code ( By http://www.fishc.com )

typedef struct Node
{
    ElemType data;      // 数据域
    struct Node* Next;  // 指针域
} Node;
typedef struct Node* LinkList;

我们看到结点由存放数据元素的数据域和存放后继结点地址的指针域组成。

假设p是指向线性表第i个元素的指针，则该结点ai的数据域我们可以用p->data的值是一个数据元素。

结点ai的指针域可以用p->next来表示，p->next的值是一个指针。

那么p->next指向谁呢？当然指向第i+1个元素！也就是指向ai+1的指针。

问题：如果p->data = ai，那么p->next->data = ?

答案：p->next->data = ai+1。

单链表的读取

在线性表的顺序存储结构中，我们要计算任意一个元素的存储位置是很容易的。

但在单链表中，由于第i个元素到底在哪？我们压根儿没办法一开始就知道，必须得从第一个结点开始挨个儿找。

因此，对于单链表实现获取第i个元素的数据的操作GetElem，在算法上相对要麻烦一些，大家不妨先思考一下。

获得链表第i个数据的算法思路：

声明一个结点p指向链表第一个结点，初始化j从1开始；

当j<i时，就遍历链表，让p的指针向后移动，不断指向一下结点，j+1；

若到链表末尾p为空，则说明第i个元素不存在；

否则查找成功，返回结点p的数据。

单链表的插入

我们先来看下单链表的插入。假设存储元素e的结点为s，要实现结点p、p->next和s之间逻辑关系的变化，大家参考下图思考一下：

单链表的插入

我们思考后发觉根本用不着惊动其他结点，只需要让s->next和p->next的指针做一点改变。

s->next = p->next;

p->next = s;

我们通过图片来解读一下这两句代码。

那么我们考虑一下大部分初学者最容易搞坏脑子的问题：这两句代码的顺序可不可以交换过来？

先 p->next = s;

再 s->next = p->next;

大家发现没有？如果先执行p->next的话会先被覆盖为s的地址，那么s->next = p->next其实就等于s->next = s了。

所以这两句是无论如何不能弄反的，这点初学者一定要注意咯~

单链表第i个数据插入结点的算法思路：

声明一结点p指向链表头结点，初始化j从1开始；

当j<1时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1；

若到链表末尾p为空，则说明第i个元素不存在；

否则查找成功，在系统中生成一个空结点s；

将数据元素e赋值给s->data；

单链表的插入刚才两个标准语句；

返回成功。

单链表的删除

现在我们再来看单链表的删除操作。

假设元素a2的结点为q，要实现结点q删除单链表的操作，其实就是将它的前继结点的指针绕过指向后继结点即可。

那我们所要做的，实际上就是一步：

可以这样：p->next = p->next->next;

也可以是：q=p->next; p->next=q->next;

单链表第i个数据删除结点的算法思路：

声明结点p指向链表第一个结点，初始化j=1；

当j<1时，就遍历链表，让P的指针向后移动，不断指向下一个结点，j累加1；

若到链表末尾p为空，则说明第i个元素不存在；

否则查找成功，将欲删除结点p->next赋值给q；

单链表的删除标准语句p->next = q->next；

将q结点中的数据赋值给e，作为返回；

释放q结点。

效率PK

我们最后的环节是效率PK，我们发现无论是单链表插入还是删除算法，它们其实都是由两个部分组成：第一部分就是遍历查找第i个元素，第二部分就是实现插入和删除元素。

从整个算法来说，我们很容易可以推出它们的时间复杂度都是O(n)。

再详细点分析：如果在我们不知道第i个元素的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构是没有太大优势的。

但如果，我们希望从第i个位置开始，插入连续10个元素，对于顺序存储结构意味着，每一次插入都需要移动n-i个位置，所以每次都是O(n)。

而单链表，我们只需要在第一次时，找到第i个位置的指针，此时为O(n)，接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。

显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显啦~

单链表的整表创建

对于顺序存储结构的线性表的整表创建，我们可以用数组的初始化来直观理解。

而单链表和顺序存储结构就不一样了，它不像顺序存储结构数据这么集中，它的数据可以是分散在内存各个角落的，他的增长也是动态的。

对于每个链表来说，它所占用空间的大小和位置是不需要预先分配划定的，可以根据系统的情况和实际的需求即时生成。

创建单链表的过程是一个动态生成链表的过程，从“空表”的初始状态起，依次建立各元素结点并逐个插入链表。

所以单链表整表创建的算法思路如下：

声明一结点p和计数器变量i；

初始化一空链表L；

让L的头结点的指针指向NULL，即建立一个带头结点的单链表；

循环实现后继结点的赋值和插入。

头插法建立单链表

头插法从一个空表开始，生成新结点，读取数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头上，直到结束为止。

简单来说，就是把新加进的元素放在表头后的第一个位置：

先让新节点的next指向头节点之后

然后让表头的next指向新节点

嗯，用现实环境模拟的话就是插队的方法，始终让新结点插在第一的位置。

尾插法建立单链表

头插法建立链表虽然算法简单，但生成的链表中结点的次序和输入的顺序相反。

就像现实社会我们鄙视插队不遵守纪律的孩子，那编程中我们也可以不这么干，我们可以把思维逆过来：把新结点都插入到最后，这种算法称之为尾插法。

单链表的整表删除

当我们不打算使用这个单链表时，我们需要把它销毁

其实也就是在内存中将它释放掉，以便于留出空间给其他程序或软件使用。

单链表整表删除的算法思路如下：

声明结点p和q；

将第一个结点赋值给p，下一结点赋值给q；

循环执行释放p和将q赋值给p的操作；

单链表结构与顺序存储结构优缺点

我们分别从存储分配方式、时间性能、空间性能三方面来做对比。

存储分配方式：

顺序存储结构用一段连续的存储单元依次存储线性表的数据元素。

单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。

时间性能：

查找

顺序存储结构O(1)

单链表O(n)

插入和删除

顺序存储结构需要平均移动表长一半的元素，时间为O(n)

单链表在计算出某位置的指针后，插入和删除时间仅为O(1)

空间性能：

顺序存储结构需要预分配存储空间，分大了，容易造成空间浪费，分小了，容易发生溢出。

单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制。

综上所述对比，我们得出一些经验性的结论：

若线性表需要频繁查找，很少进行插入和删除操作时，宜采用顺序存储结构。

若需要频繁插入和删除时，宜采用单链表结构。

比如说游戏开发中，对于用户注册的个人信息，除了注册时插入数据外，绝大多数情况都是读取，所以应该考虑用顺序存储结构。

而游戏中的玩家的武器或者装备列表，随着玩家的游戏过程中，可能会随时增加或删除，此时再用顺序存储就不太合适了，单链表结构就可以大展拳脚了。

当线性表中的元素个数变化较大或者根本不知道有多大时，最好用单链表结构，这样可以不需要考虑存储空间的大小问题。

而如果事先知道线性表的大致长度，比如一年12个月，一周就是星期一至星期日共七天，这种用顺序存储结构效率会高很多。

 

总之，线性表的顺序存储结构和单链表结构各有其优缺点，不能简单的说哪个好，哪个不好，需要根据实际情况，来综合平衡采用哪种数据结构更能满足和达到需求和性能。