chapter2.1-2.2顺序表
顺序表-思维导图
顺序表-思维导图第二章线性表课后作业： 1、复习观看视频，并完成顺序表部分的章节测试（2.1 2.2.1~2.2.4五个小视频的章节测试） 2、解答下题：v 线性表L中，若每个元素占用m个存储单元，则LOC(i+1)=LOC(i)+m LOC(i)=LOC(1)+(i-1)*m LOC(1)是线性表的第一个数据元素的存储位置，通常称为线性表的起始位置或基地址。
设线性表中，数组A的每个数据元素占4个字节，已知Loc(a1)=2000，A的终端结点a5的起始地址为何? 答：2000+（5-1）*4=2020 3、线性表的定义： #define maxsize 1024 /*线性表的最大长度*/ typedefint datatype; /*定义表元素类型*/ typedef struct{ datatype elem[maxsize]; /*存放表结点的数组*/ int length;/*表长*/ }sequenlist; 删除线性表中第i个结点数据，请将以下程序补充完整：int Del(sequenlist *L，int i) { int j; if(iL->length) return FALSE； for(j=i;jlength;j++) L->elem[j-1]=L->elem[j] L->length--; return TRUE； }在表L的第i个位置插入数据item int Ins(sequenlist *L，int i，datatype item) {int j; if(iL->length )return FALSE；for(j=L->length-1;j>=i-1;j--) L->elem[j+1]=L->elem[j];L->elem[i]=item; L->length++; return TRUE; } 以上作业下节课请同学来讲解一下。
顺序表及其运算
// 修改表中指定元素
int ModifyList (*L, ElemType item ) ;
2.1 线性表的概念
int InsertList (*L, ElemType item ) ; // 向表中插入元素
int DeleteList (*L, ElemType item ) ; // 删除表中元素
例： 1
a12a23来自a34a4
:
:
: :
an-1
n
an
利用数组实现线性表的顺序存储,要求：
数组长度 > 表长度
表中元素地址计算： ADR( ai )=ADR( a1 ) + ( i -1 )* k k——为每个元素所占字节数；
2.2 顺序表及其运算
二、 顺序表的运算 若对表示顺序表的数组空间采用动态分配， 对顺序表结构作如下定义：
2.1 线性表的概念
二、线性表的抽象数据类型 数据部分：
数据元素，数据元素之间的关系描述；
操作部分：
根据应用需要确定 按照功能可以归纳为以下基本类型： • 属性设置：确定类型的基本属性值； • 读取属性：读取类型的属性值； • 插入：在对象的指定位置加入新的数据元素； • 删除：删除对象中的指定数据元素； • 查找：在对象查找满足条件的数据元素； • 遍历：按某种方式不重复地访问对象中所有数据元素； • 关系访问：访问对象中有特定关系的元素；
int LenthList (*L) ;
// 求表的长度
void SortList (*L) ;
// 按关键字值对表元素排序
void TraverseList (*L) ; // 对表进行遍历并输出
void ClearList (*L) ;
数据结构Python语言描述 线性表
2.1 线性表简介
一种典型的线性表的逻辑结构。
6
2.1 线性表简介
线性表中的元素之间也可以存在某种关系。如数字 1 ～ 20 里 所有奇数的排列，可用如下线性表的形式来表示。 {1,3,5,7,9,11,13,15,17,19} 此时，表内元素的值是按照递增顺序来排列的，通常我们称 这种类型的线性表为有序线性表（简称有序表），即该表中 元素按某种顺序进行排列。从严格意义上来讲，仅当线性表 中所有元素以递增或递减的顺序排列（允许表中存在相同的 元素），我们才称其为有序表；否则，我们均称其为无序表， 元素之间既无递增也无递减关系，示例如下。 {1,13,5,74,9,11,13,15,17,195}
16
算法2-2 创建顺序表函数
1 2 3 4 5 6 7 8 9 10 11 ##################################### #创建顺序表函数 ##################################### def CreateSequenceList(self): print("*************************************************") print("*请输入数据后按回车键确认，若想结束请输入“#”。*") print("*************************************************") Element=input("请输入元素：") while Element!='#': self.SeqList.append(int(Element)) Element=input("请输入元素：")
有机化学系统命名法
烯丙基自由基 甲基自由基 苯甲酸根自由基
Chapter 2
苯基自由基
三苯甲基自由基
“基”与“自由基”在写法上有区别
2．表示链异构的形容词
正——直链烃和官能团取代直链烃末端碳上氢所得
到的烃的衍生物都用“正”字表示碳链结构。
例如：
CH3CH2CH2CH3 正丁烷
CH3CH2CH2CH2OH 正丁醇
CH3CH2CH2CH3 正丁烷
(CH3)2CH-CH3 CH2=C(CH3)CH3
异丁烷
异丁烯
CH2=CH-C(CH3)=CH2 异戊二烯
(CH3)3CCl 叔丁基氯
(CH3)3CCH2Br 新戊基溴
CH3CH(OH)CH2CH3 仲丁醇
CH3CH2CH2CHO 正丁醛
(CH3)2CHCOOH 异丁酸
Chapter 2
这个表又称官能团优先顺序表，它的顺序要记牢命 名时要用到。
一般是把这两种分类方法结合，先按碳架分类，再 按官能团分为若干系列。
Chapter 2
2.2 有机化合物的命名和方法
2.2.1 概述
命名是有机化学的基本内容 。对常见有机化合物
能顺利命名，依据名称能写出化合物的结构，由结构能
[(CH3CH2)4N+与Br-化合]
C6H6Cl6
六氯化苯
[看成苯环与六个Cl化合]
(C6H5)3CLi 三苯甲基（化）锂 [(C6H5)3C-与Li+化合］
Chapter 2
C10H18 十氢化萘 ［看成萘与十个H化合］
代——母体化合物的氢、其它原子或基团被置换，命名所
用的介词。常被省略。这里的“母体化合物”非专指碳氢 化合物。
合物。例如：
chap2数据结构,顺序表,树,图,链表,排序
2.4 一元多项式的表示
ADT List { 数据对象： D＝{ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 } { 称 n 为线性表的表长; 称 n=0 时的线性表为空表。} 数据关系：
R1＝{ <ai-1 ,ai >|ai-1 ,ai∈D, i=2,...,n }
{ 设线性表为 (a1，a2, . . . ，ai，. . . ，an), 称 i 为 ai 在线性表中的位序。}
i = 1; found = TRUE; while ( i<= La_len && found ) {
GetElem(LA, i, e); // 取得LA中一个元素
if (LocateElem(LB, e, equal( ))
i++;
// 依次处理下一个
else found = FALSE;
// LB中没有和该元素相同的元素
{加工型操作} ClearList( &L ) ( 线性表置空 ) PutElem( &L, i, &e ) ( 改变数据元素的值 ) ListInsert( &L, i, e ) ( 插入数据元素 ) ListDelete( &L, i, &e ) ( 删除数据元素 )
ClearList( &L ) 初始条件：线性表 L 已存在。 操作结果：将 L 重置为空表。 PutElem( &L, i, e ) 初始条件： 线性表 L 已存在， 且 1≤i≤LengthList(L)。 操作结果：L 中第 i 个元素赋值和 e 相同。
线性结构的基本特征: 线性结构 是 一个数据元素的有序（次序）集 1．集合中必存在唯一的一个“第一元素” 2．集合中必存在唯一的一个 “最后元素”
数据结构李春葆 第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); } }
DS2_1顺序表
数据结构 第二章 －－线性表
2.1.2 线性表的基本操作 1. 初始化线性表L InitList(L) 2. 销毁线性表L DestoryList(L) 3. 清空线性表L ClearList(L) 4. 求线性表L的长度 ListLength(L) 5. 判断线性表L是否为空 IsEmpty(L) 6. 获取线性表L中的某个数据元素内容 GetElem(L,i,e) 7. 检索值为e的数据元素 LocateELem(L,e) 8. 返回线性表L中e的直接前驱元素 PriorElem(L,e) 9. 返回线性表L中e的直接后继元素 NextElem(L,e) 10. 在线性表L中插入一个数据元素 ListInsert(L,i,e)
数据结构 第二章 －－线性表
SeqListPoint是顺序表的地址，这样表示的线性表在内存中 的表示如图2-2所示。表长为(*SeqListPoint). length 或 (*SeqListPoint). SeqListPoint->length， SeqListPoint->length 线性表的存储区域为SeqListPoint->data数组。
数据结构 第二章 －－线性表
顺序表插入运算主要步骤： for(j= SeqListPoint -> length -1; j>=i-1; j--) SeqListPoint ->data[j+1]= SeqListPoint ->data[j]; /* 移动元素 */ SeqListPoint ->data[i-1]=x; /* 新元素插入*/ SeqListPoint -> length ++; /*表长加 1*/
数据结构 第二章 －－线性表
顺序表及其运算
L->len = 0 ； // 置初始线性表为空 }
2.2 顺序表及其运算
2. 顺序表的插入运算
在表中第 i个位置插入一个元素 item
设表长为 len
即：插入一元素的时间复杂度为：O(n) ② 空间复杂度：原地工作( in place )
思考：在有序顺序表中插入一个数据元素， 算法？
2.2 顺序表及其运算
3. 顺序表的删除运算 在表中删除第pos个元素 删除前：(b0，b1 ，…，bi ，bi+1 ，…，bn-1) 表长为 n ； 删除后：(b0'，b1'，…，bi-1'，bi+1'，…，bn-2' ) 表长为 n-1 ； 算法考虑：表空( L->len = 0)不能做删除 ——下溢处理；
保存现场1
a:
保存现场2
b:
保存现场3
c:
end
return
return
return
2.3 栈
为保证中断正确执行，须依次记住每层中断的现场及返回地址；
进入中断→
现场1
现场2 现场1
现场3 现场2 现场1
当各层中断“返回”时，则要按记入的相反次序逐个恢复现场继续 执行；
现场1
现场2 现场1
←中断返回
指定的删除位置不存在，要处理； 正常删除操作，表长 n 减 1； 算法描述：参考教材 算法分析： 与插入运算类似； 平均时间复杂度： O(n)； 空间复杂度：原地工作
思考：在有序顺序表中删除指定元素， 算法？
第2章 顺序表及其应用
maxlen-1
last
18
第 2章 顺序表及其应用
这样，该顺序表的第一个数据元素（结点）a1可以表 示为： S.data[0]、 (*L).data[0]、 L->data[0] 最后一个数据元素（结点）an可以表示为： S.data[st]、(*L).data[(*L). last]、 L->data[L->last]
if( z= =0 )
printf(“%d ”, -1);
}
25
第 2章 顺序表及其应用
5．判表满运算 SqLempty(L)
在实际运算中，若出现顺序表的表长等于数组 的长度，则为表满，不可以继续插入数据元素的操 作。若表满，返回1；否则返回0。 算法如下：
int SqLempty(Sequenlist *L){
29
第 2章 顺序表及其应用
7、删除运算
SqLdelete (L , i )
a1 a2
ai-1 ai ai+1
an
操作: (1) ai+1 ~an 依次前移
（2）L->last =L->last -1
30
第 2章 顺序表及其应用
条件：⑴ 表是否空 即：L->last 是否小于 0 ⑵ 表示数组元素下标的 I (I=i –1) 应满足如 下条件： 0<= I <= L->last 即：1<= i <= L->last +1 算法如下：
if( L->last+1> = maxlen ) else return ( 0); }
26
return ( 1);
第 2章 顺序表及其应用
第02章线性表(I)
{ int i;
if(slt->size==MAXSIZE)
{printf("\n顺序表是满的!没法插入!");exit(1);}
if(position<0||position>slt->size)
{printf("\n指定的插入位置不存在!");exit(1);}
for(i=slt->size;i>position;i--) slt->a[i]=slt->a[i−1];
将有序顺序表L1分裂成两个线性表L2与L3，L2由表 中所奇数组成，L3由所有偶数组成。
（3）void merge(sequence_lsit *l1,sequence_list *l2, sequence_list *l3)
将有序顺序表L1与L2合并成有序顺序表L3。
退出
2.3.1栈
2.3 栈
栈是一种特殊的线性表，对于这种线性表规定它
n 1 2
这表明，在一个长为n的顺序表中删除一个元素平 均需要移动表中大约一半的元素。该算法的时间复杂 度为O（n）。
退出
顺序表上的一些其它常见算法
（1）void verge(sequence_list l) 将顺序表L就地转置，即借助于O（1）的辅助空间
。 （2）void sprit(sequence_lsit *l1,sequence_list *l2, sequence_list *l3) [略]
退出
要删除顺序表中的第i个结点，则需要称动（n-i-1 ）个元素，设删除表中第i个结点的概率为qi，且在表中 每一个位置删除的概率相等，即：
q0=q1=…=qn-1=1/n
则在一个长度为n的顺序表中删除一个结点的平均 移动次数为：
02 顺序表
a1 a 2 a
new i i-1 node
a ai+1
…
an
for( j = table.length; j > i; j--){ table.data[ j+1 ] = table.data[ j ]; }
1.2.1 线性表--顺序表结构的定义和初始化
设顺序表元素的数据类型为： 则顺序表结构的完整定义为： #define MAXNUM 128 typedef struct{ typedef score_table elemtype ; int number; typedef struct{ char name[20]; elemtype data[MAXNUM] ; char grade[10]; int num ; }listtype ; float math; 定义一个顺序表： float physics; listtype list; float electrocircuit; 初始化函数为： float c_language; void init_list(listtype *l){ float average; l->num=0;} }score_table;
1.2.1 线性表--顺序表插入运算 插入运算
问题描述
以a1开始的线性表中 在第i个元素前插入一个新元素new_node。
a1 a2 ai-1 ai ai+1
new i node
……
an
a1 a2 ai-1 a ai+1 …… an
数据结构 第二章__线性表(本)
数据结构与算法华东师范大学计算机系杨沛第二章线性表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。
顺序表的建立与基本算法代码
顺序表的建立与基本算法代码顺序表是一种线性表的存储结构，它的特点是元素在内存中占据一块连续的地址空间。
顺序表的建立与基本算法涉及到顺序表的初始化、插入元素、删除元素、查找元素等操作。
下面我将详细介绍顺序表的建立与基本算法，并提供示例代码进行演示。
顺序表的建立首先需要定义一个存储结构，通常使用数组来表示，例如定义一个长度为n的数组来存储顺序表的元素。
顺序表的初始化操作就是为数组分配内存空间，并将数组中的元素初始化为默认值（通常是一个特殊标记，如0或者null）。
以下是顺序表的初始化代码示例：```cpp#define MAX_SIZE 100 // 定义顺序表的最大长度typedef int DataType; // 定义顺序表的元素类型为整数typedef structDataType data[MAX_SIZE]; // 存储顺序表元素的数组int length; // 当前顺序表的长度} SeqList;//初始化顺序表void InitList(SeqList* list)for (int i = 0; i < MAX_SIZE; i++)list->data[i] = 0; // 将数组元素初始化为0}list->length = 0; // 初始长度为0```初始化完毕后，可以进行元素的插入操作。
顺序表的插入操作通常有两种情况：在表尾插入元素和在表中间插入元素。
如果顺序表的长度没有达到最大长度，可以在表尾插入元素，需要注意的是插入后需要更新顺序表的长度。
以下是在表尾插入元素的代码示例：```cpp//在表尾插入元素void InsertElem(SeqList* list, DataType elem)if (list->length >= MAX_SIZE)printf("顺序表已满，无法插入新元素！\n");return;}list->data[list->length] = elem; // 将元素插入表尾list->length++; // 更新顺序表的长度```如果需要在表中间插入元素，则需要先将插入位置后的元素后移，腾出位置给新插入的元素。
顺序表
顺序表1．顺序表的定义(1) 顺序存储方法即把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。
(2) 顺序表（Sequential List）用顺序存储方法存储的线性表简称为顺序表（Sequential List）。
2．结点ai 的存储地址不失一般性，设线性表中所有结点的类型相同，则每个结点所占用存储空间大小亦相同。
假设表中每个结点占用c个存储单元，其中第一个单元的存储地址则是该结点的存储地址，并设表中开始结点a1的存储地址（简称为基地址）是LOC（a1），那么结点ai的存储地址LOC（ai）可通过下式计算：LOC（ai）= LOC（a1）+（i-1）*c 1≤i≤n注意：在顺序表中，每个结点ai的存储地址是该结点在表中的位置i的线性函数。
只要知道基地址和每个结点的大小，就可在相同时间内求出任一结点的存储地址。
是一种随机存取结构。
3．顺序表类型定义#define ListSize 100 //表空间的大小可根据实际需要而定，这里假设为100typedef int DataType; //DataType的类型可根据实际情况而定，这里假设为inttypedef struct {DataType data[ListSize]；//向量data用于存放表结点int length；//当前的表长度}SeqList；注意：①用向量这种顺序存储的数组类型存储线性表的元素外，顺序表还应该用一个变量来表示线性表的长度属性，因此用结构类型来定义顺序表类型。
②存放线性表结点的向量空间的大小ListSize应仔细选值，使其既能满足表结点的数目动态增加的需求，又不致于预先定义过大而浪费存储空间。
③由于C语言中向量的下标从0开始，所以若L是SeqList类型的顺序表，则线性表的开始结点a1和终端结点an分别存储在L．data[0]和L．Data[L．length-1]中。
④若L是SeqList类型的指针变量，则a1和an分别存储在L-＞data[0]和L-＞data[L-＞length-1]中。
顺序表——精选推荐
顺序表顺序表的1基本操作的代码在下⽂都有，并且经过初步测试，如果有⼤佬发现不对的地⽅，还望多多指正，谢谢。
1.线性表线性表：n个具有相同特性的数据元素的有限序列。
线性表是⼀种在实际中⼴泛使⽤的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的⼀条直线。
但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
（画图没弄整齐--^_^--）顺序表：基本内容如图：1概念及结构顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组存储。
在数组上完成数据的增删查改。
顺序表⼀般可以分为：1. 静态顺序表：使⽤定长数组存储。
2. 动态顺序表：使⽤动态开辟的数组存储#define Capacity 100typedef int DataType; //表中保存的数据类型，在前⾯⽤typedef关键字再给类型名，⽅便⼀改全改struct SeqList{DataType array[Capacity]; //保存顺序表中元素，Capacity是数组总容量size_t size; //记录有效元素个数};静态顺序表实质就是固定容量的数组加⼀个有效元素计数。
顺序表的具体操作以动态顺序表来展⽰：typedef int DataType; //存放的数据类型typedef struct SeqList{DataType* _array; // 指向动态申请的数组空间size_t _size; //记录有效元素个数size_t _capacity; //记录容量，空间总⼤⼩}SeqList;int main(){//要⽤结构体定义⼀个变量，然后将顺序表地址交给指针，⽤指针对顺序表进⾏操作SeqList S1;SeqListInit(&S1);//SeqList *ps = &S1; //和上⾯的效果是⼀样得//SeqListInit(ps);return0;顺序表的主要操作：初始化顺序表、销毁顺序表、检查容量和有效元素个数、尾插尾尾删、头插头删、任意下标插⼊、查找、删除、遍历、更改数据、更改容量等，扩展有在顺序表中进⾏排序、删除重复元素、合并两个或多个顺序表等。
顺序表——精选推荐
顺序表顺序表 顺序表属于顺序存储结构，是最简单的顺序表，基本思想是⽤⼀段连续的储存单元依次存储线性表的数据元素，⼀般使⽤数组来定义，就能实现增，删，改，差等基本操作。
使⽤结构体来实现顺序表，结构体中有⼀个data数组，⽤来连续存储数据。
变量last⽤来指明当前顺序表中有⼏个数据，⽅便访问顺序表。
typedef struct seqlist{int data[MAX_LIST]; //数据域，MAX_LIST = 10int last; //下标域}my_seqlist, *p_my_seqlist;初始化顺序表 当需要创建⼀个顺序表时，可以调⽤此函数，此函数给顺序表分配⼀个堆空间，并且将地址返回，接收此返回值⽤p_my_seqlist变量。
p_my_seqlist init_list(){p_my_seqlist p_my_seqlist1 = calloc(1, sizeof(my_seqlist));if(NULL == p_my_seqlist1)return false;return p_my_seqlist1;}插⼊数据 当需要在顺序表中插⼊数据的时候，调⽤此函数。
注意需要传⼊已经初始化好的顺序表，第⼆个形参为需要插⼊的数据。
int insert_seqlist(p_my_seqlist p_my_seqlist1, int data){if(NULL == p_my_seqlist1){printf("LIST指针为空\n");return false;}if(MAX_LIST <= p_my_seqlist1->last){printf("顺序表以满,⽆法建⽴顺序表\n");printf("p_my_seqlist1->last:%d\n",p_my_seqlist1->last);return false;}p_my_seqlist1->data[p_my_seqlist1->last++] = data; //每插⼊⼀个数据last需要加1，表⽰顺序表中的数据多了⼀个return true;}打印顺序表 将顺序表中的数据打印出来。
C语言：2.2 线性表及其顺序存储结构
线性表中数据元素的个数n称为线性表的长度
2.线性表的顺序存储结构
2.2.1 线性表及其运算
… a1 a2 … ai-1 ai … an …
第1个元素的存储地址，即线性表的起始地 址，称作线性表的基地址
每个数据元素所占的
线性表的顺序存储结构具有的特点： 存储空间（子节数） （1）所有元素所占的存储空间是连续的 （2）各元素在存储空间中是按逻辑顺序
v[i-1]=b;
//插入新元素
n=n+1;
//线性表长度增加1
return;
}
4.线性表在顺序存储结构下的删除运算 2.2.1 线性表及其运算
例2 删除线性表(21,18,30,75,66,42,56,87) 的第5个元素。
V(1:10) 21 18 30 75 4626 4526 5867 87
2. 线性表：允许在任意位置进行插入、删除运算 栈：只允许在一端进行插入、删除运算的线性表, 具有先进后出、后进先出的特点 队列：只允许在队尾插入，在排头进行删除 运算的线性表，具有先进先出的特点
3.由线性表在顺序存储结构下的插入与删除运算效 率比较低,这种存储方式对于大线性表或元素经常 需要变动的线性表不太合适.
S(1:10)
1.什么是队列
2.2.3 队列栈及其应用
队列（Queue）是指允许在一端进行插入，而在 另一端进行删除的线性表。
出队
ABCDE F
入队
排头指针 front
队尾指针 rear
2.队列的应用
输入输出缓冲区的结构
计
缓
打
算
冲
印
机
区
机
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第2章 线性表
36/48
void MergeList_L (LinkList &La，LinkList &Lb，LinkList &Lc) {
pa = La->link ； pb = Lb->link ；//分别指向第一个结点 Lc = pc = La ； while ( pa && pb ) { if ( pa->data <= pb->data ) {
X=
1 2 3 4 5 6 7 8 9
第2章 线性表 24/112
以列序为主序 a00 a01
a00 a10
Am×n
0
a02
... ...
a0,n-1
a10 am-1,0
...
a11 am-1,1 ...
a12 am-1,2
...
a1,n-1
...
am-1,0 a01 a11 am-1,1 a0,n-1 a1,n-1 am-1,n-1 … … …
铜牌 29 23 19 32
总数 104 88 65 4/48 82
线性表的定义
2. 线性表的形式定义
线性表可以表示为 n 个数据元素的有限序列:
(a1，…，ai-1，ai，…，an)
其中a1是头元素， an是尾元素， ai是第i个元素。
ai-1是ai的直接前驱， ai是ai-1的直接后继。
当2≤i≤n时， ai有且只有一个直接前驱。
d1[1..3],d2[1..5],d3[1..5]分别为3个维
第2章 线性表 23/112
数组的存储
• 多维数组的逻辑特征：一个元素可能有多个直接前驱 和多个直接后继。 • 内存是一维的，所以数组的存储也只能是一维的 —— 数组顺序表
–以行为主序（也称为“行优先”） –以列为主序（也称为“列优先”）
第2章 线性表 41/48
2) 删除
ELEM A[c1..d1][c2..d2]…[cn..dn]
–ci和di是各维下标的下界和上界。所以其元素个数 为：
(d
i 1
n
i
ci 1)
第2章 线性表
22/112
数组的空间结构
d3 d1=3,d2=5,d3=5
d2
d1
d1 a[2][2]
d2 a[2][3][3]
二维数组
三维数组
数据结构与算法
第2章 线性表
第2章 线性表
• 2.1 线性表的概念
• 2.2 顺序表 • 2.3 链表
第2章 线性表
2/48
线性表
线性结构特点:
头 尾 线性 O O O O O 1 2 3 4 5
• 唯一头元素 • 唯一尾元素 • 除头元素外，均有一个直接前驱
• 除尾元素外，均有一个直接后继 • 具有反对称性和传递性
第2章 线性表
18/48
顺序表特点
优点:
• 可随机存取表中任意数据元素，算法简单，空间利用率高； • 直接可获取线性表的长度 缺点: •需要预先确定数据元素的最大个数， •数据元素的插入、删除相对麻烦，插入和删除时需要移 动较多的数据元素。
第2章 线性表 19/48
顺序表应用举例
• 编程实现如下任务:建立一个线性表，首先依次 输入数据元素1，2，3，„，10，然后删除数 据元素5，最后依次显示当前线性表中的数据 元素。要求采用顺序表实现，假设该顺序表的 数据元素个数在最坏情况下不会超过100个。 • class SeqList{…};
45 12 9 25 33 33 69 69 5 5
删除25
第2章 线性表
15/48
算法时间复杂度:
移动元素的个数取决于删除元素位置。
i=1，需移动n - 1个元素； i=n，需移动0个元素； i=i，需移动n – i 个元素；
第2章 线性表
16/48
假设qi是删除第 i 个元素的概率
则长度为 n 的线性表中删除一个元素所需移动元 素次数的期望值为: Edl = ∑ qi (n – i)
pa pc
pa pc
pa
La
pb pc Lb
6
pc pb pb
27
pb
67
89
0
21
35
0
第2章 线性表
38/48
双链表
双链表的结点有两个指针域: 一个指向直接后继，
一个指向直接前驱。
prev data link
第2章 线性表
39/48
head
A
B
C
d 空表: head
tail
性质: 设d 是指向某个结点的指针，则有
b+(i-1)l
b+(n-1)l b+nl
… …
第2章 线性表
9/48
例2.4 在第 i 个数据元素之前插入一个新的元素 例，在第 i 个元素前插入 b
a1
a1 … … ai-1 ai b ai … an …
ai-1
an
思想: 1. 将第 n 到 i 个元素均向后移动一个位置。
2. 将新元素放置在第 i 个位置。
pc->link = pa ；pc = pa ；pa = pa->link；}
else { pc->link = pb ；pc = pb ；pb = pb->link ；} } pc->link = pa ? pa : pb ；//处理剩余部分
delete Lb ； }
第2章 线性表
37/48
Lc Lc , pc
第2章 线性表 7/48
线性表的存储
• 顺序存储
– 顺序表
• 链式存储
– 链表
第2章 线性表
8/48
顺序表
用一组地址连续的存储单元依次存储线性表的数据元素。
存储地址 内存状态 b b+l 设每个元素需占用 l 个存储单元
a1 a2 … ai … an
LOC(ai)表示元素ai的存储地址
则LOC(a1)是第一个数据元素a1的存储 地址，也是整个线性表的起始地址 LOC(ai+1) = LOC(ai) + l LOC(ai) = LOC(a1) + (i - 1)l
第2章 线性表 10/48
例，在第4个元素之前插入元素25。
插入25
1 2 3 4 5 6 7
45 12 9 33 25 69 33 5 69 5
第2章 线性表
11/48
算法时间复杂度:
移动元素的个数取决于插入元素位置。 i=1，需移动 n 个元素； i=n+1，需移动 0 个元素； i=i，需移动 n – i +1 个元素；
s->link = p->link
p->link= s
第2章 线性表 34/48
பைடு நூலகம்
删除元素b : p a q=p->link b c
1) p ->link = p ->link ->link ?
2) q = p->link p->link = q->link
第2章 线性表 35/48
单链表操作
• 将两个有序单链表合并为一个有序单链表
1
m-1
第2章 线性表
链表
线性表的链式存储结构的特点是：
用一组任意的存储单元存储线性表的数据元素。
存储单元可以是连续的，也可以是不连续的。
第2章 线性表
28/48
单链表
结点: 两部分信息组成，存储数据元素信息的数据域，
存储直接后继存储位置信息的指针域。
数据域，存放数据信息
data
link
tail
d->link->prev = d->prev->link = d
操作: 只涉及单向的操作基本相同，但插入、删除操 作变化很大。
第2章 线性表 40/48
p
1) 插入 A B
X s
1. 2. 3. 4. 5.
找到要在之前插入的结点，p记录。 s->prev = p->prev ； p->prev->link= s ； s->link = p ； p->prev= s ；
…
1
...
am-1,n-1
n-1
第2章 线性表
a00 a01
以行序为主序 a00 a10 ... a01 a11 ...
Am×n
0
a02 a12 ...
... ...
a0,n-1 a1,n-1 ...
a0,n-1 a10 a11
a1,n-1
… … …
1
am-1,0 am-1,1 am-1,2 . . .
当1≤i≤n-1时， ai有且只有一个直接后继。
第2章 线性表 5/48
线性表
线性表抽象数据类型 顺序表
主 要 知 识 点
链表
栈 队列 字符串 应用举例
第2章 线性表 6/48
线性表抽象数据类型
数据集合:｛ a0, a1, … , an-1 ｝, ai的数据类型为DataType (1) Clear() 置空线性表 (2) Append(T value) 在表尾添加元素 操作集合: (3) Insert(int p, T value) 插入数据元素 (4) Delete(int p) 删除数据元素 (5) GetValue(int p, T& value) 取数据元素 (6) SetValue(int p, T value) 更改数据元素 (7) GetPos(int p, T value) 取数据元素