数据结构第2章
抽象数据类型定义 ：
ADT LinearList{
数据元素：D={ai| ai∈D0, i=1,2,…，n n≥0 ，D0为某一数据对象} 关系：Ｓ＝｛<ai,ai+1> | ai, ai+1∈D0，i=1,2, …,n-1｝ 基本操作：
（1）InitList（L） （2）DestroyList(L) （3）ClearList(L)
{ LC->elem[k]= LB->elem[j]; j++; k++; }
LC->last=LA->last+LB->last;
21
}
2019/8/31
顺序存储结构的优点和缺点
优点：
1.无需为表示结点间的逻辑关系而增加额外的存储空间；
2.可方便地随机存取表中的任一元素。
缺点：
1.插入或删除运算不方便，除表尾的位置外，在表的其 它位置上进行插入或删除操作都必须移动大量的结 点，其效率较低；
if(L->last>=maxsize-1)
{ printf(“表已满无法插入”)； return(ERROR); } for(k=L->last;k>=i-1;k--) /*为插入元素而移动位置*/
L->elem[k+1]=L->elem[k];
L->elem[i-1]=e; /*在C语言中数组第i个元素的下标为i-1*/
1. 按序号查找GetData(L,i)：要求查找线性表L中第i 个数据元素，其结果是L.elem[i-1]或L->elem[i-1]。
2. 按内容查找Locate（L,e）: 要求查找线性表L中与 给定值e相等的数据元素，其结果是：若在表L中找 到与e相等的元素，则返回该元素在表中的序号；若 找不到，则返回一个“空序号”，如-1。
else
{
LC->elem[k]=LB->elem[j]; j++; k++; }
while(i<=LA->last) /*当表LA长则将表LA余下的元素赋给表LC*/
{ LC->elem[k]= LA->elem[i]; i++; k++; }
while(j<=LB->last) /*当表LB长则将表LB余下的元素赋给表LC*/
loc(ai) =loc(a1)+(i-1)×k
8
2019/8/31
顺序存储结构示意图
存储地址
Loc(a1) Loc(a1)+(2-1)k
…
loc(a1)+(i-1)k
…
loc(a1)+(n-1)k
...
loc(a1)+(maxlen-1)k
内存空间状态
a1 a2
…
ai
…
an
9
逻辑地址
1 2
…
i
…
n
空闲
2019/8/31
顺序存储结构的C语言定义
#define maxsize=线性表可能达到的最大长度； typedef struct {
ElemType elem[maxsize]； /* 线性表占用的数组空间*/ int last； /*记录线性表中最后一个元素在数组elem[ ]
中的位置（下标值），空表置为-1*/ } SeqList；
D B C H F A G E
指针域
43 13
1 NULL 37
7 19 25
26
2019/8/31
带头结点的单链表示意图
有时为了操作的方便，还可以在单链表的第一个 结点之前附设一个头结点。
带头结点的空单链表
H
∧
带头结点的单链表
H
a1
a2
…
an ∧
27
2019/8/31
单链表的存储结构描述
循环链表和双链表。
23
2019/8/31
链表
2.3.1 单链表 2.3.2 单链表上的基本运算 2.3.3 循环链表 2.3.4 双向链表 *2.3.5 静态链表 2.3.6 顺序表和链表的比较
24
2019/8/31
2.3.1 单链表
结点（Node）为了正确地表示结点间的逻辑关系，必 须在存储线性表的每个数据元素值的同时，存储指示 其后继结点的地址（或位置）信息，这两部分信息组 成的存储映象叫做结点（Node）。
线性表的定义
线性表(Linear List)是由n (n≥0)个类型相同的 数据元 素 a1,a2,…，an组成 的有限 序 列 ，记做 （a1,a2,…，ai-1，ai，ai+1， …，an）。 数据元素之间是一对一的关系，即每个数据 元素最多有一个直接前驱和一个直接后继。 线性表的逻辑结构图为：
L->last++;
return(OK);
}
16
2019/8/31
删除操作
线性表的删除运算是指将表的第i(1≤i≤n)个 元素删去，使长度为n的线性表 (e1，…,ei-1，ei， ei+1，…，en)，变成长度为n-1的线性表 (e1，…,ei-1， ei+1，…，en)。 算法思路示意 算法实现
c1 ∧
7
2019/8/31
顺序存储结构的定义
线性表的顺序存储是指用一组地址连续的存 储单元依次存储线性表中的各个元素，使得线性 表中在逻辑结构上相邻的数据元素存储在相邻的 物理存储单元中，即通过数据元素物理存储的相 邻关系来反映数据元素之间逻辑上的相邻关系。 采用顺序存储结构的线性表通常称为顺序表。
假设线性表中每个元素占k个单元，第一个元素 的地址为loc(a1)，则第k个元素的地址为：
2.由于顺序表要求占用连续的存储空间，存储分配只能 预先进行静态分配。因此当表长变化较大时，难以 确定合适的存储规模。
22
2019/8/31
2.3 线性表的链式存储
链表定义： 采用链式存储结构的线性表称为链表 。
现在我们从两个角度来讨论链表： 1.从实现角度看，链表可分为动态链表和静态
链表； 2.从链接方式的角度看，链表可分为单链表、
4 9 15 28 30 30 42 51 62
移动元素 4 9 15
28 30 30 42 51 62
插入元素 4 9 15 21 28 30 30 42 51 62
15
2019/8/31
插入运算
int InsList(SeqList *L,int i,ElemType e)
{ int k;
if( (i<1) || (i>L->last+2) ) /*首先判断插入位置是否合法*/ { printf(“插入位置i值不合法”)；return(ERROR); }
if (i<=st) return(i); /*若找到值为e的元素，则返回其序号*/
else return(-1); /*若没找到，则返回空序号*/
}
13
2019/8/31
插入操作
线性表的插入运算是指在表的第i (1≤i≤n+1) 个位置，插入一个新元素e，使长度为n的线性表 (e1，…，ei-1，ei，…，en) 变成长度为n+1的线 性表（e1，…,ei-1，e，ei，…，en）。
线性表的查找运算算法描述为：
12
2019/8/31
线性表的查找运算
int Locate(SeqList L，ElemType e) { i=0 ; /*i为扫描计数器，初值为0，即从第一个元素开始比较*/
while ((i<=st)&&(L.elem[i]!=e) ) i++; /*顺序扫描表，直到找到值为key的元素,或扫描到表尾而没找到*/
for(k=i;i<=L->last;k++)
L->elem[k-1]= L->elem[k]; /*将后面的元素依次前移*/
L->last--;
return(OK);
}
19
2019/8/31
合并算法
已知 ：有两个顺序表LA和LB，其元素均为非递减有序排列，编写 一个算法，将它们合并成一个顺序表LC，要求LC也是非递减有序 排列。
注意区分元素的序号和数组的下标，如a1的序号为1，而 其对应的数组下标为0。
10
2019/8/31
2.2.2 线性表顺序存储结构的基本运算
线性表的基本运算：
1. 查找操作 2. 插入操作 3. 删除操作 4. 顺序表合并算法
线性表顺序存储结构的优缺点分析
11
2019/8/31
查找操作
线性表的两种基本查找运算
线性表的插入运算算法。
14
2019/8/31
插入算法示意图
已知：线性表 (4,9,15,28,30,30,42,51,62)，需在第4个元素之前插 入一个元素“21”。则需要将第9个位置到第4个位置的元素依次后 移一个位置，然后将“21”插入到第4个位置，
序号 1 2 3 4 5 6 7 8 9 10
算法思想 ：设表LC是一个空表，为使LC也是非递减有序排列，可 设两个指针i、j分别指向表LA和LB中的元素，若 LA.elem[i]>LB.elem[j]，则当前先将LB.elem[j]插入到表LC中，若 LA.elem[i]≤LB.elem[j] ，当前先将LA.elem[i]插入到表LC中，如此 进行下去，直到其中一个表被扫描完毕，然后再将未扫描完的表中 剩余的所有元素放到表LC中。
算法应用示例：
1. 求单链表的长度 2. 求两个集合的差
数据结构第二章课后答案
数据结构第二章课后答案数据结构第二章课后答案1. 线性表1.1 数组实现线性表Q1. 请说明线性表的定义，并结合数组实现线性表的特点进行解释。
线性表是由n(n≥0)个数据元素构成的有序序列，其中n表示线性表的长度。
数组实现线性表的特点是使用一组具有相同数据类型的连续存储空间存储线性表中的元素，通过下标访问和操作元素。
A1. 线性表的定义指出，线性表是由若干个数据元素组成的有序序列。
具体地，在数组实现线性表中，我们将元素存储在一组连续的内存空间中，通过下标访问和操作元素。
由于数组的存储空间具有连续性，这样的实现方式可以在O(1)的时间复杂度下进行元素的访问和修改操作。
1.2 链表实现线性表Q2. 请说明链表实现线性表的特点，并与数组实现进行比较。
链表实现线性表的特点是通过指针将线性表中的元素按照节点的形式连接起来，每个节点包含了存储的元素和指向下一个节点的指针。
与数组实现相比，链表的插入和删除操作更为高效，但是访问某个位置的元素需要从头开始遍历，时间复杂度较大。
A2. 链表实现线性表的特点是通过使用节点和指针将线性表中的元素连接起来。
每个节点中包含了一个存储的元素和指向下一个节点的指针。
链表的插入和删除操作的时间复杂度为O(1)，因为只需要改变指针的指向即可。
但是，访问某个位置的元素需要从头开始遍历链表，所以时间复杂度为O(n)。
2. 栈和队列2.1 栈的定义和基本操作Q3. 请给出栈的定义和基本操作。
栈是一种特殊的线性表，它只能在表的一端进行插入和删除操作，该端称为栈顶。
栈的基本操作包括入栈(push)和出栈(pop)，分别用于将元素压入栈和将栈顶元素弹出。
A3. 栈是一种特殊的线性表，它只能在表的一端进行插入和删除操作。
这个特定的一端称为栈顶，而另一端称为栈底。
栈的基本操作包括入栈(push)和出栈(pop)。
入栈操作将一个元素压入栈顶，出栈操作将栈顶元素弹出。
2.2 队列的定义和基本操作Q4. 请给出队列的定义和基本操作。
数据结构--第二章考试题库(含答案)
第2章线性表一选择题1．下述哪一条是顺序存储结构的优点？（）【北方交通大学 2001 一、4（2分）】A．存储密度大 B．插入运算方便 C．删除运算方便 D．可方便地用于各种逻辑结构的存储表示2．下面关于线性表的叙述中，错误的是哪一个？（）【北方交通大学 2001 一、14（2分）】A．线性表采用顺序存储，必须占用一片连续的存储单元。
B．线性表采用顺序存储，便于进行插入和删除操作。
C．线性表采用链接存储，不必占用一片连续的存储单元。
D．线性表采用链接存储，便于插入和删除操作。
3．线性表是具有n个（）的有限序列（n>0）。
【清华大学 1998 一、4（2分）】A．表元素 B．字符 C．数据元素 D．数据项 E．信息项4．若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（）存储方式最节省时间。
【哈尔滨工业大学 2001二、1（2分）】A．顺序表 B．双链表 C．带头结点的双循环链表 D．单循环链表5．某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用（）存储方式最节省运算时间。
【南开大学 2000 一、3】A．单链表 B．仅有头指针的单循环链表 C．双链表 D．仅有尾指针的单循环链表6．设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用( )最节省时间。
A. 单链表B.单循环链表C. 带尾指针的单循环链表D.带头结点的双循环链表【合肥工业大学 2000 一、1（2分）】7．若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。
则采用（）存储方式最节省运算时间。
【北京理工大学 2000一、1（2分）】A．单链表 B．双链表 C．单循环链表 D．带头结点的双循环链表8. 静态链表中指针表示的是（）. 【北京理工大学 2001 六、2（2分）】A．内存地址 B．数组下标 C．下一元素地址 D．左、右孩子地址9. 链表不具有的特点是（）【福州大学 1998 一、8 (2分)】A．插入、删除不需要移动元素 B．可随机访问任一元素C．不必事先估计存储空间 D．所需空间与线性长度成正比10. 下面的叙述不正确的是（）【南京理工大学 1996 一、10（2分）】A．线性表在链式存储时，查找第i个元素的时间同i的值成正比B. 线性表在链式存储时，查找第i个元素的时间同i的值无关C. 线性表在顺序存储时，查找第i个元素的时间同i 的值成正比D. 线性表在顺序存储时，查找第i个元素的时间同i的值无关11. 线性表的表元存储方式有(（1）)和链接两种。
数据结构第二章习题(1)
B. 单链表
C. 双链表
D. 单循环链表
3.具有线性结构的数据结构是（ ）。
A. 图
B. 树
C. 广义表
D. 栈
4.在一个长度为 n 的顺序表中，在第 i 个元素之前插入一个新元素时，需向后移动（ ）
个元素。
A. n-i
B. n-i+1
C. n-i-1
5.非空的循环单链表 head 的尾结点 p 满足（ ）。
A. n-i
B. n-i+1
C. n-i-1
D. i+1
10.线性表是n个（ ）的有限序列。
A. 表元素
B. 字符 C. 数据元素 D. 数据项
11.从表中任一结点出发，都能扫描整个表的是（ ）。
A. 单链表
B. 顺序表
C. 循环链表
D. 静态链表
12.在具有n个结点的单链表上查找值为x的元素时，其时间复杂度为（ ）。
A. q->next=s->next；s->next=p； B. s->next=p；q->next=s->next；
C. p->next=s->next；s->next=q； D. s->next=q；p->next=s->next； 24.在以下的叙述中，正确的是（ ）。
A. 线性表的顺序存储结构优于链表存储结构 B. 线性表的顺序存储结构适用于频繁插入/删除数据元素的情况
A. p->next=p->next->next;
B. p=p->next;p->next=p->next->next;
C. p =p->next;
数据结构李春葆 第2章 线性表
2.2.1 线性表的顺序存储—顺序表
线性表的顺序存储结构：把线性表中的所有元素按照 其逻辑顺序依次存储到从计算机存储器中指定存储位臵开 始的一块连续的存储空间中。 这样,线性表中第一个元素的存储位臵就是指定的存储 位臵，第i+1个元素（1≤i≤n-1）的存储位臵紧接在第i个元 素的存储位臵的后面。 线性表 逻辑结构 顺序表 存储结构
回true，否则返回false。
bool ListEmpty(SqList *L) {
return(L->length==0);
}
本算法的时间复杂度为O(1)。
（4）求线性表的长度ListLength(L)
该运算返回顺序表 L 的长度。实际上只需返回 length成员 的值即可。
int ListLength(SqList *L)
（ 3 ）判线性表是否为空表 ListEmpty(L) ：若 L 为空表， 则返回真，否则返回假。 （ 4 ）求线性表的长度 ListLength(L) ：返回 L 中元素个数。 （ 5）输出线性表 DispList(L): 当线性表 L不为空时，顺序 显示L中各节点的值域。 （6）求线性表L中指定位臵的某个数据元素 GetElem(L,i,&e) ：用 e 返回 L 中第 i （ 1≤i≤ListLength(L) ）个 元素的值。
void unionList(List LA,List LB,List &LC) { int lena,i; ElemType e; InitList(LC); for (i=1;i<=ListLength(LA);i++) //将LA的所有元素插入到Lc中 { GetElem(LA,i,e); ListInsert(LC,i,e); } lena=ListLength(LA); //求线性表LA的长度 for (i=1;i<=ListLength(LB);i++) { GetElem(LB,i,e); //取LB中第i个数据元素赋给e if (!LocateElem(LA,e)) //LA中不存在和e相同者,插入到LC中 ListInsert(LC,++lena,e); } }
吉林大学数据结构_第二章 线性表
如何找指定位置的结点？
• 与顺序表不同，单链表无法直接访问指定 位置的结点，而是需要从哨位结点开始， 沿着next指针逐个结点计数，直至到达指定 位置。
操作
• • • • 存取 查找 删除 插入
存取算法
算法Find(k.item) /*将链表中第k个结点的字段值赋给item*/ F1. [k合法？] IF (k<1) THEN (PRINT “存取位置不合法”. RETURN.) F2. [初始化] p←head. i ←0. F3. [找第k个结点] WHILE (p ≠NULL AND i<k) DO (p←next(p). i ←i+1.) IF p=NULL THEN (PRINT “无此结点”. RETURN. ) item←data(p). ▍ 存取算法的时间复杂性分析。P30
插入算法
算法Insert(k,item) /*在链表中第k个结点后插入字段值为item的结点*/ I1.[k合法？] IF (k<0) THEN (PRINT “插入不合法”. RETURN) I2.[初始化] p←head. i ←0. I3.[p指向第k个结点] WHILE (p ≠NULL AND i<k) DO (p←next(p). i ←i+1.) IF p=NULL THEN (PRINT “插入不合法”. RETURN. ) I4.[插入] s<= AVAIL. data(s) ←item. next(s) ←next(p). next(p) ←s. ▍
删除算法
算法Delete(k.item) /*删除链表中第k个结点并将其字段值赋给item*/ D1.[k合法？] IF (k<1) THEN (PRINT “删除不合法”. RETURN.) D2.[初始化] p←head. i ←0. D3.[找第k-1结点] WHILE (p ≠NULL AND i<k-1) DO (p←next(p). i ←i+1.) IF p=NULL THEN (PRINT “无此结点”. RETURN. ) D4.[删除] q ← next(p). next(p) ← next(q) . item←data(q). AVAIL<=q.▍
《数据结构》课程课件第二章线性表
Step2：数据域赋值
插入后： Step3：插入（连接）
X q
(1)式和(2)式的顺序颠倒，可以吗？
4、插入元素（在第i个元素之前插入元素e）
为什么时间复杂度不再是O(1)？
第i－1个元素
第i个元素
p
s
新插入元素
5、删除p所指元素的后继元素
P
删除前：
P->next P->next->next
删除：
五、线性表ADT的应用举例
Void mergelist(list La，list Lb,list &Lc)
{ //已知线性表La和Lb中的数据元素按值非递减排列
//归并La和Lb得到新的线性表Lc，Lc中的元素也按值非递减排列
例: 将两个各有n个元素的有序表归并成一个有序表， 其最小的比较次数是（ ）。 A、n B、2n-1 C、2n D、n-1
三、线性表的ADT
四、线性表的分类
五、线性表ADT的应用举例
例1：已知有线性表L，要求删除所有X的出现
五、线性表ADT的应用举例
例2: 已知有两个分别有序的线性表（从小到大），要 求合并两个线性表，且合并后仍然有序。——归并 方法1: 合并，再排序O((m+n)2)
方法2： 归并，利用分别有序的特点O((m+n))
二、线性表上常见的运算
8、删除 Delete(L,i):删除线性表的第i个元素 删除前 a1 a2 … ai-1 ai ai+1 … an 删除后 a1 a2 … ai-1 ai+1 … an 9、判断是否为空 Empty(L):线性表空,则返回TRUE, 否则FALSE 10、输出线性表 Print(L):输出线性表的各个元素 11、其它操作 复制、分解、合并、分类等
数据结构第二章作业及答案
8
解答(续):
(2) 插入操作基本步骤: 1) 若i不合法或表L已满，算法结束并返回 ERROR；否则转2) 2) 将第i个元素及之后的所有元素均后移一个位置 3) 将新元素写入空出的位置； 4) 表长+1
9
解答(续):
插入操作算法(算法2.4 )：
Status ListInsert_Sq(SqList &L, int i , ElemType e) { //在顺序线性表L中第i个位置之前插入新的元素e, // i的合法值为1≤i≤ListLength_Sq(L)+1 if (i<1||i>L.length+1)return ERROR; //i值不合法 if (L.length>=L.listsize) { //当前存储空间已满，重新分配空间 newbase=(ElemType*)realloc(L. elem, (L.listsize+LISTINCREMENT)*sizeof (ElemType)); if (!newbase)exit(OVERFLOW); //存储分配失败 L. elem=newbase; //新基址 L.listsize+=LISTINCREMENT; //增加存储容量 } q=&(L.elem[i-1]); //q为插入位置 for (p=&(L. elem[L.length-1]); p>=q ; --p) *(p+1) = *p; //插入位置及之后的元素右移 *q=e; //插入e ++L.length; //表长增1 return OK; }//ListInsert_Sq
15
4．若某线性表最常用的操作是存取任一指定序号的元素和在最 后进行插入和删除运算，则利用（ ）存储方式最节省时间。 A．顺序表 B．双向链表 C．带头结点的双向循环链表 1 D．循环链表
数据结构第2章典型例题解析
第2章线性表典型例题解析一、选择题1．线性表是具有n个（n≥0）的有限序列。
A．表元素B．字符C．数据元素D．数据项【分析】线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列,通常记为（a1,a2，…，a n），其中n为表长，n=0时称为空表.【答案】C2．顺序存储结构的优点是.A．存储密度大B．插入运算方便C．删除运算方便D．可方便地用于各种逻辑结构的存储表示【分析】顺序存储结构是采用一组地址连续的存储单元来依次存放数据元素，数据元素的逻辑顺序和物理次序一致。
因此,其存储密度大。
【答案】A3．带头结点的单链表head为空的判断条件是.A．head==NULL B．head—〉next==NULLC．head->next==head D．head!=NULL【分析】链表为空时，头结点的指针域为空。
【答案】B4．若某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素,则采用存储方式最节省运算时间。
A．单链表B．仅有头指针的单循环链表C．双链表D．仅有尾指针的单循环链表【分析】根据题意要求，该线性表的存储应能够很方便地找到线性表的第一个元素和最后一个元素，A和B都能很方便地通过头指针找到线性表的第一个元素，却要经过所有元素才能找到最后一个元素；选项C双链表若存为双向循环链表，则能很方便地找到线性表的第一个元素和最后一个元素，但存储效率要低些，插入和删除操作也略微复杂；选项D可通过尾指针直接找到线性表的最后一个元素，通过线性表的最后一个元素的循环指针就能很方便地找到第一个元素。
【答案】D5．若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用存储方式最节省时间。
A．顺序表B．双链表C．带头结点的双循环链表D．单循环链表【分析】某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算。
因此不需要移动线性表种元素的位置。
根据题意要求,该线性表的存储应能够很方便地找到线性表的任一指定序号的元素和最后一个元素,顺序表是由地址连续的向量实现的，因此具有按序号随机访问的特点.链表需要通过指针才能找到线性表的莫以指定序号的元素,需要一定的时间开销。
数据结构 第2章 线性表
123456
1 3
2 5
4
6
8
整理ppt
06/03/2021
线性表链式结构的存储示意
假设我们有一个线性表(a1,a2,…,an)
数据信息
结点
指针
……
ai 0500
数据域 指针域
图a：链表中的相邻元素
……
ai+1 0800
地址0500
头指针
第一个结点
12
整理ppt
06/03/2021
实现读取单链表第i个元素的代码
/* 初始条件：链式线性表L已存在，0 < i < ListLength(L)+1 */ /* 操作结果：用 e 返回 L 中第 i 个数据元素的值 */
1. Status GetElem (LinkList L, int i, ElemType *e)
2. { /* 参数 L 是待操作的链表，其实也是头结点 */
3.
int j;
4.
Node *p;
/* 声明一结点指针p */
5.
p = L->next;
/* 让p指向链表L的第一个结点 */
6.
j = 1;
/* j为计数器 */
7.
while (p && j<i) /* p不为空或者计数器j还没有等于i时，循环继续 */
8.
{
9.
p = p->next; /* 让p指向下一个结点 */
10.
++j;
11.
}
12. if (!p || j>i)
13.
《数据结构C语言版》----第02章
p size=0
head
a0
a1
(a)
...
a n 1 ∧
3.顺序表操作的效率分析
时间效率分析: 算法时间主要耗费在移动元素的操作上，因此计算时间复 杂度的基本操作(最深层语句频度) T(n)= O(移动元素次数) 而移动元素的个数取决于插入或删除元素的位置i. 若i=size，则根本无需移动（特别快）； 若i=0，则表中元素全部要后移（特别慢）； 应当考虑在各种位置插入（共n+1种可能）的平均移动次 数才合理。
(3)带头结点单链表和不带头结点单链表的比较
1).在带头结点单链表第一个数据元素前插入结点
p head s p head data next a0 x
∧
a1
…
an-1
∧
(a) 插入前
data next a0
∧
a1
…
an-1
∧
s
x
(b) 插入后
2).删除带头结点单链表第一个数据元素结点
p data next head
（5）取数据元素ListGet(L,
i, x)
int ListGet(SeqList L, int i, DataType *x) { if(i < 0 || i > L.size-1) { printf("参数i不合法! \n"); return 0; } else { *x = L.list[i]; return 1; } }