数据结构_线性表及其基本算法讲解
数据结构 线性表
第1讲线性表本章主要掌握如下内容：线性表的定义和基本操作，线性表的实现,线性表的顺序存储结构及链式存储结构，线性表的应用。
知识点分析（一）线性表的定义和基本操作1．线性表基本概念1）定义：是由相同类型的结点组成的有限序列。
如：由n个结点组成的线性表（a1, a2, …, a n）a1是最前结点，a n是最后结点。
结点也称为数据元素或者记录。
2）线性表的长度：线性表中结点的个数称为其长度。
长度为0的线性表称为空表。
3）结点之间的关系：设线性表记为（a1,a2,…a i-1 , a i, a i+1 ,…a n），称a i-1是a i的直接前驱结点．．．．（简称前驱），a i+1是a i的直接后继结点．．．．（简称后继）。
4）线性表的性质：①线性表结点间的相对位置是固定．．的，结点间的关系由结点在表中的位置确定。
②如果两个线性表有相同的数据结点，但它们的结点顺序不一致，该两个线性表也是不相等的。
注意：线性表中结点的类型可以是任何数据（包括简单类型和复杂类型），即结点可以有多个成分，其中能唯一标识表元的成分称为关键字（key），或简称键。
以后的讨论都只考虑键，而忽略其它成分，这样有利于把握主要问题，便于理解。
『经典例题解析』线性表的特点是每个元素都有一个前驱和一个后继。
( )【答案】错误。
【解析】线性表的第一个数据元素没有前驱，最后一个元素没有后继。
其余的所有元素都有一个前驱和后继。
2．线性表的抽象数据类型线性表是一个相当灵活的数据结构，其长度可以根据需要增加或减少。
从操作上讲，用户不仅可以对线性表的数据元素进行访问操作，还可以进行插入、删除、定位等操作。
1）线性表的基本操作假设线性表L有数据对象 D＝{ai | ai∈ElemSet，i=1,2,3,…,n，n>=0},数据元素之间的关系R＝{<ai-1,ai>|ai-1,ai∈D,i=1,2,…,n},则线性表L的基本操作如下所示：●InitList(&L)：其作用是构造一个长度为0的线性表（空线性表）；●DestoryList(&L)：其作用是销毁当前的线性表L；●ClearList(&L)：清空线性表L，使之成为空表；●ListLength(L)：返回线性表L的长度，即线性表中数据元素的个数；●ListEmpty(L) ：判断线性表L是否为空表，是则返回True，否则返回False；●GetElem(L,i,&e)：将线性表L中第i个数据元素的值返回到变量e中；●LocateELem(L,e,compare( )) ：判断线性表L中是否存在与e满足compare（）条件的数据元素，有则返回第一个数据元素；●PriorElem(L,cur_e,&pri_e)：返回线性表L中数据元素cur_e的前驱结点；●NextElem(L,cur_e,&next_e)：返回线性表L中数据元素cur_e的后继结点；●ListInsert(&L,i,e)：向线性表L的第i个位置之前插入一个数据元素，其值为e；●ListDelete(&L,i,&e)：删除线性表L的第i个数据元素，并将该数据元素的值返回到e中；●ListTraverse(L,visit())：遍历线性表中的每个数据元素。
数据结构第1讲---线性表
34F2 地址 被释放，变 量P与地址 34F2没有关 系
p1^
200 34F2
34F2
new（p1） ——向计算机申请内存地址 p1^:=200 ——给p1指向的单元赋值 dispose(p1) ——释放存储单元
链式结构——什么是指针
Type p=^integer; arr=array[1..4] of char; arrp = ^arr; Var p1:p; p2:arrp;
线性结构 数据的逻辑结构 数 据 结 构 树形结构 图形结构 数据的存储结构 顺序存储
链式存储
数据结构的基本运算 :查找、插入、删除等
三、线性结构——线性表
1、线性表的概念
线性表是由n（n≥0）个具有相同特性数据元素(结点)
a1，a2，…，an组成的有限序列。
线性表的长度：所含元素的个数,用n表示，n>=０。
在我们生活中有哪些属于线性表的例子,列举几个。 1、英文字母表（A，B，…，Z）是线性表， 表中每个字母是一个数据元素（结点）
2、学生成绩表中，每个学生及其成绩是一
个数据元素，其中数据元素由学号、姓名、
各科成绩及平均成绩等数据项组成。
4、线性表的顺序存储
顺序存储是线性表的一种最 简单的存储结构，存储方式是： 在内存中为线性表开辟一块连 续的存储空间。用数组来存放 每一个节点。
[例4-2] 法雷序列
[问题描述]对任意给定的一个自然数n（n<=100），将 分母小于等于n的不可约的真分数按上升次序排序，并 且在第一个分数前加0/1，而在最后一个分数后加1/1, 这个序列称为n级的法雷序列。 当n=8时序列为：0/1, 1/8, 1/7, 1/6,1/5, 1/4,2/7,1/3,3/8, 2/5,3/7,1/2,4/7,3/5,5/8,2/3,5/7,3/4, 4/5,5/6,6/7,7/8, 1/1 。 编程求出n级的法雷序列，每行输出10个分数。
数据结构第二章：线性表
实现：可用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章线性表
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值不合法”）；
《数据结构》课程课件第二章线性表
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、其它操作 复制、分解、合并、分类等
数据结构线性表ppt课件
01
02
03
04
插入操作
在链表的指定位置插入一个新 节点，需要修改相邻节点的指
针。
删除操作
删除链表的指定节点，需要修 改相邻节点的指针。
查找操作
从链表的头节点开始，顺序遍 历链表，直到找到目标元素或
遍历到链表末尾。
遍历操作
从链表的头节点开始，顺序访 问每个节点，直到遍历到链表
末尾。
04 线性表应用举例 与问题分析
多项式表示与计算问题
01
02
03
多项式表示方法
数组表示法和链表表示法 。
数组表示法
将多项式的系数按次序存 放在一个数组中，通过下 标表示对应的幂次。
链表表示法
每个节点包含系数和指数 两个数据域，以及一个指 向下一个节点的指针域。
一元多项式相加算法设计
• 算法思想：将两个多项式中的同类项系数相加，得到新的 多项式。
删除操作
删除指定位置i的元素，需要将i之后的元素都向前移动 一个位置。
03 链式存储结构及 其实现
链式存储结构原理及特点
链式存储结构原理
使用一组任意的存储单元存储线 性表的数据元素（这组存储单元 可以是连续的，也可以是不连续 的）。
链式存储结构特点
逻辑上相邻的元素在物理位置上 不一定相邻，元素之间的逻辑关 系是通过指针链接来表示的。
...，an组成的有序序列。
性质
集合中必存在唯一的一个“第一元素 ”。
集合中必存在唯一的一个“最后元素 ”。
除最后元素之外，均有唯一的后继。
除第一元素之外，均有唯一的前驱。
线性表与数组关系
数组是线性表的一种表现和实现形式。
线性表更侧重于逻辑概念，而数组则是这种逻辑概念在计算机中的一种存储方式。
第2章 线性表 (数据结构教程PPT课件)
3.在数组a中检索（查找）值为X的数据元素
int locate (int a[ ],int n, int x) { int i; i=0; while((i<=n-1)&&(a[i]!=x)) i++; if(i<=n-1) return (i); /*返回的是存储位置*/ else return (0);} }
(2)按值查找即定位 Locate_LinkList(L,x) Lnode * Locate_LinkList( LinkList L, datatype x) /*在单链表L中查找值为x的结点，找到后 返回其指针，否则返回空*/ { Lnode * p=L->next; while ( p!=NULL && p->data != x) p=p->next; return p; }
2.2.2 典型操作的算法实现
1. 初始化线性表L
SeqList *init_SeqList( )
{ SeqList *L; L=malloc(sizeof(SeqList)); L->last=-1; return L; }
2.在数组a第i个数据元素之（ai-1）前插入数据 元素X insert (int a[ ],int n,int i, int x) { int j; for(j=n-1;j>=i-1;j--) a[j+1]=a[j]; /* 结点移动 */ a[i-1]=x; /*新元素插入*/ n++; /*修改长度*/ }
4.删除数组a第i个数据元素（ai-1） delete (int a[ ],int n,int i) { int j; for(j=i;j<=n;j++) a[j-1]=a[j]; /* 结点移动 */ n--; /*修改长度*/ }
数据结构线性表
数据结构---线性表线性表代码主要参考严蔚敏《数据结构（c语言版）》，有部分改动线性表的定义定义•线性表是具有相同的数据类型的n(n >= 0)个数据元素的有限序列，当n=0时线性表为一个空表•用L表示线性表则L = （a1,a2,a3,…,ano a1为表头元素，an为表尾元素o a1无直接前驱，an无直接后继特点•表中元素个数有限•表中元素具有逻辑上的顺序，表中元素有先后次序•表中元素都是数据元素•表中元素的数据类型都相同，每个元素占的空间大小一致要点数据项、数据元素、线性表的关系线性表由若干个数据元素组成，而数据元素又由若干个数据项组成，数据项是数据的不可分割的最小单位。
其中姓名，学号等就是数据项线性表的顺序表示顺序表的定义顺序表是指用一组地址连续的存储单元依次存储信息表中的数据元素，从而使得逻辑相邻的两个元素在物理位置上也相邻预先定义（为了代码可以运行）#define True 1#define False 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;第n个元素的内存地址表示为LOC(A) + (n-1)*sizeof(ElemType)假定线性表的元素类型为ElemType,则线性表的顺序存储类型描述为typedef int ElemType ;#define MaxSize 50typedef struct{ElemType data[MaxSize];int length;}SqList;一维数组可以是静态分配的，也可以是动态分配的。
静态分配后大小和空间都固定了，下面使用动态分配的形式typedef int ElemType ;#define InitSize 100 //表长度的初始大小定义#define ListIncreasement 10 //线性表存储空间的分配增量typedef struct{ElemType *data;int MaxSize,length;}SeqList;顺序表的初始化顺序表的初始化,&是C++的引用，可以使用指针代替Status InitList(SeqList &L){L.data = (ElemType *) malloc(InitSize * sizeof(ElemType));if(! L.data) exit(OVERFLOW);//存储分配失败L.length = 0;L.MaxSize = InitSize;return OK;}顺序表的插入在顺序表L的第i(1<= i <= L.length +1)个位置插入新元素e，需要将第n 个至第i (共n-i+1)个元素向后移动一个位置【最后一个到倒数第n-i+i个元素向后移动一位】。
线性表 数据结构讲义
a1 a2 … ai-1 ai+1 … an
表的长度减1
演示
int ListDelete (SqList *&L，int i，ElemType &e)
{
int j;
if (i<1 || i>L->length) return 0; i--; /*将顺序表位序转化为elem下标*/
e=L->elem[i];
typedef struct {
存放元素
ElemType elem[MaxSize];
int length;
存放线性表的实 际长度
} SqList； /*顺序表类型*/
2 顺序表基本运算的实现
(1)初始化线性表 InitList(L) 只需将length成员设置为0即可。
void InitList (SqList *&L) //引用型指针 {
/*顺序表长度增1*/
return 1;
}
演示
元素移动的次数与两个因素有关： 表长L—>length（n）； 插入位置i（有n+1个可能的插入位置）。
假设pi(=
)是在第i个位置上插入一个元素的
概率，则在长度为n的线性表中插入一个元素时所需
移动元素的平均次数为:
p n1
n1 1
n
(n i 1)
当n=0时，表示线性表是一个空表，即表中 不包含任何元素。
设序列中第i（i表示位序）个元素为ai(1≤i≤n)， 则线性表的一般表示为：
(a1，a2，…，ai，ai+1，…，an)
例如，在线性表(1，4，3，2，8，10)中，1 为表头元素，10为表尾元素。
2 线性表的运算
数据结构与算法线性表.ppt
线性结构分类
按操作划分
线性表
• 所有表目都是同一类型结点的线性表 • 不限制操作形式 • 根据存储的不同分为：顺序表，链表
栈(LIFO, Last In First Out)
• 插入和删除操作都限制在表的同一端进行
队列(FIFO, First In First Out)
• 插入操作在表的一端， 删除操作在另一端
bool append(const T value); // 在表尾添加一个元素value，表的长度增1
bool insert(const int p, const T value);
// 在位置p上插入一个元素value，表的长度增1
bool delete(const int p);
// 删除位置p上的元素，表的长度减 1
bool getPos(int & p, const T value)
// 查找值为value的元素并返回其位置
bool getValue(const int p, T& value);
// 把位置p的元素值返回到变量value中
bool setValue(const int p, const T value);// 用value修改位置p的元素值
有序性：各数据元素在线性表中都有自己的位置，且 数据元素之间的相对位置是线性的
线性结构
包括：
简单的
• 线性表 •栈 • 队列 • 散列表
高级的
• 广义表 • 多维数组 • 文件
……
线性结构分类
按访问方式划分
直接访问型(direct access) 顺序访问型( sequential access) 目录索引型(directory access)
数据结构之线性表详细解答
二章线性表线性表是最简单、最基本、也是最常用的一种线性结构。
它有两种存储方法：顺序存储和链式存储，它的主要基本操作是插入、删除和检索等。
2.1 线性表的逻辑结构2.1.1 线性表的定义线性表是一种线性结构。
线性结构的特点是数据元素之间是一种线性关系，数据元素“一个接一个的排列”。
在一个线性表中数据元素的类型是相同的，或者说线性表是由同一类型的数据元素构成的线性结构。
在实际问题中线性表的例子是很多的，如学生情况信息表是一个线性表：表中数据元素的类型为学生类型; 一个字符串也是一个线性表：表中数据元素的类型为字符型，等等。
综上所述，线性表定义如下：线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，通常记为：(a1，a2，… a i-1，a i，a i+1，…a n)其中n为表长，n＝0 时称为空表。
表中相邻元素之间存在着顺序关系。
将a i-1 称为a i 的直接前趋，a i+1 称为a i 的直接后继。
就是说：对于a i，当i=2，...，n 时，有且仅有一个直接前趋a i-1.，当i=1，2，...，n-1 时，有且仅有一个直接后继a i+1，而a1 是表中第一个元素，它没有前趋，a n 是最后一个元素无后继。
需要说明的是：a i为序号为i 的数据元素（i=1,2,…,n），通常我们将它的数据类型抽象为datatype，datatype根据具体问题而定，如在学生情况信息表中，它是用户自定义的学生类型; 在字符串中，它是字符型; 等等。
2.1.2 线性表的基本操作在第一章中提到，数据结构的运算是定义在逻辑结构层次上的，而运算的具体实现是建立在存储结构上的，因此下面定义的线性表的基本运算作为逻辑结构的一部分，每一个操作的具体实现只有在确定了线性表的存储结构之后才能完成。
线性表上的基本操作有：⑴线性表初始化：Init_List(L)初始条件：表L不存在操作结果：构造一个空的线性表⑵求线性表的长度：Length_List(L)初始条件：表L存在操作结果：返回线性表中的所含元素的个数⑶取表元：Get_List(L,i)初始条件：表L存在且1<=i<=Length_List(L)操作结果：返回线性表L中的第ｉ个元素的值或地址⑷按值查找：Locate_List(L,x)，ｘ是给定的一个数据元素。
数据结构--线性表的基本运算及多项式的算术运算
数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算，多项式的加法和乘法算术运算。
要求：能够正确演示线性表的查找、插入、删除运算。
实现多项式的加法和乘法运算操作。
二、实验环境(实验设备)X64架构计算机一台，Windows 7操作系统，IDE: Dev C++ 5.11编译器: gcc 4.9.2 64bit二、实验原理及内容程序一：实现顺序表和单链表的实现本程序包含了四个文件，分别是LinearListMain.cpp，linearlist.h，seqlist.h，singlelist.h。
分别是主程序，线性表抽象类，顺序储存线性表的实现，链表储存顺序表的实现。
文件之间的关系图：本程序一共包含了三个类：分别是LinearList（线性表抽象类），SeqList（顺序储存的线性表），SingleList（链表储存的线性表）。
类与类之间的关系图如下：其实，抽象类LinearList规定了公共接口。
分别派生了SeqList类和SingleList。
SingleList类与SingleList类分别实现了LinearList类中的所有接口。
程序代码以及分析：Linearlist类：#include <iostream>using namespace std;template <class T>class LinearList{protected:int n; //线性表的长度public:virtual bool IsEmpty() const=0; //判读是否是空线性表virtual int Length() const=0; //返回长度virtual bool Find(int i,T& x) const=0; //将下标为i的元素储存在x中，成功返回true，否则返回falsevirtual int Search(T x) const=0; //寻找值是x的元素，找到返回true，否则返回falsevirtual bool Insert(int i,T x)=0; //在下标为i的元素后面插入xvirtual bool Delete(int i)=0; //删除下标为i的元素virtual bool Update(int i,T x)=0;//将下标为i的元素更新为x virtual void Output(ostream& out)const=0; //将线性表送至输出流};包含了一个保护数据成员n，和8种运算，具体说明见注释。
数据结构、算法、线性表总结思维导图-高清简单脑图模板-知犀思维导图
数据结构、算法、线性表总结算法
特性
有穷性
确定性
可行性
有输入
有输出
目标
正确性
可使用性
可读性
健壮性
高效率与低存储量需求
算法的分析
算法的频度
时间复杂度
空间复杂度
数据结构
逻辑结构
存储结构
顺序存储
链式存储
运算
线性表
顺序存储结构顺序表
链式存储结构
单链表
双链表
循环链表
有序表所有元素以递增或递减方式有序排列的线性表栈和队列
栈是一种只能在一端进行插入或删除操作的线性表
队列是一种仅允许在表的一端迸行插入操作，
而在另一端进行删除操作的线性表
串
串是由零个或多个字符组成的有限序列
顺序存储的顺序串
链式存储的链串。
数据结构 第二章__线性表(本)
数据结构与算法华东师范大学计算机系杨沛第二章线性表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。
数据结构——线性表（顺序实现）
数据结构——线性表（顺序实现） 好好学习基础知识，出⼈头地就靠它了，内外兼修。
（好吧，我现在内外都不⾏）写这篇⽂章的⽬的就是为了，巩固刚学完的线性表，个⼈能⼒有限，若有不当之处，望指出。
线性表 好了，扯完了，说正事： 1、定义 线性表是⼀种及其常⽤的并且最简单的⼀种数据结构。
简单来说，线性表就是集合⾥的元素的有限排列。
（在这⾥我把集合定义为具有相同属性的元素，会有些狭义） 在线性表中数据元素之间的关系是⼀对⼀的关系，即除了第⼀个和最后⼀个数据元素之外，其它数据元素都是⾸尾相接的（注意，这句话只适⽤⼤部分线性表，⽽不是全部。
⽐如，循环链表逻辑层次上也是⼀种线性表（存储层次上属于链式存储），但是把最后⼀个数据元素的尾指针指向了⾸位结点）[] 怎么说呢，毕竟数据结构毕竟是逻辑结构，逻辑上符合线性结构的特征即可，存储结构能实现就⾏。
线性表的很重要！很重要！很重要！后⾯的栈，队列，串等都是基于线性表的基础上实现的，所以说⼀定要学好线性表 2、线性表的特点： 对于任意的的⾮空线性表或者线性结构有： 1、存在唯⼀⼀个被称为 ”第⼀个“的元素 2、存在唯⼀⼀个被称为 ”最后⼀个“的元素 3、出第⼀个元素之外，每⼀个元素都存在⼀个后继 4、除最后⼀个元素之外，每⼀个元素都存在⼀个前驱 3、基本操作 1、Create（*L）创建空表 2、InitEmpty（*L）初始化 3、getLength（*L）获取长度 4、Insert（*L）插⼊元素 5、Remove（*L）移除元素 6、IsEmpty（*L）空表检测 7、IsFulled（*L）表满检测（顺序表常⽤，链式表基本不⽤） 8、Delete（*L）删除表 9、getElemt（*L）获取元素 10、Traverse（*L）遍历输出所有元素 11、Clear（*L）清除所有元素 4 、实现 好了最⿇烦的事情开始了，数据结构在计算机上的的映射。
众所周知，线性表有两种实现⽅法，⼀种是顺序表，另⼀种是链式表，这两种结构实现最⼤的不同在于前者逻辑关系⽆需存储空间，⽽后者则需要⽤额外的空间（顺便记录⼀下，指针⼤⼩只由环境有关（严格意义上说和CPU的位数有关）本篇只实现顺序结构）。
数据结构课件之线性表(ppt 86页)
删除算法
int DelList(SeqList *L,int i,ElemType *e)
/*在顺序表L中删除第i个数据元素，并用指针参数e返回其值*/
{ int k;
if((i<1)||(i>L->last+1))
{ printf(“删除位置不合法！”)； return(ERROR)； }
*e= L->elem[i-1]; /* 将删除的元素存放到e所指向的变量中*/
loc(ai) =loc(a1)+(i-1)×k
8
15.10.2019
顺序存储结构示意图
存储地址
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
操作前提：L为未初始化线性表。 操作结果：将L初始化为空表。 操作前提：线性表L已存在。 操作结果：将L销毁。 操作前提：线性表L已存在 。 操作结果：将表L置为空表。
………
}ADT LinearList
6
15.10.2019
2.2 线性表的顺序存储
2.2.1 线性表的顺序存储结构 2.2.2 线性表顺序存储结构上的基本运算
17
15.10.2019
删除算法示意
将线性表(4,9,15,21,28,30,30,42,51,62)中的第5个元素 删除。
序号
1 2 3 4 5 6 7 8 9 10 4 9 15 21 28 30 30 42 51 62
数据结构与算法--线性表
数据结构与算法--线性表⽬录线性结构特点唯⼀头元素唯⼀尾元素除头元素外，都有⼀个直接前驱除尾元素外，都有⼀个直接后继线性表定义语⾔定义线性表是n个数据元素的有限序列。
线性表中的数据元素可以由若⼲个数据项组成。
形式定义线性表可以表⽰成n个数据元素的有限序列（a1,a2,a3……a i-1,a i,……a n）其中a1是头元素，a n是尾元素，a i是第i个元素。
a i-1是a i的直接前驱，a i是a i-1的直接后继。
当2 $\leq$ i $\leq$ n时，a i只有⼀个直接前驱当1 $\leq$ i $\leq$ n-1时，a i只有⼀个直接基本操作InitList(&L)//构造空线性表LDestroyList(&L)//销毁已存在的线性表LClearList(&L)//将L重置为空表ListEmpty(L)//判断列表是否为空ListLength(L)//获取列表长度GetElem(L,i,&e)//返回L中的第i个元素到eLocateElem(L,e,compare())//查找元素e的位置PriorElem(L,cur_e,&pre_e)//查找前驱元素NextElem(L,cur_e,&next_e)//查找后继元素ListInsert(&L,i,e)//插⼊元素ListDelete(&L,i,&e)//删除元素ListTraverse(L,visit())//遍历元素线性表的实现顺序表⽰和实现线性表的顺序表⽰是指⽤⼀组地址连续的存储单元⼀次存储线性表的数据元素，⽤物理位置相邻来表⽰逻辑关系相邻，任意数据元素都可随意存取（故⼜称随机存取结构）readme顺序表中元素下标从0开始以下顺序表的实现可以直接运⾏#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define LIST_INIT_SIZE 100//顺序表初始化长度#define LIST_INCREMENT 10 //每次不⾜时新增长度#define OVERFLOW 0 //分配空间失败#define REFREE 0 //重复释放，释放空指针#define OK 1#define ERROR 0typedef int ElemType;//需要时进⾏修改typedef int Status;template <typename ElemType>//使⽤模板⽅便更多数据类型的使⽤//结构定义class List{public:typedef struct{ElemType *elem;//存储数据元素int length;//表长，初始为0int listsize;//表存储容量，也就是实际分配的存储空间}SqList;SqList L;//线性表List();//构造函数~List();//析构函数Status List_Init();//线性表初始化函数Status List_Insert(int i,ElemType e);//线性表插⼊元素Status List_Delete(int i,ElemType &e);//线性表删除元素Status List_Traverse();//线性表遍历Status List_Destroy();//线性表销毁Status List_Clear();//线性表清空};template <typename ElemType>List<ElemType>::List(){List_Init();//含有指针变量，构造时需要分配空间，不过我们可以直接利⽤线性表的初始化函数}template <typename ElemType>List<ElemType>::~List(){if(!L.elem)//避免我们之前调⽤过线性表的销毁函数，导致重复释放指针free(L.elem);}//线性表的初始化template <typename ElemType>Status List<ElemType>::List_Init(){L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if(!L.elem)//指针为空时，说明分配失败，通常由于内存满了，但这种情况⼀般不会出现exit(OVERFLOW);L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}//插⼊元素e到顺序表i位置//可以插⼊第0个位置⼀直到第n个位置(第n个位置也就是附加在结尾)template <typename ElemType>Status List<ElemType>::List_Insert(int i, ElemType e){if(i<0||i>L.length)//插⼊位置错误return ERROR;if(L.length>=L.listsize)//空间不⾜时分配空间，相等时说明当前空间已满不能再插⼊元素了，所以也要分配空间{ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(ElemType));if(!newbase)exit(OVERFLOW);L.elem = newbase;//上述重新分配时，如果后续空间充⾜则会扩展并返回原指针，否则会寻找⼤⼩适合的空间，返回新指针(并⾃动释放原内存)，所以elem指针需要进⾏更改。
数据结构(第二章 线性表)
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)。
2.2 线性表的顺序存储结构
三、基本操作的算法描述
初始化顺序表 （算法 2.3）
插入元素
（算法 2.4）
删除元素
（算法 2.5）
元素的查找
（算法 2.6）
顺序表的合并 （算法 2.7）
算法2.3 （初始化顺序表）
Status InitList_Sq(SqList &L){ L.elem=(ElemType*) malloc(LIST_INIT_SIZE*sizeof(ElemType))
if (!L.elem) exit （OVERFLOW）;
L.length=0; L.listsize=LIST_INIT_SIZE; return OK; }//InitList_Sq
算法2.4 ：顺序表中插入一个元素
Status ListInsert_Sq(SqList &L,int i,ElemType e){ if (i<1||i>L.length+1) return ERROR; if (L.length>=L.listsize){ newbase=(ElemType *) realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType)); if(!newbase) exit (OVERFLOW); L.elem=newbase;L.listsize+=LISTINCREMET; } q=&(L.elem[i-1]);
掌握链表如何表示线性表中元素之间的逻辑关系；单链 表、双链表、循环链表链接方式上的区别；单链表上实 现的建表、查找、插入和删除等基本算法及其时间复杂 度。循环链表上尾指针取代头指针的作用，以及单循环 链表上的算法与单链表上相应算法的异同点。双链表的 定义和相关算法。利用链表设计算法解决简单应用问题。
CH2 线性表
2.1 线性表的逻辑结构 2.2 线性表的顺序存储及运算实现 2.3 线性表的链式存储和运算实现 2.4 线性表的两种存储结构的比较 2.5 线性表的应用举例
教学目标
线性表的逻辑结构特征；线性表上定义的基本运算，并 利用基本运算构造出较复杂的运算。
掌握顺序表的含义及特点，顺序表上的插入、删除操作 是及其平均时间性能分析，解决简单应用问题。
领会顺序表和链表的比较，以及如何选择其一作为其存 储结构才能取得较优的时空性能。
教学重点与难点
本章的重点是掌握顺序表和单链表上实现的各种 基本算法及相关的时间性能分析；
难点是使用本章所学的基本知识设计有效算法解 决与线性表相关的应用问题。
教学方法
课堂讲授 提问互动 实验
2.1 线性表的类型定义
}//MergeList
2.2 线性表的顺序存储结构
一、特点
1. 用一组地址连续的存储单元依次存放线性 LOC(a1) 表中的元素；
a1
2. 以元素在机内的“物理位置相邻”来表示
a2
数据之间的;1)＝ LOC(ai)＋L 3. 是一种随机存取的存储结构;
LOC(ai)＝LOC(a1)＋(i－1)*L 4. 插入／删除时需移动大量元素;
LOC(ai) LOC(ai+1)
ai ai+1 ……
an
2.2 线性表的顺序存储结构
二、描述方式
#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef struct{
ElemType *elem; int length; int listsize; } SqList
有且仅有一个终端结点(表尾结点tail)an，它没有直接 后继，只有一个直接前驱;
其它结点都有一个直接前驱和直接后继； 元素之间为一对一的线性关系。
线性表的抽象数据类型定义（P18 ）
ADT List{
数据对象：D={ai|ai∈ElemSet;1≤i≤n,n≥0;} 数据关系：R={<ai,ai+1>| ai, ai+1∈D,i=1,2,……,n-1}
算法2.1（线性表的首尾合并）
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); if (!LocateElem(La,e,equal)) ListInsert(La,++La_len,e); }
定义:
线性表（linear list） （ a1，a2，… ， an ）
其中:
n ：数据元素的个数或线性表的长度； ai ： 是一个抽象的符号，它的数据类型设定为ElemType，
表示某一种具体的已知数据类型（1≤i≤n） 。
非空线性表的特征（P18）
有且仅有一个开始结点(表头结点 head)a1，它没有直 接前驱，只有一个直接后继;
}//union 算法分析：
设LocateElem的执行时间与表长成正比， 即：算法的时间复杂度为：O(ListLength(La) * ListLength(Lb))
算法2.2（有序线性表的合并）
void MergeList(List La,List Lb,List &Lc){ InitList(Lc); i=j=1;k=0; 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);}