第二章_线性表_线性存储部分
DS第二章线性表PPT课件
删除第 i（1≦i≦n) 个元素e
思想：把第i＋1个元素（下标为i）开始的元素，
依次前移
步骤：
1.要检查删除位置的有效性。 2.依次移动元素 3.长度减1
顺序表上的删除元素操作
请看教材P.24.图2-4 ElemType SeqListDelete(SeqList L,int i)
线性表的逻辑结构典型题解析
选择题 【说明】：本节内容比较简单， 只需注意线性表的定义和逻辑特 征。
线性表的逻辑结构典型题解析
选择题1： 线性表是具有n个（ ）的有限序 列。
A．数据
B．字符
C．数据元素 D．数据项
【解答】 C
【分析】 数据的逻辑结构是指数据元素之间逻
辑关系的整体。线性表中数据元素之间的逻辑
第二章 线性表
有序（次序）表， 不是值有序
基本知识点：线性表的逻辑结构特点，线性表的 两种存储结构以及在这两种存储结构下线性表基 本运算的实现算法，顺序表与链表的优缺点比较。
线性结构是一个数据元素的有限序列
重点：掌握线性表的定义和特点，线性表的存储 结构，顺序表和链表的组织方法和相关算法设计。
请与教材 p.31.算法进 行比较
顺序表按值查找算法
int SeqListLocate(SeqList L, ElemType x)
{ //在顺序表L中查找第一个与x值相等的元素。若查找 //成功，则返回它在顺序表中的位置；否则，返回0。
for(i=0; i<L.length; i&#x) return i+1;
i 1
设在第i个 位置删除的概率为pi；
pi 1 n
n
1n
n 1
Ede pi(n i) (n i)
第二章 线性表
（7）已知顺序表L中的元素有序递增，设计算法将元素x插入到L 种，并依旧保持其有序递增;设计一个高效的算法，删除顺序表 中所有值为x的元素，要求空间复杂度为O(1)。(基于顺序表基本 操作的运算) （8）(2010年13分)设将n(n＞1)个整数存放到一维数组R中。试 设计一个在时间和空间两方面尽可能有效的算法，将R中保有的 序列循环左移P(0＜p＜ n)个位置，即将R中的数据由(X0 X1 ……Xn-1)变换为(Xp Xp+1 ……Xn-1 X0 X1……Xp-1) 要求： (1)给出算法的基本设计思想。 (2)根据设计思想，采用C或C++或JAVA语言描述算法，关键之处 给出注释。 (3)说明你所设计算法的时间复杂度和空间复杂度
2 3 4 5 6
30 60 20 40
6 -1 3 1
h
10
20Βιβλιοθήκη 304050
60∧
8、例题: （1）链表不具有的特点是（ ）。 A．可随机访问任一元素 B．插入删除不需要移动元素 C．不必事先估计存储空间 D．所需空间与线性表长度成正比 （2）在具有n个结点的单链表中插入一个新结点并使链表仍然有 序的时间复杂度是( )。 A. O(1) B. O(n) C. O(nlog2n) D. O(n2) （3）对于由n个元素组成的线性表，创建一个有序单链表的时间 复杂度是（ ）。 A. O(1) B. O(n) C. O(nlog2n) D. O(n2)
（4）设A是一个线性表，采用顺序存储结构。在等概率情况下， 平均插入一个元素需要移动多少个元素？若元素插在ai和ai+1之 间的概率为(n-i)/n(n-1)/2,则平均插入一个元素需要移动多少 个元素？ （5）以顺序表作为存储结构，实现线性表的就地逆置；判断回 文；设计一个时间复杂度为O(n)的算法，将顺序表中所有元素循 环左移k位；设计一个时间复杂度为O (n)的算法，将顺序表中所 有元素循环右移k位；（基于逆置操作的运算） （6）将顺序表中的元素调整为左右两部分，左边元素为奇数， 右边元素为偶数，要求算法的时间复杂度为O (n)；将顺序表A拆 分为B 和C,其中B中的元素小于0，C中的元素大于0;将有序表A和 有序表B合并为C,合并后C依然是有序的。（基于对顺序表的拆分 和合并操作的运算）
数据结构第二章：线性表
实现：可用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( ) 失败，则操作失败。
线性表
2.1 线性表的类型定义
例3：下图为10个个学生的成绩表,它也是一个 线性表,该线性表的数据元素类型为结构体类型。
2.1 线性表的类型定义
从以上例子可看出线性表的逻辑特征是： 在非空的线性表中，有且仅有一个被称作 “第一个”的数据元素a1，它没有直接前趋， 而仅有一个直接后继a2； 有且仅有一个被称作“最后一个”的数据元 素an，它没有直接后继，而仅有一个直接前 趋 a n-1； 其余的数据元素ai(2≦i≦n-1)都有且仅有一个 直接前趋a i-1和一个直接后继a i+1。 线性表是一种典型的线性结构。
2.2 线性表的顺序表示和实现
＃define MAXNUM 100 Elemtype List1[MAXNUM] ; /*定义线性表L1*/ int length1;
Elemtype List2[MAXNUM] ; /*定义线性表L1*/ int length2;
Elemtype List3[MAXNUM] ; /*定义线性表L1*/ int length3;
2.2 线性表的顺序表示和实现
而只需要将数组和表长封装在一个结构体中，然 后定义三个结构体变量即可： struct L_list { Elemtype List[MAXNUM]; int length; }； struct L_list L1, L2, L3; /*定义三个线性表L1，L2，L3*/
2.1 线性表的类型定义
例1：26个英文字母组成的字母表 （A，B，C、…、Z） 例2：某公司2000年每月产值表(单位：万元) （400，420，500，…，600，650） 是一个长度为12的线性表。
上述两例中的每一个数据元素都是不可分割的， 在一些复杂的线性表中，每一个数据元素又可 以由若干个数据项组成。
线性表的顺序存储结构
∑
n +1 i =1
p i ( n i + 1)
1 不失一般性,若在线性表的任何位置插入元素都是等概率的,即 p i = 不失一般性,若在线性表的任何位置插入元素都是等概率的, , n + 1 上式可化简为: 上式可化简为: 1 n+1 n
Eis =
∑(n i +1) = 2 n +1
第二章 线性表
2.1 线性表的类型定义 2.2 线性表的顺序表示和实现
2.3 线性表的链式表示和实现
2.4 一元多项式的表示及相加
2.2 线性表的顺序表示和实现 线性表的顺序表示指的 是用一组地址连续的存储单 元依次存储线性表的数据元 素.
￡2.2 线性表的顺序存储结构
(1)线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性 ) 表的数据元素.如下图2.1所示 所示: 表的数据元素.如下图 所示: 存储地址 b b+l … b+(i-1)l … b+(n-1)l b+nl … b+(maxlen-1)l 内存状态 a1 a2 … ai … an 空闲 数据元素在线性表中的位序 1 2 … i … n
// 为顺序表分配大小为 maxsize 的数组空间
if (!L.elem) exit(OVERFLOW); L.length = 0; L.listsize = maxsize; return OK; 算法时间复杂度 O(1) 时间复杂度: 时间复杂度 } // InitList_Sq
(4)线性表的插入和删除运算 ) 序号 数据元素 1 2 3 4 5 6 7 8 12 13 21 24 28 30 42 77 (a) 序号 数据元素 1 2 3 4 5 6 7 8 9 12 13 21 24 25 28 30 42 77 (b) 序号 数据元素 1 2 3 4 5 6 7 8 12 13 21 24 28 30 42 77 (a) 序号 数据元素 1 2 3 4 5 6 7 12 13 21 28 30 42 77
吉林大学数据结构_第二章 线性表
如何找指定位置的结点？
• 与顺序表不同，单链表无法直接访问指定 位置的结点，而是需要从哨位结点开始， 沿着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.▍
数据结构 第2章线性表 习题 答案
第2章线性表参考答案一、填空1. 【严题集2.2①】在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与表长和该元素在表中的位置有关。
2. 线性表中结点的集合是有限的，结点间的关系是一对一的。
3. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动n-i+1 个元素。
4. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时，需向前移动n-i 个元素。
5. 在顺序表中访问任意一结点的时间复杂度均为 O(1)，因此，顺序表也称为随机存取的数据结构。
6. 【严题集2.2①】顺序表中逻辑上相邻的元素的物理位置必定相邻。
单链表中逻辑上相邻的元素的物理位置不一定相邻。
7. 【严题集2.2①】在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点的链域的值指示。
8．在n个结点的单链表中要删除已知结点*p，需找到它的前驱结点的地址，其时间复杂度为O（n）。
二、判断正误（在正确的说法后面打勾，反之打叉）（ × ）1. 链表的每个结点中都恰好包含一个指针。
答：错误。
链表中的结点可含多个指针域，分别存放多个指针。
例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。
（ × ）2. 链表的物理存储结构具有同链表一样的顺序。
错，链表的存储结构特点是无序，而链表的示意图有序。
（ × ）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。
错，链表的结点不会移动，只是指针内容改变。
（ × ）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。
错，混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。
（ × ）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。
错，正好说反了。
顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜”（ × ）6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。
数据结构导论 第2章 线性表
线性表是一种线性结构，线性结构的特点是数据元 素之间是一种线性关系，数据元素“一个接一个的 排列”。 线性结构是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++; //修改表长 } }
常见的线性表的基本运算有以下几个： 常见的线性表的基本运算有以下几个：
第二章 线性表
第二章 线性表 1． 线性表的逻辑定义、基本运算 线性表：由n个数据元素a1, a2, ……, an组成的有限序列，
长度为n。 例：成绩单，英文字母，多边形的顶点序列，实数的计算机表示，多项式的计算机表示等。
基本运算： 置空表： InitList(&L); 求表长： ListLength(L)； //返回一个整数 取表中第i个结点：GetElem(L, i, &e)；//用e返回 查找： Locate(L, x)；//x是否位于L中， //是返回true否则返回false 插入： ListInsert(&L, i, e)； //第i位置插入e，长度加1 删除： ListDelete(&L, i, &e)； //删除第i个元素，放入e中并返回 其它运算：线性表的拆分，合并，求差，求交，复制，…
例：La = La ∪ Lb // 将La与Lb元素合并，得到新的线性表La void ListUnion (List &La, List Lb) { n = ListLength(La); for (i=0; i{ GetElem(Lb, i, &x); If (LocateNode(La, x)==0) ListInsert(&La, ++n, x); } }
例：求两单调增加序列的并集(仍单调增加) La={1, 4, 5, 8, 10} Lb={2, 5, 7, 8, 12, 15} Lc=La U Lb ={1, 2, 4, 5, 7, 8, 10, 12, 15} void SetMerge(List La, List Lb, List &Lc) { La.len = ListLength(La); Lb.len = ListLength(Lb); // InitList(Lc); if (La.len ==0) { for (i=0; i{ GetElem (Lb, i, &bi); ListInsert(&Lc, i, bi); } } if (Lb.len ==0) { for (i=0; i{ GetElem (La, i, &ai); ListInsert(&Lc, i, ai); } } if ((La.len==0)||(Lb.len==0)) return; // La, Lb均非空 i=j=0; k=0; GetElem(La, i, &ai); GetElem(Lb, j, &bj); while ((iif (ai<=bj) { ListInsert(&Lc, k, ai); i++; k++; if (ielse ai = +∞; } else { ListInsert(&Lc, k, bj); j++; k++; if (jelse bj=+∞; } } // } 思考题：如何求两线性表交集La ∩ Lb?
数据结构第2章线性表A
在线性表的第i个位臵前插入一个元素的示意图如下：
1 2 3 4 插入25 5 12 1
12
13 21
13
21 24 28 30 42 77
2
3 4 5 6 7 8
24
25
6
7 8
28
30 42 77
9
16
3)删除
删除线性表的第i个位臵上的元素
实现步骤： 将第i+1 至第n 位的元素向前移动一个位臵； 表长减1。 注意：事先需要判断，删除位臵i 是否合法? 应当符合条件：1≤i≤n 或 i=[1, n] 核心语句： for ( j=i+1; j<=n; j++ )
18
2.2.3 顺序表的运算效率分析
时间效率分析:
算法时间主要耗费在移动元素的操作上，因此 计算时间复杂度的基本操作（最深层语句频度） T(n)= O (移动元素次数) 而移动元素的个数取决于插入或删除元素的位臵.
讨论1：若在长度为 n 的线性表的第 i 位前 插入一个元素， 则向后移动元素的次数f(n)为: f(n) = n – i + 1
例2 分析学生情况登记表是什么结构。
学号 姓名 性别 年龄 班级
0406010402
0406010405 0406010406 0406010410 0406010413 ：
陈杰
邓博 管杰 黄腾达 李荣智 ： ： ：
2004级计软04-1班
2004级计软04-1班 2004级计软04-1班 2004级计软04-1班 2004级计软04-1班 ：
InitList( &L ); DestoryList( &L ); //建空表，初始化 //撤销表，释放内存
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1第二章线性表本章内容2.1线性表的基本概念2.2线性表的顺序存储结构2.3线性表的链式存储结构2.4循环链表及其运算2.5双向链表及其运算
链式存储结构
一、线性表基本特征A=( a1，a2，a3，... ... , an )
(1)当1(2) 除了第一个元素与最后一个元素,序列中任何一个元素有且仅有一个直接前驱元素, 有且仅有一个直接后继元素。
(3)数据元素之间的先后顺序为“一对一”的关系。
2.1 线性表的基本概念
(4)数据元素之间具有的逻辑关系为线性关系的数据元素集合称为线性表。(5) 线性表中元素的个数N（N≥0）定义为线性表的长度。(6) 长度为0的线性表称为空表。
二、线性表的抽象数据类型定义初始化:
InitList（&L）操作结果：构造一个空的线性表L。销毁:
DestroyList(&L) 初始条件：线性表L已存在。操作结果：销毁线性表L。引用型:
不改变数据元素间的关系
加工型：改变数据元素间的关系
ADT List{ 数据对象：D={ai|ai属于ElemSet，i=1，2，…，n，n>=0}
数据关系：R1={|ai-1，ai∈D，i=1，2，…，n}
基本操作：
} ADT ListListEmpty（L）初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE。
引用型:不改变数据元素间的关系
ListLength（L）初始条件：线性表L已存在。操作结果：返回L中数据元素的个数。
GetELem（L，i，&e）初始条件：线性表L已存在，1≦i≦ListLength（L）。操作结果：用e返回L中第i个数据元素的值。
LocateElem（L，e，compare()）初始条件：线性表L已存在，compare()是数据元素判定函数。操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。若这样的数据元素不存在，则返回值为0.
引用型: 不改变数据元素间的关系PriorElem（L，cur_e，&pre_e）初始条件：线性表L已存在。操作结果：若cur_e是L中的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义。
NextElem（L，cur_e，&Next_e）初始条件：线性表L已存在。操作结果：若cur_e是L中的数据元素，且不是最后一个，则用Next_e返回它的后继，否则操作失败，next_e无定义。
ListTraverse（L，visit()）初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数visit() 。一旦visit()失败，则操作失败。2
ListInsert（&L，i，e）初始条件：线性表L已存在，1≦i≦ListLength（L）+1。操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。
加工型: 改变数据元素间的关系
ListDelete（&L，i，&e）初始条件：线性表L已存在且非空，1≦i≦ListLength（L）。操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1。PutElem（&L,，i，e）
初始条件：线性表L已存在，1≦i≦ListLength（L）。操作结果：用e改变线性表L的第i个元素的值。
ClearList（&L）初始条件：线性表L已存在。操作结果：将L重置为空表。
1. 求两个集合A和B的并集，即A∪B三、应用举例分析: 用线性表La和Lb分别表示集合A和B，求A∪B问题转化为将Lb中的所有不同于La中的元素插入到La中，则步骤如下：
1) 从线性表Lb中依次取得每个数据元素GetElem（Lb,i，e）2) 依值在线性表La中进行查访LocateElem（La，e, equal()）3) 若不存在，则插入之ListInsert（La，n+1，e）
void Union(List&La, List Lb) {intLa_len,Lb_len,i;ElemTypee;La_len= ListLength(La); Lb_len= ListLength(Lb);for (i=1; i<=Lb_len; i++) {GetElem(Lb, i, e); if (!LocateElem(La, e, equal)) ListInsert(La, ++La_len, e); }} // union
O(ListLength(La)*ListLength(lb)2. 线性表La和Lb中的数据元素按值非递减排列，归并La和Lb中的数据元素到Lc中，使Lc中的数据元素也按值非递减排列
三、应用举例
分析:La: a1,a2,…ai,…an
Lb: b1,b2,…bj,…bm
Lc: c1,c2….ck,…cm+n
其中ai、bj和ck分别是指向La、Lb和Lc的当前指针所指元素，则
当ai≥bj则ck=bj, lc和Lb的当前指针后移
否则ck=ai,lc和La的当前指针后移
三、应用举例操作步骤如下：1) 分别从LA和LB中取得当前元素ai和bj;2）若ai<=bj，则将ai插入到LC中，否则将bj插入到LC中3）若LA未取完，则继续取LA到LC4）若LB未取完，则继续取LB到LC
2. 线性表La和Lb中的数据元素按值非递减排列，归并La和Lb中的数据元素到Lc中，使Lc中的数据元素也按值非递减排列
void MergeList(ListLa, List Lb, List &Lc) {intLa_len, Lb_len;ElemTypeai, bj;inti=1, j=1, k=0;InitList(Lc);La_len= ListLength(La); Lb_len= ListLength(Lb);while ((i <= La_len) && (j <= Lb_len)) { GetElem(La, i, ai);GetElem(Lb, j, bj);if (ai<= bj) {ListInsert(Lc, ++k, ai);++i;} else { ListInsert(Lc, ++k, bj);++j;}}
} // MergeList3
void MergeList(ListLa, List Lb, List &Lc) {intLa_len, Lb_len; ElemTypeai, bj;inti=1, j=1, k=0; InitList(Lc);La_len= ListLength(La); Lb_len= ListLength(Lb);while ((i <= La_len) && (j <= Lb_len)) { GetElem(La, i, ai);GetElem(Lb, j, bj);if (ai<= bj) {ListInsert(Lc, ++k, ai);++i;} else { ListInsert(Lc, ++k, bj); ++j;}}
while (i <= La_len) {
GetElem(La, i++, ai); ListInsert(Lc, ++k, ai);}while (j <= Lb_len) {GetElem(Lb, j++, bj); ListInsert(Lc, ++k, bj);}} // MergeList
O(ListLength(La)+ListLength(lb)用一组地址连续的存储单元依次存放线性表中的数据元素，数据元素之间的逻辑关系通过数据元素的存储位置直接反映。
一、构造原理
( a1，a2，a3，... ... , an )所谓一个元素的地址是指该元素占用的若干(连续的)存储单元的第一个单元的地址。
LOC(ai)a1a2a3an……
d1d2 d3……dn
k个单元
2.2 线性表的顺序存储
若假设每个数据元素占用k个存储单元，并且已知第一个元素的存储位置LOC(a1)，则有
LOC(ai) = LOC(a1)+(i−1)×k
a1a2a3an……
结论：
例：LOC(a1)=100 k=4 求LOC(a5)=?
a1a2a3an……a4a5
100 104 108 112 116
LOC(a5) = 100+(5 −1)×4=116
顺序存储示意图(a1, a2, a3, ... ... , an-1, an )
0 1 2 3 …n-2 n-1 n n+1 …M-1……………a2a1a3an-1a
n
事先分配给线性表的空间
当前已经占用的空间尚未使用的空间
#define MaxSize100ElemTypeA[MaxSize];intn;
在C语言中预先分配给线性表的空间大小
表的长度
顺序表
A[0], A[1], …, A[n−1], …如何预先分配线性表存储空间的大小？#defineLIST_INIT_SIZE 100//线性表存储空间的初始分量
#define LISTINCREMENT 10//线性表存储空间的分配增量Typedefstruct{ElemType*elem;//存储空间基址Intlength;//表的当前长度Intlistsize;//当前分配的存储容量（以sizeof(ElemType)//为单位）} SqList；
线性表的动态分配顺序存储结构表示