数据结构第02章线性表
合集下载
数据结构第2章 线性表
1
第二章 线性表 2.1 线性表的逻辑结构
1. 线性表的语言定义： n个数据元素的有限序列。
例1 英文字母表（A,B,C,…..Z)是一个线性表
线性表中的数据元素可以由若干个数据项组成。
例2 包含大量记录的登记表 学号 姓名 001 张三 002 李四 …… ……
年龄 18 19 ……
数据元素
2
第二章 线性表
q = & ( L.elem[i-1]) ；
for ( p = & L.elem[L.length-1] ；p >= q ；- - p ) * (p+1) = * p ； // 后移元素 * q = e ； // 插入新元素 ++L.length ；
return OK ；
}
26
第二章 线性表
// 越界处理
31
第二章 线性表
Status ListDelete_Sq ( Sqlist &L ，int i ，ElemType &e ) { if ( i < 1 || i > L.length ) return ERROR ；
p = & ( L.elem[i-1]) ；
e = * p ； // 取第 i 个元素的值 q =& L.elem[ L.length–1] ； for ( ++p；p <= q；++p ) * (p - 1) = * p ； // 前移
O(ListLength(La) ＋ ListLength(Lb))
14
第二章 线性表 算法时间复杂度
前提: GetElem() 和 ListInsert() 的执行时间与表长无关
第二章 线性表 2.1 线性表的逻辑结构
1. 线性表的语言定义： n个数据元素的有限序列。
例1 英文字母表（A,B,C,…..Z)是一个线性表
线性表中的数据元素可以由若干个数据项组成。
例2 包含大量记录的登记表 学号 姓名 001 张三 002 李四 …… ……
年龄 18 19 ……
数据元素
2
第二章 线性表
q = & ( L.elem[i-1]) ；
for ( p = & L.elem[L.length-1] ；p >= q ；- - p ) * (p+1) = * p ； // 后移元素 * q = e ； // 插入新元素 ++L.length ；
return OK ；
}
26
第二章 线性表
// 越界处理
31
第二章 线性表
Status ListDelete_Sq ( Sqlist &L ，int i ，ElemType &e ) { if ( i < 1 || i > L.length ) return ERROR ；
p = & ( L.elem[i-1]) ；
e = * p ； // 取第 i 个元素的值 q =& L.elem[ L.length–1] ； for ( ++p；p <= q；++p ) * (p - 1) = * p ； // 前移
O(ListLength(La) ＋ ListLength(Lb))
14
第二章 线性表 算法时间复杂度
前提: GetElem() 和 ListInsert() 的执行时间与表长无关
数据结构第二章：线性表
实现逻辑上相邻—物理地址相邻 实现逻辑上相邻— 实现随机存取 实现随机存取
实现：可用C 实现：可用C语言的一维数组实现
6
V数组下标 0 1
内存 a1 a2
元素序号 1 2
typedef int DATATYPE; #define M 1000 DATATYPE data[M]; 例 typedef struct card { int num; char name[20]; char author[10]; char publisher[30]; float price; }DATATYPE; DATATYPE library[M];
4
{加工型操作 加工型操作} 加工型操作
ClearList( &L ) 初始条件：线性表 L 已存在。 操作结果：将 L 重置为空表。 PutElem( &L, i, &e ) 初始条件：线性表L已存在，1≤i≤LengthList(L)。 操作结果：L 中第 i 个元素赋值同 e 的值 ListInsert( &L, i, e ) 初始条件：线性表 L 已存在，1≤i≤LengthList(L)+1。 操作结果：在 L 的第 i 个元素之前插入新的元素 e，L 的长度增1。 ListDelete( &L, i, &e ) 初始条件：线性表 L 已存在且非空，1≤i≤LengthList(L)。 操作结果：删除 L 的第 i 个元素，并用 e 返回其值，L 的长度减1。 }ADT LIST
3
PriorElem( PriorElem L, cur_e, &pre_e ) 初始条件：线性表 L 已存在。 操作结果：若 cur_e 是 L 中的数据元素，则用 pre_e 返回 它的前驱，否则操作失败，pre_e 无定义。 NextElem( NextElem L, cur_e, &next_e ) 初始条件：线性表 L 已存在。 操作结果：若 cur_e 是 L 中的数据元素，则用 next_e 返 回它的后继，否则操作失败，next_e 无定义。 GetElem( GetElem L, i, &e ) 初始条件：线性表 L 已存在，1≤i≤LengthList(L)。 操作结果：用 e 返回 L 中第 i 个元素的值。 LocateElem( LocateElem L, e, compare( ) ) 初始条件：线性表 L 已存在，compare( ) 是元素判定函数。 操作结果：返回 L 中第1个与 e 满足关系 compare( ) 的元 素的位序。若这样的元素不存在，则返回值为0。 ListTraverse(L, visit( )) ListTraverse 初始条件：线性表 L 已存在，visit( ) 为元素的访问函数。 操作结果：依次对 L 的每个元素调用函数 visit( )。 一旦 visit( ) 失败，则操作失败。
实现：可用C 实现：可用C语言的一维数组实现
6
V数组下标 0 1
内存 a1 a2
元素序号 1 2
typedef int DATATYPE; #define M 1000 DATATYPE data[M]; 例 typedef struct card { int num; char name[20]; char author[10]; char publisher[30]; float price; }DATATYPE; DATATYPE library[M];
4
{加工型操作 加工型操作} 加工型操作
ClearList( &L ) 初始条件：线性表 L 已存在。 操作结果：将 L 重置为空表。 PutElem( &L, i, &e ) 初始条件：线性表L已存在，1≤i≤LengthList(L)。 操作结果：L 中第 i 个元素赋值同 e 的值 ListInsert( &L, i, e ) 初始条件：线性表 L 已存在，1≤i≤LengthList(L)+1。 操作结果：在 L 的第 i 个元素之前插入新的元素 e，L 的长度增1。 ListDelete( &L, i, &e ) 初始条件：线性表 L 已存在且非空，1≤i≤LengthList(L)。 操作结果：删除 L 的第 i 个元素，并用 e 返回其值，L 的长度减1。 }ADT LIST
3
PriorElem( PriorElem L, cur_e, &pre_e ) 初始条件：线性表 L 已存在。 操作结果：若 cur_e 是 L 中的数据元素，则用 pre_e 返回 它的前驱，否则操作失败，pre_e 无定义。 NextElem( NextElem L, cur_e, &next_e ) 初始条件：线性表 L 已存在。 操作结果：若 cur_e 是 L 中的数据元素，则用 next_e 返 回它的后继，否则操作失败，next_e 无定义。 GetElem( GetElem L, i, &e ) 初始条件：线性表 L 已存在，1≤i≤LengthList(L)。 操作结果：用 e 返回 L 中第 i 个元素的值。 LocateElem( LocateElem L, e, compare( ) ) 初始条件：线性表 L 已存在，compare( ) 是元素判定函数。 操作结果：返回 L 中第1个与 e 满足关系 compare( ) 的元 素的位序。若这样的元素不存在，则返回值为0。 ListTraverse(L, visit( )) ListTraverse 初始条件：线性表 L 已存在，visit( ) 为元素的访问函数。 操作结果：依次对 L 的每个元素调用函数 visit( )。 一旦 visit( ) 失败，则操作失败。
数据结构第二章线性表.ppt
构造原理
用一组地址连续的存储单元依次存储线性表的数据元素，数 据元素之间的逻辑关系通过数据元素的存储位置直接反映。
k个单元 (a1,a2,a3,... ...,an)
a1 a2 a3
……
an
LOC(ai)
d1+k=d2 d3
………
dn
所谓一个元素的地址是指该元素占用的
若干(连续的)存储单元的第一个单元的地址。
LOC(a5)=100+(5-1)*4=116
线性表 11
顺序存储结构示意图
(a1,a2,a3,... ...,an)
当前已经占用的空间
尚未使用的空间
a1 a2 a3 … … an-1 an
01 2
n-2 n-1 n
……
n+1
M-1
事先分配给线性表的空间
线性表 12
一般来说，长度为n的线性表(a1,a2,…,an)在计算机中 的结构如下：
INSERT(L,x,i)。 6.删除线性表中第i个数据元素DELETE(L,i)。 7.对线性表中的数据元素进行升序或者降序排序。 8.将两个或两个以上的线性表合并成为一个线性表。 9.将一个线性表分解为两个或两个以上的线性表路】 依次输出线性表中的每个元素的值。
编写在线性表A中删除线性表B中出现的元素的算法。
1 3 57 9
12346
579
【算法思路】 依次检查线性表B中的每个元素，看它是否在线性表
A中。若在A中，则将其从A中删除。
线性表
5
void delete(Sqlist *A,Sqlist *B) {
int i,k;
datatype x;
for(i=1;i<=LENGTH(B);i++) {
用一组地址连续的存储单元依次存储线性表的数据元素，数 据元素之间的逻辑关系通过数据元素的存储位置直接反映。
k个单元 (a1,a2,a3,... ...,an)
a1 a2 a3
……
an
LOC(ai)
d1+k=d2 d3
………
dn
所谓一个元素的地址是指该元素占用的
若干(连续的)存储单元的第一个单元的地址。
LOC(a5)=100+(5-1)*4=116
线性表 11
顺序存储结构示意图
(a1,a2,a3,... ...,an)
当前已经占用的空间
尚未使用的空间
a1 a2 a3 … … an-1 an
01 2
n-2 n-1 n
……
n+1
M-1
事先分配给线性表的空间
线性表 12
一般来说，长度为n的线性表(a1,a2,…,an)在计算机中 的结构如下：
INSERT(L,x,i)。 6.删除线性表中第i个数据元素DELETE(L,i)。 7.对线性表中的数据元素进行升序或者降序排序。 8.将两个或两个以上的线性表合并成为一个线性表。 9.将一个线性表分解为两个或两个以上的线性表路】 依次输出线性表中的每个元素的值。
编写在线性表A中删除线性表B中出现的元素的算法。
1 3 57 9
12346
579
【算法思路】 依次检查线性表B中的每个元素，看它是否在线性表
A中。若在A中，则将其从A中删除。
线性表
5
void delete(Sqlist *A,Sqlist *B) {
int i,k;
datatype x;
for(i=1;i<=LENGTH(B);i++) {
《数据结构C语言版》----第02章
同理可证:顺序表删除一元素的时间效率为: 同理可证:顺序表删除一元素的时间效率为: T（n)=(n-1)/2 ≈O(n) O(n) （
插入效 E = ∑ is 率： i=0
n
1 n n pi ( n − i ) = ∑ (n − i) = 2 n + 1 i=0
n −1 删除效 1 n −1 n −1 Edl = ∑ qi (n − i ) = ∑ (n − i ) = 率： n i =0 2 i =0
2.2 线性表的顺序表示和实现
顺序存储结构的线性表称作顺序表 1.顺序表的存储结构 顺序表的存储结构
实现顺序存储结构的方法是使用数组。数组把线性表 实现顺序存储结构的方法是使用数组。 使用数组 的数据元素存储在一块连续地址空间的内存单元中， 连续地址空间的内存单元中 的数据元素存储在一块连续地址空间的内存单元中，这样 线性表中逻辑上相邻的数据元素在物理存储地址上也相邻。 线性表中逻辑上相邻的数据元素在物理存储地址上也相邻。 数据元素间的逻辑上的前驱、 数据元素间的逻辑上的前驱、后继逻辑关系就表现在数据 元素的存储单元的物理前后位置上。 元素的存储单元的物理前后位置上。 顺序表的存储结构如图所示
2.线性表抽象数据类型 2.线性表抽象数据类型
数据集合:｛ 的数据类型为DataType 数据集合 ｛ a0, a1, … , an-1 ｝, ai的数据类型为 (1) ListInitiate(L) 初始化线性表 (2) ListLength(L) 求当前数据元素个数 操作集合: 操作集合 (3) ListInsert(L,i,x) 插入数据元素 (4) ListDelete(L,i,x) 删除数据元素 (5) ListGet(L,i,x) 取数据元素
printf("参数 不合法 \n"); 参数i不合法 参数 不合法! return 0;
数据结构(C语言版)第2章 线性表
案例2.3 ：图书信息管理系统
图书顺序表
图书链表
总结
01
线性表中数据元素的类型可以为简单类型，也 可以为复杂类型。 许多实际应用问题所涉的基本操作有很大相似
02
性，不应为每个具体应用单独编写一个程序。
从具体应用中抽象出共性的逻辑结构和基本操 作（抽象数据类型），然后实现其存储结构和 基本操作。
03
04级计算机1班 04级计算机2班 04级计算机3班 04级计算机4班
：
：
：
：
：
数据元素都是记录;
元素间关系是线性
同一线性表中的元素必定具有相同特性
目 录 导 航
Contents
2.1 2.2 2.3 2.4 2.5
线性表的定义和特点 案例引入 线性的类型定义 线性表的顺序表示和实现 线性表的链式表示和实现
线性表
目标
target
01 02 03 04
OPTION
了解线性结构的特点
OPTION
掌握顺序表的定义、查找、插入和删除
掌握链表的定义、创建、查找、插入和删除 能够从时间和空间复杂度的角度比较两种存储结构的不同 特点及其适用场合
OPTION
OPTION
目 录 导 航
Contents
2.1 2.2 2.3 2.4 2.5
4
查找
3
目 录 导 航
Contents
2.1 2.2 2.3 2.4 2.5
线性表的定义和特点 案例引入 线性的类型定义 线性表的顺序表示和实现 线性表的链式表示和实现
2.6
2.7 2.8
顺序表和链表的比较
线性表的应用 案例分析与实现
线性表的顺序表示和实现
数据结构第二章线性表详解
第二章线性表一、描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。
并说明头指针和头结点的作用。
答：头指针是一个指针变量，里面存放的是链表中首结点的地址，并以此来标识一个链表。
如链表H，链表L等，表示链表中第一个结点的地址存放在H、L中。
头结点是附加在第一个元素结点之前的一个结点，头指针指向头结点。
当该链表表示一个非空的线性表时，头结点的指针域指向第一个元素结点，为空表时，该指针域为空。
开始结点指第一个元素结点。
头指针的作用是用来惟一标识一个单链表。
头结点的作用有两个：一是使得对空表和非空表的处理得以统一。
二是使得在链表的第一个位置上的操作和在其他位置上的操作一致，无需特殊处理。
二、填空题1、在顺序表中插入或删除一个元素，需要平均移动（表中一半）元素，具体移动的元素个数与（表长和该元素在表中的位置）有关。
2、顺序表中逻辑上相邻的元素的物理位置（必定）相邻。
单链表中逻辑上相邻的元素的物理位置（不一定）相邻。
3、在单链表中，除了首元结点外，任一结点的存储位置由（其直接前驱结点的链域的值）指示。
4、在单链表中设置头结点的作用是（插入和删除元素不必进行特殊处理）。
三、何时选用顺序表、何时选用链表作为线性表的存储结构为宜?答：在实际应用中，应根据具体问题的要求和性质来选择顺序表或链表作为线性表的存储结构，通常有以下几方面的考虑：1.基于空间的考虑。
当要求存储的线性表长度变化不大，易于事先确定其大小时，为了节约存储空间，宜采用顺序表；反之，当线性表长度变化大，难以估计其存储规模时，采用动态链表作为存储结构为好。
2.基于时间的考虑。
若线性表的操作主要是进行查找，很少做插入和删除操作时，采用顺序表做存储结构为宜；反之，若需要对线性表进行频繁地插入或删除等的操作时，宜采用链表做存储结构。
并且，若链表的插入和删除主要发生在表的首尾两端，则采用尾指针表示的单循环链表为宜。
十一、设顺序表中的数据元素递增有序，试写一算法，将X插入到顺序表的适当位置上，以保持该表的有序性。
《数据结构及其应用》笔记含答案 第二章_线性表
第2章线性表一、填空题1、线性结构反映结点间的逻辑关系是一对一的。
2、线性结构的特点：1）只有一个首结点和尾结点2）除首尾结点外，其他结点只有一个直接前驱和一个直接后继3、线性表的顺序表示又称为顺序存储结构。
4、结点只有一个指针域的链表，称为单链表。
5、首尾相接的链表称为循环链表。
6、线性表的链式表示又称为非顺序映像。
7、指向链表中第一个结点的指针称为头指针。
8、链表中存储第一个数据元素的结点称为首元结点。
二、判断题1、线性表的逻辑顺序与存储顺序总是一致的。
（╳）2、顺序存储的线性表可以按序号随机存取。
（√）3、顺序表的插入和删除操作不需要付出很大的时间代价，因为每次操作平均只有近一半的元素需要移动。
（╳）4、线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此属于同一数据对象。
（√）5、在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定相邻。
（╳）6、在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。
（√）7、线性表的链式存储结构优于顺序存储结构。
（╳）8、在线性表的顺序存储结构中，插入和删除时移动元素的个数与该元素的位置有关。
（√）9、线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。
（√）10、在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。
（╳）11、线性表的特点是每个元素都有一个前驱和一个后继。
（╳）三、单项选择题1、顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（B）。
A．110 B．108 C．100 D．120解释：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。
2、在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（A）。
A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n）B．在第i个结点后插入一个新结点（1≤i≤n）C．删除第i个结点（1≤i≤n）D．将n个结点从小到大排序解释：在顺序表中插入一个结点的时间复杂度都是O(n2)，排序的时间复杂度为O(n2)或O(nlog2n)。
数据结构--线性表
2020/4/7
14
2.3.1单链表
2020/4/7
15
2.3.1单链表
单链表的基本操作算法
查找运算
按序号查找 按值查找
插入运算
结点插入到链表的第一个结点前 结点插入到两个结点之间 结点插入到链表的最后一个结点后
删除运算
2020/4/7
16
2.3.1单链表
按序号查找 算法描述：设带头结点的单链表的头指针为L,要查
3
2.1 线性表的基本概念
线性表基本运算 初始化运算InitList(L) 求表长运算ListLength(L) 元素定位运算 LocateElem(L,x) 取元素运算GetElem(L,i,e) 插入运算ListInsert(L,i,x) 删除运算ListDelete(L,i,e) 遍历运算ListTraverse(L）
第2章 线性表
本章的基本内容是：
线性表的逻辑结构 线性表的顺序存储 线性表的链式存储 顺序表和链表的比较
2020/4/7
1
2.1 线性表的基本概念
线性表（Linear List): 是由n(n≥0)个类型相同的数据元素组成的 有限序列，记为（a1，a2，a3，…，an）。
a1
a2
a3
a4
next
2020/4/7
13
2.3.1单链表
上图所示为线性表（Sun，Mon，Tue，Wed，Thu， Fri，Sat）的线性链式存储结构。这种链表有一个头 指针（H），如果线性表非空，H指向链表中第一个结 点，否则它为空指针（即不指向任何结点的指针，通 常用NULL或∧表示）。由于最后一个结点设有直接后 继，所以它的指针域为空。
d
Loc(a1)
《数据结构(C++版)》第2章 线性表
线性表的抽象数据类型
Clear_List(&L) //清空线性表 输入：线性表L。 返回结果：将线性表L重置为空表。 List_Empty(&L) //判断线性表是否为空 输入：线性表L。 返回结果：若线性表L为空表，则返回TRUE，否则返回 FALSE。 List_Length(&L) //求线性表的长度 输入：线性表L。 返回结果：线性表L中的数据元素个数。
Next_Elem(& L，cur_e，&next_e) //返回当前元素的后一个元素值 输入：线性表L。 返回结果：若cur_e是线性表L中的数据元素，且不是最后一个，则 用next_e返回它的直接后继元素；否则操作失败，next_e无定义。 List_Insert(&L，i，e) //在线性表的第i个位置之前插入数据元素e 输入：线性表L，1≤ i ≤ List_Length(L)+1。 返回结果：在线性表L中的第i个位置之前插入新的数据元素e，线 性表L的长度加1。
• 例2–2 设一维数组A的下标的取值范围是0 - - 99，每个数组 元素用相邻的5个字节存储。存储器按字节编址，设存储数组 元素A[0]的第一个字节的地址是100，则A[5]的第一个字节的 地址是 。 • 解：第i个元素的存储地址的计算公式为Loc(ai) = Loc(a1) + (i– 1) × d，1 ≤ i ≤ n。因此，Loc(A[5])=100+ (5–0)×5=125。数 组A的第1个元素的下标是0，即A[0]。
• 时间复杂度为： • O(List_Length(LA)*List_Length(LB))
2.2 线性表的顺序存储结构
• 2.2.1 顺序表 • 线性表的顺序存储：是指用一组地址连续的存储单元依次 存储线性表中的数据元素。设a1的存储地址为Loc(a1)，每个 数据元素占用d个字节，则第i个数据元素的地址为 Loc(ai)=Loc(ai)+(i–1)×d，1≤i≤n，如图2.1所示。
数据结构 第二章 线性表
2.2 线性表的顺序存储
2.2.1 顺序表
线性表的结点按逻辑次序存放在一组地址连续 的存储单元里。 设LOC( ai )为顺序中第i个结点的存储地址，则 LOC( ai )=LOC( ai-1 )+*c LOC( ai )=LOC( a1 )+( i-1 )*c 1≤ i ≤n 其中 n为表长，c为每个结点存储单元长度。
第二章 线性表
☞ ☞ ☞ ☞ 线性表的概念及运算 线性表的顺序存储 线性表的链表存储 顺序表和链表的比较
2.1 线性表的概念及运算
2.1.1线性表的逻辑结构
定义：线性表（Linear List)是由n(n ≥ 0)个 数据元素a1,a2,a3,……. , an组成的有限序列。 其中数据元素个数n为表的长度。n=0时表为空 表，非空的线性表(n≥0)可记作： （ a1,a2,a3,……. , an ) 即表示为数据元素的非空有限集合。
datatype Get(LIST *L, int i) 取结点(第i个结点)
int Locate(LIST *L, datatype x) 定位(首个值为x的结点位置) void Insert(LIST *L, datatype x, int i) 插入(在i与i+1结点之间) void Delete(LIST *L, int i) 删除(第i结点) bool Empty(LIST *L) 判表空
Eis P ) i (n i 1
i 1 n 1
若认为Pi
1 n ห้องสมุดไป่ตู้1
T n On
1 n 1 n 则Eis ( n i 1 ) n 1 i 1 2
int Deletet(LIST *L, int i) //删除表中第i个结点 { if( i<1 || i> L→ last+1) //判无效位置
数据结构2第二章：线性表
单链表的删除图例
单链表的删除算法
Status ListDelete(LinkList L,int i,ElemType &e) //算法2.10 { //在带头结点的单链表L中，删除第I个元素，并由e返回其值。 p=L；j=0; while(p->next&&j<i-1) // 寻找第i个结点,并令p指向其前趋 { p=p->next; ++ j; } if(!p->next||j>i-1) return ERROR; // 删除位置不合理 q=p->next; // 删除并释放结点 p->next=q->next; e=q->data; free(q); return OK; }
顺序表的运算
• 插入运算 • 删除运算 • 总结
–由此可见，在顺序表中插入或删除一个数 据元素时，平均约移动表中的一半数据元 素。所以当n很大时，算法的效率是很低的。 若表长为n，则上述算法的时间复杂度为 O(n)。
顺序表的插入图例
顺序表的插入运算
Status ListInsert(SqList &L,int i,ElemType e) // 算法2.4
ai
逆置单链表
逆置单链表的算法如下：
void nz（NODE *h） {// 逆置头指针为h的带表头结点的单链表 NODE *s,*p； p=h->link；// p先指向原表中第一个结点 h->link=NULL；// 逆表的初态为空表 while (p!=NULL) {s=p； // s指向当前逆转的结点 p=p->link； s->link=h->link； h->link=s； // 把s结点插入逆表 } }
数据结构导论 第2章 线性表
线性表(linear list) 第二章 线性表
线性表是一种线性结构，线性结构的特点是数据元 素之间是一种线性关系，数据元素“一个接一个的 排列”。 线性结构是n（n>=0）个结点的有穷序列。对于 n>0的线性结构表示成： (a1，a2，… ai-1，ai，ai+1，…an) a1称为起始结点 an称为终端结点 起始结点， 终端结点; 起始结点 终端结点 ai-1 称为 ai 的直接前趋 i+1 称为 ai 的直接后继 直接前趋，a 直接后继。 直接前趋 直接后继
4．查找（定位） locate(L,x)： ．查找（定位） ：
依次将顺序表L中的每个元素与给定的值x进行比 较。若找到则返回其序号（下标+1），否则返回0。 int locate (sqlist L, datatype x) { int i; for ( i=0; i<st; i++) if (L.data[i]==x) return (i+1); return(0); }
void insert (sqlist *L, datatype x, int i ) { if (i<1 || i>L->last+1) error (“插入位置错误”); else if (L->last==maxsize) error (“溢出”); else { for (j=L->last-1; j>=i-1; j--) //往后移动元素 //往后移动元素 L->data[j+1]=L->data[j]; L->data[i-1]=x; //插入x L->last++; //修改表长 } }
常见的线性表的基本运算有以下几个： 常见的线性表的基本运算有以下几个：
线性表是一种线性结构，线性结构的特点是数据元 素之间是一种线性关系，数据元素“一个接一个的 排列”。 线性结构是n（n>=0）个结点的有穷序列。对于 n>0的线性结构表示成： (a1，a2，… ai-1，ai，ai+1，…an) a1称为起始结点 an称为终端结点 起始结点， 终端结点; 起始结点 终端结点 ai-1 称为 ai 的直接前趋 i+1 称为 ai 的直接后继 直接前趋，a 直接后继。 直接前趋 直接后继
4．查找（定位） locate(L,x)： ．查找（定位） ：
依次将顺序表L中的每个元素与给定的值x进行比 较。若找到则返回其序号（下标+1），否则返回0。 int locate (sqlist L, datatype x) { int i; for ( i=0; i<st; i++) if (L.data[i]==x) return (i+1); return(0); }
void insert (sqlist *L, datatype x, int i ) { if (i<1 || i>L->last+1) error (“插入位置错误”); else if (L->last==maxsize) error (“溢出”); else { for (j=L->last-1; j>=i-1; j--) //往后移动元素 //往后移动元素 L->data[j+1]=L->data[j]; L->data[i-1]=x; //插入x L->last++; //修改表长 } }
常见的线性表的基本运算有以下几个： 常见的线性表的基本运算有以下几个：
数据结构讲义第2章-线性表
t个单元
a1 a2 ai-1 ai ai+1 an
2.2 线性表的顺序存储和实现
线性表的顺序存储结构——顺序表 一 线性表的顺序存储结构 顺序表
顺序表的定义： 一维数组＋表长
例1： 写出线性表（6，17，28，50，92，188）的顺序 存储结构表示。 # define ListSize 100 typedef int ElemType; ElemType List[ListSize]; int length;
思考：采用其它的定义如何初始化空表？
2.2 线性表的顺序存储和实现
三 顺序表应用举例
1. 设有两个按元素值递增有序排列的顺序表A和B，请编写算法将A 和B归并成一个按元素值递增有序排列的线性表C。 void merge(SeqList A,SeqList B,SeqList &C) {i=0;j=0;k=0; while ( i<A.length && j<B.length ) if (A.data[i]<B.data[j]) C.data[k++]=A.data[i++]; else C.data[k++]=B.data[j++]; while (i<A.length ) C.data[k++]= A.data[i++]; while (j<B.length ) C.data[k++]=B.data[j++]; C.length=k; }
调用示例： main() {SeqList L; ElemType e; ．．． delete_ListSq(L,2,e); ．．． }
数据结构 第二章__线性表(本)
数据结构与算法华东师范大学计算机系杨沛第二章线性表2.1 线性表的基本概念线性表是具有相同数据类型的数据元素的有限序列。
由n（n≥0）个数据元素k0,k1,…,kn-1组成的线性表记为（k0 ,k1 ,…,kn-1），线性表中包含的数据元素的个数n称为线性表的长度（length），称长度为零的线性表为空的线性表（简称为空表）。
相关概念：表头、表尾、前驱、后继有序线性表：数据元素的相对位置与它们的值有联系。
无序线性表：数据元素的相对位置与它们的值没有联系。
第二章线性表例小于20的质数组成的线性表(2,3,5,7,11,13, 17,19)；英文字母表也是线性表，表中每个字母是一个数据元素：(A,B,C,……,Z)；2.2 顺序表2.2.1 线性表顺序表（sequential list）就是顺序存贮的线性表，即用一组连续的存贮单元依次、连续地存贮线性表中的结点。
如果每个结点占用s个存贮单元，并假设存放结点ki（0≤i≤n-1）的开始地址为loc(k0)，则结点ki的地址loc(ki)可表示成Loc(ki) =loc(k0) + i*s。
2.2 顺序表在C 语言中，可用数组表示线性表：#define MAXN 100int list[MAXN];int n;线性表的结点k 0,k 1,…,k n-1依次存放在数组单元list[0]，list[1]，…，list[n-1]。
2.2.1 线性表最大表长实际表长线性表2.2 顺序表2.2.1 线性表假设s=sizeof(int)，则可得到计算ki的地址的公式，因loc(ki)=&list[i]，而&list[i]=&list[0]+i·s，故loc(ki)=&list[0]+i·s。
2.2 顺序表2.2.2 顺序表的操作（1）初始化：初始长度置为0即可（n=0;），数组空间在编译时分配。
（2)顺序表的插入：插入算法的C函数SqListInsert()：若插入位置i不在可以插入的位置上，即i＜0或i>n，则返回0；若n=MAXN，即线性表已满，此时数组list[]没有多余的存贮单元可以存放新结点，则返回-1；若插入成功，则返回12.2 顺序表实际表长（2）顺序表的插入：int SqListInsert(int list[],int*p_n,int i,int x) {int j;if(i<0||i>*p_n）return(0);//i不是合法的插入位置if(*p_len==MAXN)return(-1);//线性表已满2.2 顺序表for(j=*p_n;j>i;j--)list[j]=list[j-1];//结点右移list[i]=x;(*p_n)++;//表长加1return(1);｝2.2 顺序表（2）顺序表的插入：对于存放在数组list[]中的、具有n个结点的顺序表，为了把值为x的结点插在表的位置i（0≤i≤n）上，可调用如下的语句：k=SqListInsert(list, &n, i, x);注：结点移动是本算法的关键操作2.2 顺序表（3）顺序表的删除：删除算法的C函数SqListDelete()：在具有n个结点的顺序表中，删除第i（0≤i≤n-1）个位置上的结点，使线性表长度减1，若删除位置不合法，即i＜0或i≥n，则返回0；若删除位置合法，即0≤i≤n-1，则删除成功，返回1。
数据结构第2章 线性表
大长度*/
};
当初始化此类型的一个线性表时，要使list指针指向大小为MaxSize的动 态数组空间。
2.2.2 顺序存储下的线性表的操作实现
1. 初始化线性表L，即进行动态存储空间分配并置L为一个空表 void InitList(struct List *L,int ms) { /*检查ms是否有效，若无效则退出运行*/ if(ms<=0) {printf("ms值非法!\n"); exit(1);} /*置线性表空间大小为ms*/ L->MaxSize=ms; /*动态存储空间分配，若分配失败则退出运行*/ L->list=malloc(ms*sizeof(ElemType)); if(!L->list) { printf("动态存储分配失败!\n"); exit(1); /*执行此函数则中止程序运行，此函数在stdlib.h中有定义*/ } /*初始置线性表为空*/ L->size=0; }
5. 向有序线性表L中插入元素x，使得插入后仍然有序 有序线性表是指按元素值从小到大顺序排列的线性表，如（23,36,45,49,56,73,80） 就是一个有序线性表。向有序线性表中插入一个新元素后要保证仍然是有序的，需要进 行的插入过程为： (1) 检查表空间是否用完，若是则分配更大的存储空间； (2) 采用顺序查找的方法查找出x的插入位置； (3) 从表尾到插入位置止，把所有位置上的元素均后移一个位置； (4) 把新元素写入到空出的位置上； (5) 线性表的长度增1。 算法描述为： void InsertOrderList(struct List *L, ElemType x) { int i,j; /*若数组空间用完则重新分配更大的存储空间*/ if(L->size==L->MaxSize) againMalloc(L); /*顺序查找出x的插入位置*/ for(i=0; i<L->size; i++) if(x<L->list[i]) break; /*从表尾到下标i元素依次后移一个位置，把i位置空出*/
};
当初始化此类型的一个线性表时，要使list指针指向大小为MaxSize的动 态数组空间。
2.2.2 顺序存储下的线性表的操作实现
1. 初始化线性表L，即进行动态存储空间分配并置L为一个空表 void InitList(struct List *L,int ms) { /*检查ms是否有效，若无效则退出运行*/ if(ms<=0) {printf("ms值非法!\n"); exit(1);} /*置线性表空间大小为ms*/ L->MaxSize=ms; /*动态存储空间分配，若分配失败则退出运行*/ L->list=malloc(ms*sizeof(ElemType)); if(!L->list) { printf("动态存储分配失败!\n"); exit(1); /*执行此函数则中止程序运行，此函数在stdlib.h中有定义*/ } /*初始置线性表为空*/ L->size=0; }
5. 向有序线性表L中插入元素x，使得插入后仍然有序 有序线性表是指按元素值从小到大顺序排列的线性表，如（23,36,45,49,56,73,80） 就是一个有序线性表。向有序线性表中插入一个新元素后要保证仍然是有序的，需要进 行的插入过程为： (1) 检查表空间是否用完，若是则分配更大的存储空间； (2) 采用顺序查找的方法查找出x的插入位置； (3) 从表尾到插入位置止，把所有位置上的元素均后移一个位置； (4) 把新元素写入到空出的位置上； (5) 线性表的长度增1。 算法描述为： void InsertOrderList(struct List *L, ElemType x) { int i,j; /*若数组空间用完则重新分配更大的存储空间*/ if(L->size==L->MaxSize) againMalloc(L); /*顺序查找出x的插入位置*/ for(i=0; i<L->size; i++) if(x<L->list[i]) break; /*从表尾到下标i元素依次后移一个位置，把i位置空出*/
数据结构第二章线性表
线性表的顺序存储结构可用数组来实现。
线性表的顺序存储结构可用数组来实现。 数组元素的类型就是线性表中数据元素 的类型，数组的大小，最好大于线性表 的长度。因此，顺序存储结构是把线性 表中每个元素a1, a2, a3, …, an依次存放到数 组下标为0, 1, 2,…, n1的位置上。
假设用数组data［MAXSIZE］存储线性 表 A =（a1, a2, a3, …, an） 其顺序存储结构如图2.1所示。
➢2.2.1 线性表的顺序存储结构 ➢2.2.2 顺序表的基本运算 ➢2.2.3 插入和删除运算的时间分析 ➢2.2.4 顺序表的优点和缺点
2.2.1 线性表的顺序存储结构
线性表的顺序存储方法是：将线性表的所有元素 按其逻辑顺序依次存放在内存中一组连续的存储 单元中，也就是将线性表的所有元素连续地存放 到计算机中相邻的内存单元中，以保证线性表元 素逻辑上的有序性。 顺序表的特点是：其逻辑关系相邻的两个结点在 物理位置上也相邻，结点的逻辑次序和物理次序 一致。
图2.1 顺序存储结构示意图
由于线性表中所有结点的数据类型是相同 的，因此每个结点占用的存储空间也是
相同的。假设每个结点占用d个存储单元，
若 线 性 表 中 第 一 个 结 点 a1 的 存 储 地 址 为 LOC(a1) ， 那 么 结 点 ai 的 存 储 地 址 LOC(ai) 可以通过下面的公式计算得到：
【例2.3】学生成绩统计表也是一个线性表， 见表2.1。在线性表中每个学生的成绩是
一个数据元素，它由学号、姓名、数学、 外语、物理、总分这6个数据项组成。该 线性表的长度为5。
学号 1 2 3 4 5
姓名 李华 王放 张利 田勇 成惠
表 2.1 某班学生成绩统计表
线性表的顺序存储结构可用数组来实现。 数组元素的类型就是线性表中数据元素 的类型，数组的大小，最好大于线性表 的长度。因此，顺序存储结构是把线性 表中每个元素a1, a2, a3, …, an依次存放到数 组下标为0, 1, 2,…, n1的位置上。
假设用数组data［MAXSIZE］存储线性 表 A =（a1, a2, a3, …, an） 其顺序存储结构如图2.1所示。
➢2.2.1 线性表的顺序存储结构 ➢2.2.2 顺序表的基本运算 ➢2.2.3 插入和删除运算的时间分析 ➢2.2.4 顺序表的优点和缺点
2.2.1 线性表的顺序存储结构
线性表的顺序存储方法是：将线性表的所有元素 按其逻辑顺序依次存放在内存中一组连续的存储 单元中，也就是将线性表的所有元素连续地存放 到计算机中相邻的内存单元中，以保证线性表元 素逻辑上的有序性。 顺序表的特点是：其逻辑关系相邻的两个结点在 物理位置上也相邻，结点的逻辑次序和物理次序 一致。
图2.1 顺序存储结构示意图
由于线性表中所有结点的数据类型是相同 的，因此每个结点占用的存储空间也是
相同的。假设每个结点占用d个存储单元，
若 线 性 表 中 第 一 个 结 点 a1 的 存 储 地 址 为 LOC(a1) ， 那 么 结 点 ai 的 存 储 地 址 LOC(ai) 可以通过下面的公式计算得到：
【例2.3】学生成绩统计表也是一个线性表， 见表2.1。在线性表中每个学生的成绩是
一个数据元素，它由学号、姓名、数学、 外语、物理、总分这6个数据项组成。该 线性表的长度为5。
学号 1 2 3 4 5
姓名 李华 王放 张利 田勇 成惠
表 2.1 某班学生成绩统计表
数据结构(第二章 线性表)
2.2 线性表的顺序存储和实现
顺序表-顺序表定义
由上可知，数据的存储逻辑位置由数组的下标决定。 所以相邻的元素之间地址的计算公式为（假设每个数 据元素占有d个存储单元）： LOC（ai）=LOC（ai-1）+d 对线性表的所有数据元素，假设已知第一个数据元 素a0的地址为LOC（a0） ，每个结点占有d个存储 单元， 则第i个数据元素ai的地址为： LOC（ai）=LOC（a0）+i*d 线性表的第一个数据元素的位置通常称做起始位置 或基地址。 在使用一维数组时，数组的下标起始位置根据给定 的问题确定，或者根据实际的高级语言的规定确定。
2.1 线性表抽象数据类型
线性表的分类
顺序存储结构 （元素连续存储、 随机存取结构） 线性表 ADT 链式存储结构 （元素分散存储） 继承 顺序表类 排序顺序表类 继承 单链表类 循环单链表 双链表 继承 排序循环双链表类 排序单链表类
单链表
双链表
循环双链表类
线性表的存储结构
2.2 线性表的顺序存储和实现
线性表的基本操作 求长度：求线性表的数据元素个数。 访问：对线性表中指定位置的数据元素进行存取、替 换等操作。 插入：在线性表指定位置上，插入一个新的数据元素， 插入后仍为一个线性表。 删除：删除线性表指定位置的数据元素，同时保证更 改后的线性表仍然具有线性表的连续性。 复制：重新复制一个线性表。 合并：将两个或两个以上的线性表合并起来，形成一 个新的线性表。 查找：在线性表中查找满足某种条件的数据元素。 排序：对线性表中的数据元素按关键字值，以递增或 递减的次序进行排列。 遍历：按次序访问线性表中的所有数据元素，并且每 个数据元素恰好访问一次。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
// La中不存在和 e 相同的数据元素，则插入之
}
} // union
2013年7月11日星期四 数据结构第二章线性表
13
例 2-2
已知一个非纯集合 B，试构造一个
纯集合 A，使 A中只包含 B 中所有值各 不相 同的数据元素。
仍选用线性表表示集合。
2013年7月11日星期四 数据结构第二章线性表
}
2013年7月11日星期四
} // union
数据结构第二章线性表
16
void MergeList(List La, List Lb, List &Lc) {
// 本算法将非递减的有序表 La 和 Lb 归并为 Lc
InitList(Lc); // 构造空的线性表 Lc i = j = 1; k = 0; 例 La_len = ListLength(La); Lb_len = ListLength(Lb); while ((i <= La_len) && (j <= Lb_len)) { // La 和 Lb 均不空 } while (i<=La_len) // 若 La 不空 while (j<=Lb_len) // 若 Lb 不空
第二章 线性表
主讲人：蔡琼
2013年7月11日星期四
数据结构第二章线性表
1
第二章 线 性 表
本章主要内容:
1.线性表的逻辑结构及ADT定义；
2.线性表的顺序存储及实现； 3.线性表的链接存储及实现;
4.线性表的其他存储及实现。
2013年7月11日星期四
数据结构第二章线性表
2
2.1 线性表的逻辑结构
GetElem(LB, i)→e
2．依值在线性表LA中进行查访; LocateElem(LA, e, equal( ))
3．若不存在，则插入之。 ListInsert(LA, n+1, e)
2013年7月11日星期四 数据结构第二章线性表
12
void union(List &La, List Lb) { La_len = ListLength(La); // 求线性表的长度 Lb_len = ListLength(Lb); for (i = 1; i <= Lb_len; i++) { GetElem(Lb, i, e); // 取Lb中第i个数据元素赋给e if (!LocateElem(La, e, equal( )) ) ListInsert(La, ++La_len, e);
LocateElem(L, e, compare()) // 查找 ListInsert(&L, i, e) // 插入元素 ListDelete(&L, i) // 删除元素
2013年7月11日星期四 数据结构第二章线性表
22
Status InitList_Sq( SqList& L ) { // 构造一个空的线性表 L.elem = (ElemType*) malloc (LIST_ INIT_SIZEsizeof (ElemType)); if (!L.elem) exit(OVERFLOW); L.length = 0; L.listsize = LIST_INIT_SIZE return OK; } // InitList_Sq O(1) 算法时间复杂度：
数据结构第二章线性表
24
int LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType, ElemType)) {
// 在顺序表中查询第一个满足判定条件的数据元素， // 若存在，则返回它的位序，否则返回 0
i = 1; // i 的初值为第 1 元素的位序 p = L.elem; // p 的初值为第 1 元素的存储位置 while (i <= L.length && !(*compare)(*p++, e)) ++i; (*compare)(*p++, e) if (i <= L.length) return i; else return 0; 算法的时间复杂度为： } // LocateElem_Sq
2013年7月11日星期四
数据结构第二章线性表
6
DestroyList(&L)
前置条件：表已存在 输入：无
功能：销毁表
输出：无 后置条件：释放表所占用的存储空间 ListLength(L) 前置条件：表已存在 输入：无 功能：求表的长度 输出：表中数据元素的个数 后置条件：表不变
2013年7月11日星期四
2013年7月11日星期四 数据结构第二章线性表
19
2. 顺序表的存储示意图
L＝（a1，a2，…,ai-1，ai, …，an) 0 … i-2 i-1 … n-1 Max-1
a1 … ai-1 ai
… an
空闲 长度
设顺序表第一个元素的存储地址为LOC(ai), 每个元素占用c个存储单元，则第i个元素的 存储地址是多少？
数据结构第二章线性表
2013年7月11日星期四
5
2.1.2 线性表的抽象数据类型定义
ADT List Data 线性表中的数据元素具有相同类 型，相邻元素具有前驱和后继关系 Operation InitList(&L) 前置条件：表不存在 输入：无 功能：表的初始化 输出： 无 后置条件：建一个空表
插入前
35
12
24
42
空
闲
4
i=4,插入33
33
插入后
35
12
24
33 42
42
空 闲
5 4
27
2013年7月11日星期四
数据结构第二章线性表
2.2.2 顺序表的实现——插 入
分析下列情况: 1.当插入位置i小于1，或插入位置i大于 Length+1,会出现什么情况？=>异常 2.当Length的值大于L.listsize,会出 现什么情况？=>溢出
ElemType *elem; int
int
// 存储空间基址
length; // 当前长度
listsize; // 当前分配的存储容量
// (以sizeof(ElemType)为单位)
数据结构第二章线性表
} SqList; // 俗称 顺序表
2013年7月11日星期四
21
线性表的基本操作在顺序表中的实现 InitList(&L) // 结构初始化
2013年7月11日星期四 数据结构第二章线性表
9
ListEmpty(L) 前置条件：表已存在 输入：无 功能：判断表是否为空 输出：若是空表，返回1，否则返回0 后置条件：表不变 ADT
进一步说明: （1）线性表的基本操作根据实际应用是而定。 （2）复杂的操作可以通过基本操作的组合来实现。 （3）对不同的应用，操作的接口可能不同。
2013年7月11日星期四 数据结构第二章线性表
10
例 2-1
假设:有两个集合 A 和 B 分别用
两个线性表 LA 和 LB 表示，即：
线性表中的数据元素即为集合中的
成员。 现要求一个新的集合A＝A∪B。
2013年7月11日星期四 数据结构第二章线性表
11
操作步骤：
1．从线性表LB中依次察看每个数据元素;
数据结构第二章线性表
7
GetElem ( L, i, &e ) 前置条件：表已存在 输入：元素的序号i 功能：在表中取序号为i的数据元素 输出：若i合法，用e返回序号为i的元素值，否则输出异常 后置条件：表不变 LocateElem( L, e, compare( ) ) 前置条件：表已存在 输入：数据元素e 功能：在线性表中查找值等于e的元素 输出：如果查找成功，返回元素e在表中的位序，否则返回0 后置条件：表不变
14
集合 B
集合 A
从集合 B 取出物件放入集合 A
要求集合A中同样物件不能有两件以上 因此，算法的策略应该和例2-1相同
2013年7月11日星期四 数据结构第二章线性表
15
void union(List &La, List Lb) { InitList(La); // 构造(空的)线性表LA
La_len=ListLength(La); Lb_len=ListLength(Lb);
启示
程序设计时要注意边界条件等细节的处理。
2013年7月11日星期四 数据结构第二章线性表
2-3
} // merge_list
2013年7月11日星期四
数据结构第二章线性表
17
while (i <= La_len) { // 当La不空时 GetElem(La, i++, ai); ListInsert(Lc, ++k, ai); } // 插入 La 表中剩余元素
while (j <= Lb_len) { // 当Lb不空时 GetElem(Lb, j++, bj); ListInsert(Lc, ++k, bj); } // 插入 Lb 表中剩余元素
for (i = 1; i <= Lb_len; i++) {
GetElem(Lb, i, e); // 取Lb中第 i 个数据元素赋给 e if (!LocateElem(La, e, equal( )) ) ListInsert(La, ++La_len, e);
// La中不存在和 e 相同的数据元素，则插入之
}
} // union
2013年7月11日星期四 数据结构第二章线性表
13
例 2-2
已知一个非纯集合 B，试构造一个
纯集合 A，使 A中只包含 B 中所有值各 不相 同的数据元素。
仍选用线性表表示集合。
2013年7月11日星期四 数据结构第二章线性表
}
2013年7月11日星期四
} // union
数据结构第二章线性表
16
void MergeList(List La, List Lb, List &Lc) {
// 本算法将非递减的有序表 La 和 Lb 归并为 Lc
InitList(Lc); // 构造空的线性表 Lc i = j = 1; k = 0; 例 La_len = ListLength(La); Lb_len = ListLength(Lb); while ((i <= La_len) && (j <= Lb_len)) { // La 和 Lb 均不空 } while (i<=La_len) // 若 La 不空 while (j<=Lb_len) // 若 Lb 不空
第二章 线性表
主讲人：蔡琼
2013年7月11日星期四
数据结构第二章线性表
1
第二章 线 性 表
本章主要内容:
1.线性表的逻辑结构及ADT定义；
2.线性表的顺序存储及实现； 3.线性表的链接存储及实现;
4.线性表的其他存储及实现。
2013年7月11日星期四
数据结构第二章线性表
2
2.1 线性表的逻辑结构
GetElem(LB, i)→e
2．依值在线性表LA中进行查访; LocateElem(LA, e, equal( ))
3．若不存在，则插入之。 ListInsert(LA, n+1, e)
2013年7月11日星期四 数据结构第二章线性表
12
void union(List &La, List Lb) { La_len = ListLength(La); // 求线性表的长度 Lb_len = ListLength(Lb); for (i = 1; i <= Lb_len; i++) { GetElem(Lb, i, e); // 取Lb中第i个数据元素赋给e if (!LocateElem(La, e, equal( )) ) ListInsert(La, ++La_len, e);
LocateElem(L, e, compare()) // 查找 ListInsert(&L, i, e) // 插入元素 ListDelete(&L, i) // 删除元素
2013年7月11日星期四 数据结构第二章线性表
22
Status InitList_Sq( SqList& L ) { // 构造一个空的线性表 L.elem = (ElemType*) malloc (LIST_ INIT_SIZEsizeof (ElemType)); if (!L.elem) exit(OVERFLOW); L.length = 0; L.listsize = LIST_INIT_SIZE return OK; } // InitList_Sq O(1) 算法时间复杂度：
数据结构第二章线性表
24
int LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType, ElemType)) {
// 在顺序表中查询第一个满足判定条件的数据元素， // 若存在，则返回它的位序，否则返回 0
i = 1; // i 的初值为第 1 元素的位序 p = L.elem; // p 的初值为第 1 元素的存储位置 while (i <= L.length && !(*compare)(*p++, e)) ++i; (*compare)(*p++, e) if (i <= L.length) return i; else return 0; 算法的时间复杂度为： } // LocateElem_Sq
2013年7月11日星期四
数据结构第二章线性表
6
DestroyList(&L)
前置条件：表已存在 输入：无
功能：销毁表
输出：无 后置条件：释放表所占用的存储空间 ListLength(L) 前置条件：表已存在 输入：无 功能：求表的长度 输出：表中数据元素的个数 后置条件：表不变
2013年7月11日星期四
2013年7月11日星期四 数据结构第二章线性表
19
2. 顺序表的存储示意图
L＝（a1，a2，…,ai-1，ai, …，an) 0 … i-2 i-1 … n-1 Max-1
a1 … ai-1 ai
… an
空闲 长度
设顺序表第一个元素的存储地址为LOC(ai), 每个元素占用c个存储单元，则第i个元素的 存储地址是多少？
数据结构第二章线性表
2013年7月11日星期四
5
2.1.2 线性表的抽象数据类型定义
ADT List Data 线性表中的数据元素具有相同类 型，相邻元素具有前驱和后继关系 Operation InitList(&L) 前置条件：表不存在 输入：无 功能：表的初始化 输出： 无 后置条件：建一个空表
插入前
35
12
24
42
空
闲
4
i=4,插入33
33
插入后
35
12
24
33 42
42
空 闲
5 4
27
2013年7月11日星期四
数据结构第二章线性表
2.2.2 顺序表的实现——插 入
分析下列情况: 1.当插入位置i小于1，或插入位置i大于 Length+1,会出现什么情况？=>异常 2.当Length的值大于L.listsize,会出 现什么情况？=>溢出
ElemType *elem; int
int
// 存储空间基址
length; // 当前长度
listsize; // 当前分配的存储容量
// (以sizeof(ElemType)为单位)
数据结构第二章线性表
} SqList; // 俗称 顺序表
2013年7月11日星期四
21
线性表的基本操作在顺序表中的实现 InitList(&L) // 结构初始化
2013年7月11日星期四 数据结构第二章线性表
9
ListEmpty(L) 前置条件：表已存在 输入：无 功能：判断表是否为空 输出：若是空表，返回1，否则返回0 后置条件：表不变 ADT
进一步说明: （1）线性表的基本操作根据实际应用是而定。 （2）复杂的操作可以通过基本操作的组合来实现。 （3）对不同的应用，操作的接口可能不同。
2013年7月11日星期四 数据结构第二章线性表
10
例 2-1
假设:有两个集合 A 和 B 分别用
两个线性表 LA 和 LB 表示，即：
线性表中的数据元素即为集合中的
成员。 现要求一个新的集合A＝A∪B。
2013年7月11日星期四 数据结构第二章线性表
11
操作步骤：
1．从线性表LB中依次察看每个数据元素;
数据结构第二章线性表
7
GetElem ( L, i, &e ) 前置条件：表已存在 输入：元素的序号i 功能：在表中取序号为i的数据元素 输出：若i合法，用e返回序号为i的元素值，否则输出异常 后置条件：表不变 LocateElem( L, e, compare( ) ) 前置条件：表已存在 输入：数据元素e 功能：在线性表中查找值等于e的元素 输出：如果查找成功，返回元素e在表中的位序，否则返回0 后置条件：表不变
14
集合 B
集合 A
从集合 B 取出物件放入集合 A
要求集合A中同样物件不能有两件以上 因此，算法的策略应该和例2-1相同
2013年7月11日星期四 数据结构第二章线性表
15
void union(List &La, List Lb) { InitList(La); // 构造(空的)线性表LA
La_len=ListLength(La); Lb_len=ListLength(Lb);
启示
程序设计时要注意边界条件等细节的处理。
2013年7月11日星期四 数据结构第二章线性表
2-3
} // merge_list
2013年7月11日星期四
数据结构第二章线性表
17
while (i <= La_len) { // 当La不空时 GetElem(La, i++, ai); ListInsert(Lc, ++k, ai); } // 插入 La 表中剩余元素
while (j <= Lb_len) { // 当Lb不空时 GetElem(Lb, j++, bj); ListInsert(Lc, ++k, bj); } // 插入 Lb 表中剩余元素
for (i = 1; i <= Lb_len; i++) {
GetElem(Lb, i, e); // 取Lb中第 i 个数据元素赋给 e if (!LocateElem(La, e, equal( )) ) ListInsert(La, ++La_len, e);
// La中不存在和 e 相同的数据元素，则插入之