第二章 线性表
第二章 线性表
（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依然是有序的。（基于对顺序表的拆分 和合并操作的运算）
线性表栈和队列
while( p !=NULL && j < i ) { p=p->link; j++; } // 指向第i结点，i＝0,1,…，当链表 //中结点数小于i时返回NULL return p; }
单链表插入算法
// 插入数据内容为value的新结点，为第i个 结点。 ListNode * Insert(ELEM value, int i) { ListNode *p，*q; q = new ListNode; p = FindIndex(i-1); if(p == NULL ) return NULL;
}
2.2.2
Байду номын сангаас
向量的运算
插入元素运算
void insert( item) ELEM remove( )
删除元素运算
插入算法
/*（设元素的类型为ELEM，nodelist是存储顺序表的 向量， msize 是此向量的最大长度， curr_len 是此向 量的当前长度，curr为此向量当前下标）*/ ＃include <assert.h> viod insert(ELEM item) { //需要检查当前长度不能等于msize，当前游标指针 //curr不能小于0,也不能大于当前长度
q->link = p->link; q->data = value; p->link = q; if(q->link == NULL ) last=q; return q;
}
插入过程
单链表删除算法
//删除由参数link所指定的结点
void RemoveAfter(ListNode * link) { ListNode *newlink=link; if(link!=NULL) link=link->link; delete newlink; }
数据结构第二章：线性表
实现：可用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++语言版)》第2章 线性表
数据结构与算法 （C++语言版）
第2章 线性表
线性表的类型定义
• 基本概念 • 线性表是由n（n≥0）个类型相同的数据元素组成的有限序 列，通常表示为L=(a1, …, ai–1, ai, ai+1, …, an)。其中，L为线 性表名称，ai为组成该线性表的数据元素，ai–1领先于ai，ai 领先于ai+1，称ai–1是ai的直接前驱元素，ai+1是ai的直接后继 元素。当i=1, 2, …, n–1时，ai有且仅有一个直接后继；当 i=2, 3, …, n时，ai有且仅有一个直接前驱。 • 线性表的长度就是线性表中元素的个数n（n≥0）。当n=0时， 称为空表。在非空表中的每个数据元素都有一个确定的位 置，如a1是第一个数据元素，an是最后一个数据元素，ai是 第i个数据元素。称i为数据元素ai在线性表中的位序。
线性表的类型定义
Prev_Elem(L, cur_e, &pre_e) //返回当前元素的前一个元素值 输入：线性表L。 输出：若cur_e是线性表L的数据元素，且不是第一个，则用 pre_e返回它的直接前驱元 素；否则操作失败，pre_e无定义。 Next_Elem(L, cur_e, &next_e) //返回当前元素的后一个元素值 输入：线性表L。 输出：若cur_e是线性表L的数据元素，且不是最后一个，则用 next_e返回它的直接后继元素；否则操作失败，next_e无定 义。
线性表
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的线性表。
上述两例中的每一个数据元素都是不可分割的， 在一些复杂的线性表中，每一个数据元素又可 以由若干个数据项组成。
数据结构课件第2章线性表
27
线性表的顺序存储结构适用于数据 元素不经常变动或只需在顺序存取设备 上做成批处理的场合。为了克服线性表 顺序存储结构的缺点，可采用线性表的 链式存储结构。
28
2.3 线性表的链式存储结构
线性表的链式存储表示 基本操作在单链表上的实现 循环链表 双向链表 线性表链式存储结构小结
2.3.1 线性表的链式存储表示 29
2.1.1 线性表的定义
6
一个线性表（linear_list）是 n（n≥0）个具有相同属性的数 据元素的有限序列，其中各元素有着依次相邻的逻辑关系。
线性表中数据元素的个数 n 称为线性表的长度。当 n = 0 时 该线性表称为空表。当 n > 0 时该线性表可以记为：
（a1，a2，a3，…，ai，…，an）
数据域 指针域
结点 data next
31
(2) 线性表的单链表存储结构
通过每个结点的指针域将线性表中 n 个结点按其逻辑顺序链 接在一起的结点序列称为链表，即为线性表 ( a1, a2, a3, …, ai, …, an ) 的链式存储结构。如果线性链表中的每个结点只有一个指针域， 则链表又称为线性链表或单链表 (linked list)。
17
(2) 算法编写
#define OK 1
#define ERROR 0
Int InsList ( SeqList *L, int i, ElemType e ) /*在顺序线性表 L 中第 i 个位置插入新的元素 e。*/ /* i 的合法值为 1≤i ≤L->last+2*/ {
int k; if ( i < 1) ||( i > L->last+2)) /*首先判断插入位置是否合法*/ { printf(“插入位置i值不合法”）；
第二章线性表
；查询通讯录信息。
第2页
目录
目录 退出
第二章 线性表
struct TelRed {char name[20]; char tel[12]; }; struct TelRed TelBook[100]; int length; 结构体数组TelBook和表示通讯录长度length二者实际 上是作为通讯录的一部分出现的，将二者作为一个整体来 表示通讯录。
第21页
目录
目录 退出
第二章 线性表
算法思想：
1）检查 i 值是否超出所允许的范围 (1 i n + 1) ，若超出
，则进行“超出范围”错误处理； 2）将线性表的第 i 个元素和它后面的所有元素均后移一个 位置； 3）将新元素写入到空出的第 i 个位置上；
4）使线性表的长度增 1。
第22页
第10页
目录
目录 退出
第二章 线性表
③ DestroyList(&L) 初始条件：线性表L已存在。
操作结果：销毁线性表L。
④ ClearList(&L) 初始条件：线性表L已存在。 操作结果：将L置为空表。 ⑤ EmptyList(L) 初始条件：线性表L已存在。 操作结果：如果L为空表，则返回TRUE，否则返回FALSE。 ⑥ GetData(L,i,&a) 初始条件：表L存在，且1≤i≤ListLength(L)。 操作结果：用a返回线性表L中第i个数据元素的值。
2、有且仅有一个终端结点 an，它没有直接后继，而仅有 一个直
接前趋 an -1， an 叫表尾元素；
3、其余的内部结点 ai (2 i n -1) 都有且仅有一个直接 前趋 ai –1
和一个直接后继 ai +1。
吉林大学数据结构_第二章 线性表
如何找指定位置的结点？
• 与顺序表不同，单链表无法直接访问指定 位置的结点，而是需要从哨位结点开始， 沿着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、其它操作 复制、分解、合并、分类等
第2章 线性表
【例2】巳知有两个按元素值递增有序的顺序表La和 Lb，设计一个算法将表La和表Lb的全部元素归并 为一个按元素值递增有序的顺序表Lc。
算法思路：用i扫描顺序表La，用j扫描顺序表Lb。 当表La和表Lb都未扫描完时，比较两者的当前元 素，将较小者插入表Lc的表尾，若两者的当前元 素相等，则将这两个元素依次插入表Lc的表尾。 最后，将尚为扫描完的顺序表的余下部分元素依 次插入表Lc的表尾。算法如下： void MergeList_Sq(SqList La, SqList Lb, SqList &Lc)
表中ai-1领先于ai，称ai-1是ai的直接前驱，ai+1是 ai的直接后继。
线性表的抽象数据类型定义 （参见教材）
返回本章目录
2.2 线性表的顺序存储结构
线性表的顺序存储是指在内存中用地址连续的一块存储空间 依次存放线性表的数据元素，用这种存储形式存储的线性表 称其为顺序表。 假设每个数据元素占d个存储单元，且将ai的存储地址表示为 Loc(ai)，则有如下关系： Loc(ai)=Loc(a1)+(i-1)*d Loc(a1)是线性表的第一个数据元素a1的存储地址，通常 称作线性表的基地址。
【例1】 编写一算法，从顺序表中删除自第i个元素开 始的k个元素。 算法思路： 为保持顺序表的逻辑特性，需将i+k ~ n位 置的所有元素依次前移k个位置。算法如下：
int deleteK(Sqlist &sq,int i,int k)
{ if (i<1||k<1||i+k-1>sq.len) return 0; for (j=i+k-1;j<=sq.len-1;j++) sq.data[j-k]=sq.data[j]; sq.len-=k; return 1; }// deleteK
DSFA第2章
14
template<class T> bool SeqList<T>::Find(int i,T& x) const { if (i<0 || i>n-1) { cout<<"Out of Bounds"<<endl; return false; } x=elements[i]; return true; } 渐近时间复杂度：O(1)
渐近时间复杂度：O(n)
18
nHale Waihona Puke 1（3）删除操作 Delete(i)： 删除元素ai。 删除它
前移n-i-1个元素
a0
0
… ai-1 ai ai+1 … … an-1 … …
… i-1 i i+1 i+2 … 删除操作 n-1 … maxLength-1
19
删除操作算法： template <class T> bool SeqList<T>::Delete(int i) { if ( !n ) { cout<<"UnderFlow"<<endl; return false; } if ( i<0 || i>n-1 ) { cout<<"Out Of Bounds"<<endl; return false; } for (int j=i+1;j<n;j++) elements[j-1]=elements[j]; n--; return true; }
4. 动态一维数组描述顺序表
class SeqList:public LinearList<T> { public: SeqList(int mSize); …… private: int maxLength; T *elements; //动态一维数组的指针 }
第2章 线性表
数。
第2章 线性表
2.2 线性表的顺序存储结构表示
图2-2所示为线性表在存储介质中顺序分配的情况。
第2章 线性表
逻辑地址 1 2 记录内容 a1 a2 存储地址 LOC(a ) 1 LOC(a )＋k 1 内存状况 a1 a2
…
i
…
ai LOC(a )＋(i－1)× k 1
…
ai
…
n
图2-2 线性表的顺序分配
第2章 线性表
2.3 线性表元素的操作
2.3.1 线性表元素插入操作 插入一个记录，对有序线性表结构的影响可以从以下 两个方面分析。
(1) 若插入记录关键字的值比表中所有的数据元素的
关键字值都大，那么只需在表后添加一个新记录元素，同 时使表的当前长度修正为n+1即可。
(2) 若插入记录的位置出现在线性表的中间，则情况
LOC(ai)=LOC(a1)+(i-1)×k
从以上的地址计算公式可知，只要已知线性表第 一个数据元素在内存中的存储地址，又知道每一个数 据元素所占存储单元的个数，就能计算出第i个数据元 素在内存中的位置。
第2章 线性表 例如，线性表中第一个数据元素在内存中的地址 LOC(a1)为1000，每一个数据元素占用2个存储单位，
名称“数据结构”的属性就不相同，它们分别为字符
型和数值型。
第2章 线性表 2.1.2 线性表的逻辑结构表示 在任何问题中，数据元素之间可以存在多种关系。 从数据结构的观点来看，重要的是数据元素之间的逻辑 关系。所谓逻辑关系，是指数据元素之间的关联方式或 称“邻接关系”。表2-1中数据的逻辑结构如图2-1(b)所 示，其中的圆圈称为结点。一个结点代表一个数据元素 (有时也把结点和数据元素当作同义词)，结点之间的连 线代表逻辑关系，即相应数据元素之间的邻接关系。图 2-1(b)中的逻辑结构反映了表2-1中表格作为一个数据的 组织形式，这种组织形式就是数据元素(记录)“一个接 一个地排列”。
第二章线性表
65
865
姓名
学号
成绩
班级 机97性表
※线性表及运算 ※线性表的存储结构
2.1线性表及运算
线性表是n个元素的有限序列，它们之间的关 系可以排成一个线性序列：
a1，a2，…… ，ai，…… ，an
其中n称作表的长度，当n=0时，称作空表。
线性表的特点：
1.线性表中所有元素的性质相同。 2.除第一个和最后一个数据元素之外，其它数据元 素有且仅有一个前驱和一个后继。第一个数据元 素无前驱，最后一个数据元素无后继。
Status ListInsert_L(LinkList &L,int i, ElemType x){ p=L; j=0; while( p&&j<i-1)
P P
a a
b b
{p=p->next; ++j;}
if( ! p j>i-1) return ERROR;
s=(struct LNode *)malloc(sizeof(struct LNode)); s->data=x; s->next=p->next; p->next=s;
3.数据元素在表中的位置只取决于它自身的序号。
在线性表上常用的运算有：
初始化、求长度、取元素、定位、插 入及删除等。
2.2 线性表的存储结构
1.顺序存储结构
2.链式存储结构
2.1. 线性表的顺序存储结构 ,可用C语言中的一维数组来描述. #define LISTINITSIZE 100 //线性表存储空间的初始分配量
s=(struct LNode *)malloc(sizeof(struct LNode)); s->data=x; s->next=p->next; p->next=s;
数据结构导论 第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++; //修改表长 } }
常见的线性表的基本运算有以下几个： 常见的线性表的基本运算有以下几个：
第2章 线性表
本算法的时间复杂度为O(1)。
(5) 输出线性表DispList(L) 该运算当线性表L不为空时,顺序显示L中各元素的 值。
void DispList(SqList *L)
{
int i; if (ListEmpty(L)) return;
for (i=0;i<L->length;i++)
printf("%c",L->data[i]); printf("\n");
⑤ 将表的长度加1。
(7) 定位查找LocateElem(L,e):返回L中第1个值域 与e相等的位序。若这样的元素不存在,则返回值为0。 (8) 插 入 数 据 元 素 ListInsert(&L,i,e): 在 L 的 第 i(1≤i≤ListLength(L)+1)个元素之前插入新的元素e,L 的长度增1。 (9) 删除数据元素ListDelete(&L,i,&e):删除L的第 i(1≤i≤ListLength(L))个元素,并用e返回其值,L的长度 减1。
(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)) 个元素的值。
线性表的存储示意图
1. 建立顺序表 其方法是将给定的含有n个元素的数组的 每个元素依次放入到顺序表中，并将n赋给顺 序表的长度成员。算法如下：
数据结构 第二章__线性表(本)
数据结构与算法华东师范大学计算机系杨沛第二章线性表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.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)。
第二章线性表练习题一、单选题1．在一个长度为n的顺序存储线性表中，向第i个元素(1≤i≤n+1)之前插入一个新元素时，需要从后向前依次后移( )个元素。
A、n-iB、n-i+1C、n-i-1D、i2．在一个长度为n的顺序存储线性表中，删除第i个元素(1≤i ≤n+1)时，需要从前向后依次前移( )个元素。
A、n-iB、n-i+1C、n-i-1D、i3．在一个长度为n的线性表中顺序查找值为x的元素时，查找时的平均查找长度（即x同元素的平均比较次数，假定查找每个元素的概率都相等）为( )。
A、nB、n/2C、(n+1)/2D、(n-1)/24．在一个单链表HL中，若要向表头插入一个由指针p指向的结点，则执行( )。
A、HL = p; p->next = HL;B、p->next = HL; HL = p;C、p->next = HL; p = HL;D、p->next = HL->next; HL->next = p;5．在一个单链表HL中，若要在指针q所指的结点的后面插入一个由指针p所指的结点，则执行( )。
A、q->next = p->next ; p->next = q;B、p->next = q->next; q = p;C、q->next = p->next; p->next = q;D、p->next = q->next ; q->next = p;6．在一个单链表HL中，若要删除由指针q所指向结点的后继结点，则执行( )。
A、p = q->next ; p->next = q->next;B、p = q->next ; q->next = p;C、p = q->next ; q->next = p->next;D、q->next = q->next->next; q->next = q;7. 下面关于线性表的叙述错误的是（）。
(A) 线性表采用顺序存储必须占用一片连续的存储空间(B) 线性表采用链式存储不必占用一片连续的存储空间(C) 线性表采用链式存储便于插入和删除操作的实现(D) 线性表采用顺序存储便于插入和删除操作的实现8、设指针变量p指向单链表中结点A，若删除单链表中结点A，则需要修改指针的操作序列为（）。
(A) q=p->next；p->data=q->data；p->next=q->next；free(q)；(B) q=p->next；q->data=p->data；p->next=q->next；free(q)；(C) q=p->next；p->next=q->next；free(q)；(D) q=p->next；p->data=q->data；free(q)；9、设一个有序的单链表中有n个结点，现要求插入一个新结点后使得单链表仍然保持有序，则该操作的时间复杂度为（）。
(A) O(log2n) (B) O(1) (C) O(n2) (D) O(n)10、设一条单链表的头指针变量为head且该链表没有头结点，则其判空条件是（）。
(A) head==0(B) head->next==0(C) head->next==head (D) head!=011．通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着( )。
A．数据元素具有同一特点B．不仅数据元素所包含的数据项的个数要相同，而且对应的数据项的类型要一致C．每个数据元素都一样D．数据元素所包含的数据项的个数要相等12．链表不具备的特点是( )。
A．可随机访问任一结点B．插入删除不需要移动元素C．不必事先估计存储空间D．所需空间与其长度成正比13．在一个长度为n（n>1）的单链表上，设有头和尾两个指针，执行( )操作与链表的长度有关。
A．删除单链表中的第一个元素B．删除单链表中的最后一个元素C．在单链表第一个元素前插入一个新元素D．在单链表最后一个元素后插入一个新元素14．下述哪一条是顺序存储结构的优点？( )。
A插入运算方便B可方便地用于各种逻辑结构的存储表示C存储密度大D删除运算方便15．下面关于线性表的叙述中，错误的是哪一个？( )。
A线性表采用顺序存储，必须占用一片连续的存储单元B线性表采用顺序存储，便于进行插入和删除操作。
C线性表采用链式存储，不必占用一片连续的存储单元D线性表采用链式存储，便于进行插入和删除操作。
16．线性表是具有n个( )的有限序列。
A．字符B．数据元素C．数据项D．表元素17．在n个结点的线性表的数组实现中，算法的时间复杂度是O（1）的操作是( )。
A．访问第i（1<=i<=n）个结点和求第i个结点的直接前驱（1<i<=n）B．在第i（1<=i<=n）个结点后插入一个新结点C．删除第i（1<=i<=n）个结点D．以上都不对18．下面关于线性表的叙述错误的是（）。
(A) 线性表采用顺序存储必须占用一片连续的存储空间(B) 线性表采用链式存储不必占用一片连续的存储空间(C) 线性表采用链式存储便于插入和删除操作的实现(D) 线性表采用顺序存储便于插入和删除操作的实现19.用无头结点链接方式存储的队列，在进行插入运算时( ).A. 仅修改头指针B. 头、尾指针都要修改C. 仅修改尾指针D.头、尾指针可能都要修改20．设指针变量p指向单链表中结点A，若删除单链表中结点A，则需要修改指针的操作序列为（）。
(A) q=p->next；p->data=q->data；p->next=q->next；free(q)；(B) q=p->next；q->data=p->data；p->next=q->next；free(q)；(C) q=p->next；p->next=q->next；free(q)；(D) q=p->next；p->data=q->data；free(q)；21.设一个有序的单链表中有n个结点，现要求插入一个新结点后使得单链表仍然保持有序，则该操作的时间复杂度为（）。
(A) O(log2n) (B) O(1) (C) O(n2) (D) O(n)22. 设一条单链表的头指针变量为head且该链表没有头结点，则其判空条件是（）。
(A) head==0 (B) head->next==0(C) head->next==head (D) head!=023.建立一个长度为n的有序单链表的时间复杂度为（）(A) O(n) (B) O(1) (C) O(n2)(D) O(log2n)24. 设顺序线性表中有n个数据元素，则删除表中第i个元素需要移动（）个元素。
(A) n-i(B) n+l -i (C) n-1-i (D) i25. 设指针变量p指向双向链表中结点A，指针变量s指向被插入的结点X，则在结点A的后面插入结点X的操作序列为（）。
(A) p->right=s；s->left=p；p->right->left=s；s->right=p->right；(B) s->left=p；s->right=p->right；p->right=s；p->right->left=s；(C) p->right=s；p->right->left=s；s->left=p；s->right=p->right；(D) s->left=p；s->right=p->right；p->right->left=s；p->right=s；26. 设顺序表的长度为n，则顺序查找的平均比较次数为（）。
(A) n (B) n/2 (C) (n+1)/2 (D) (n-1)/227. 设某链表中最常用的操作是在链表的尾部插入或删除元素，则选用下列（）存储方式最节省运算时间。
(A) 单向链表(B) 单向循环链表(C) 双向链表(D) 双向循环链表28．设指针q指向单链表中结点A，指针p指向单链表中结点A的后继结点B，指针s指向被插入的结点X，则在结点A和结点B插入结点X的操作序列为（）。
(A) s->next=p->next；p->next=-s；(B) q->next=s；s->next=p；(C) p->next=s->next；s->next=p；(D) p->next=s；s->next=q；二、填空题1．在线性表的单链接存储结构中，每个结点包含有两个域，一个叫域，另一个叫域。
2．对于一个长度为n的顺序存储的线性表，在表头插入元素的时间复杂度为，在表尾插入元素的时间复杂度为。
3．对于一个长度为n的单链接存储的线性表，在表头插入元素的时间复杂度为，在表尾插入元素的时间复杂度为。
4．在线性表的顺序存储中，若一个元素的下标为i，则它的前驱元素的下标为，后继元素的下标为。
5．在线性表的单链接存储中，若一个元素所在结点的地址为p，则其后继结点的地址为，若假定p为一个数组a中的下标，则其后继结点的下标为。
6、设指针p指向单链表中结点A，指针s指向被插入的结点X，则在结点A的前面插入结点X时的操作序列为：1) s->next=___________；2) p->next=s；3) t=p->data；4) p->data=___________；5) s->data=t；7．设指针变量p指向双向循环链表中的结点X，则删除结点X需要执行的语句序列为_________________________________________________________（设结点中的两个指针域分别为llink和rlink）。
8.设指针变量p指向双向链表中的结点A，指针变量s指向被插入的结点X，则在结点A的后面插入结点X的操作序列为_________=p；s->right=p->right；__________=s； p->right->left=s；（设结点中的两个指针域分别为left和right）。
9．设顺序线性表中有n个数据元素，则第i个位置上插入一个数据元素需要移动表中_______个数据元素；删除第i个位置上的数据元素需要移动表中_______个元素。