线性表的存储结构定义及基本操作
一、实验目的：
. 掌握线性表的逻辑特征
. 掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算
. 熟练掌握线性表的链式存储结构定义及基本操作
. 理解循环链表和双链表的特点和基本运算
. 加深对顺序存储数据结构的理解和链式存储数据结构的理解，逐步培养解决实际问题的编程能力
二、实验内容：
（一）基本实验内容（顺序表）：
建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、
查找元素、判线性表是否为空；
1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：
. 创建一个新的顺序表，实现动态空间分配的初始化；
. 根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序
顺序表；
. 根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删
除指定值的所有结点(值删除)；
. 利用最少的空间实现顺序表元素的逆转；
. 实现顺序表的各个元素的输出；
. 彻底销毁顺序线性表，回收所分配的空间；
. 对顺序线性表的所有元素删除，置为空表；
. 返回其数据元素个数；
. 按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对
查找结果进行返回；
. 按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；
. 判断顺序表中是否有元素存在，对判断结果进行返回；
. 编写主程序，实现对各不同的算法调用。
2．实现要求：
对顺序表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，每个算法的实现要
从时间复杂度和空间复杂度上进行评价；
. “初始化算法”的操作结果：构造一个空的顺序线性表。对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；
. “位置插入算法”的初始条件：顺序线性表L 已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加1；
. “位置删除算法”的初始条件：顺序线性表L 已存在，1≤i≤ListLength(L) ；
操作结果：删除L 的第i 个数据元素，并用e 返回其值，L 的长度减1 ；
. “逆转算法”的初始条件：顺序线性表L 已存在；
操作结果：依次对L 的每个数据元素进行交换，为了使用最少的额外空间，对顺序
表的元素进行交换；
. “输出算法”的初始条件：顺序线性表L 已存在；
操作结果：依次对L 的每个数据元素进行输出；
. “销毁算法”初始条件：顺序线性表L 已存在；
操作结果：销毁顺序线性表L；
. “置空表算法”初始条件：顺序线性表L 已存在；
操作结果：将L 重置为空表；
. “求表长算法”初始条件：顺序线性表L 已存在；
操作结果：返回L 中数据元素个数；
. “按序号查找算法”初始条件：顺序线性表L 已存在，元素位置为i，且1≤i≤ListLength(L)
操作结果：返回L 中第i 个数据元素的值
. “按值查找算法”初始条件：顺序线性表L 已存在，元素值为e；
操作结果：返回L 中数据元素值为e 的元素位置；
. “判表空算法”初始条件：顺序线性表L 已存在；
操作结果：若L 为空表，则返回TRUE，否则返回FALSE；
分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
(二）基本实验内容（链表）：
建立单链表，完成链表（带表头结点）的基本操作：建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。
1．问题描述：
利用线性表的链式存储结构,设计一组输入数据（假定为一组整数），能够对单链表进行如下操作：
. 初始化一个带表头结点的空链表；
. 创建一个单链表是从无到有地建立起一个链表，即一个一个地输入各结点数据，并建立起前后相互链接
的关系。又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值；
. 插入结点可以根据给定位置进行插入（位置插入），也可以根据结点的值插入到已知的链表中（值插入），且保持结点的数据按原来的递增次序排列，形成有序链表。
. 删除结点可以根据给定位置进行删除（位置删除），也可以把链表中查找结点的值为搜索对象的结点全部删除（值删除）；
. 输出单链表的内容是将链表中各结点的数据依次显示，直到链表尾结点；
. 编写主程序，实现对各不同的算法调用。
其它的操作算法描述略。
2．实现要求：
对链表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，还要针对每个算法的
实现从时间复杂度和空间复杂度上进行评价。
. “初始化算法”的操作结果：构造一个空的线性表L，产生头结点,并使L 指向此头结点；
. “建立链表算法”初始条件：空链存在；
操作结果：选择逆位序或正位序的方法，建立一个单链表，并且返回完成的结果；
. “链表（位置）插入算法”初始条件：已知单链表L 存在；
操作结果：在带头结点的单链线性表L 中第i 个位置之前插入元素e；
. “链表（位置）删除算法”初始条件：已知单链表L 存在；
操作结果：在带头结点的单链线性表L 中，删除第i 个元素,并由e 返回其值；
. “输出算法”初始条件：链表L 已存在；
操作结果：依次输出链表的各个结点的值；
（三）扩展实验内容（顺序表）
查前驱元素、查后继元素、顺序表合并等.
1．问题描述：
. 根据给定元素的值，求出前驱元素；
. 根据给定元素的值，求出后继元素；
. 对已建好的两个顺序表进行合并操作，若原线性表中元素非递减有序排列,要求合并后的结果还是有序(有序合并）；对于原顺序表中元素无序排列的合并只是完成A=A∪B（无序合并)，要求同样的数据元素只出现一次。
. 修改主程序，实现对各不同的算法调用。
2．实现要求：
. “查前驱元素算法”初始条件：顺序线性表L 已存在；
操作结果：若数据元素存在且不是第一个，则返回前驱，否则操作失败；
. “查后继元素算法”初始条件：顺序线性表L 已存在；
操作结果：若数据元素存在且不是最后一个，则返回后继，否则操作失败；
. “无序合并算法”的初始条件：已知线性表La 和Lb；
操作结果：将所有在线性表Lb 中但不在La 中的数据元素插入到La 中；
. “有序合并算法”的初始条件：已知线性表La 和Lb 中的数据元素按值非递减排列；
操作结果：归并La 和Lb 得到新的线性表Lc,Lc 的数据元素也按值非递减排列；
（四）扩展实验内容（链表）
1．问题描述：
. 求前驱结点是根据给定结点的值，在单链表中搜索其当前结点的后继结点值为给定的值，将当前结点返回；
. 求后继结点是根据给定结点的值，在单链表中搜索其当前结点的值为给定的值，将后继结点返回；
. 两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中，继续保持结点有序；
2．实现要求：
. “求前驱算法”初始条件: 线性表L 已存在；
操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱；
. “求后继算法”初始条件: 线性表L 已存在；
操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继；
. “两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列；
操作结果:归并La 和Lb 得到新的单链表。
线性表的顺序存储结构的定义及其基本操作的参考程序（顺序表）
(1) 文件1：pubuse. h 是公共使用的常量定义和系统函数调用声明，以后每个实验中几乎都涉及到此文
件。
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* 函数结果状态代码*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2 因为在math. h 中已定义OVERFLOW 的值为3,故去掉此行*/ typedef int Status； /* Status 是函数的类型,其值是函数结果状态代码，如OK 等*/ typedef int Boolean； /* Boolean 是布尔类型,其值是TRUE 或FALSE */
(2) 文件2：seqlistDef. h 进行线性表的动态分配顺序存储结构的表示
#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/
#define LISTINCREMENT 2 /* 线性表存储空间的分配增量*/
typedef struct
{
ElemType *elem； /* 存储空间基址*/
int length； /* 当前长度*/
int listsize； /* 当前分配的存储容量(以sizeof(ElemType)为单位) */
}SqList；
(3)文件3：seqlistAlgo. h 进行线性表顺序存储结构的基本实验算法定义
Status ListInit_Sq(SqList &L) /* 算法2. 3 */
{ /* 操作结果：构造一个空的顺序线性表*/
L. elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType))；
if(!L. elem)
exit(OVERFLOW)； /* 存储分配失败*/
L. length=0； /* 空表长度为0 */
L. listsize=LIST_INIT_SIZE； /* 初始存储容量*/
return OK；
}
Status ListInsert_Sq(SqList &L,int i,ElemType e) /* 算法2. 4 */
{ /* 初始条件：顺序线性表L 已存在，1≤i≤ListLength(L)+1 */
/* 操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加1 */
ElemType *newbase,*q,*p；
if(i<1||i>L. length+1) /* i 值不合法*/
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+=LISTINCREMENT； /* 增加存储容量*/
}
q=L. elem+i-1； /* q 为插入位置*/
for(p=L. elem+L. length-1；p>=q；--p) /* 插入位置及之后的元素右移*/
*(p+1)=*p；
*q=e； /* 插入e */
++L. length； /* 表长增1 */
return OK；
}
Status ListDelete_Sq(SqList &L,int i,ElemType *e) /* 算法2. 5 */
{ /* 初始条件：顺序线性表L 已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L 的第i 个数据元素，并用e 返回其值，L 的长度减1 */
ElemType *p,*q；
if(i<1||i>L. length) /* i 值不合法*/
return ERROR；
p=L. elem+i-1； /* p 为被删除元素的位置*/
*e=*p； /* 被删除元素的值赋给e */
q=L. elem+L. length-1； /* 表尾元素的位置*/
for(++p；p<=q；++p) /* 被删除元素之后的元素左移*/
*(p-1)=*p；
L. length--； /* 表长减1 */
return OK；
}
Status ListReverse_Sq(SqList &L)
{ /* 初始条件：顺序线性表L 已存在*/
/* 操作结果：依次对L 的数据元素成对交换*/
ElemType t；
int i；
for(i=0；i {t=L. elem[i]； L. elem[i]= L. elem[L. length-i-1]； L. elem[L. length-i-1]=t； } printf("\n")； return OK； } Status ListPrint_Sq(SqList L) { /* 初始条件：顺序线性表L 已存在*/ /* 操作结果：依次对L 的数据元素输出*/ int i； printf("\n")； for(i=0；i printf("%d ", L. elem[i])； return OK； } (4)文件4：seqlistUse. cpp 进行线性表顺序存储结构的基本算法验证 #include"pubuse. h" /* 实现通用常量的定义，常用系统函数的声明*/ typedef int ElemType； /*实现一组整数的操作,将int 型特定义为通用的ElemType 类型名*/ #include"seqlistDef. h" /* 采用线性表的动态分配顺序存储结构定义*/ #include"seqlistAlgo. h" /* 采用顺序表的基本算法定义*/ void main() { SqList L； Status i； int j； ElemType t； /* 首先一定要初始化顺序表*/ i=ListInit_Sq(L)；if(i==1) /* 创建空表L 成功*/ for(j=1；j<=5；j++) /* 在表L 中插入5 个元素，每个元素的值分别为2，4，6，8，10 */ i=ListInsert_Sq(L,j,2*j)； ListPrint_Sq(L)； /*检验一下插入的结果，输出表L 的内容*/ ListInsert_Sq(L,2,20)；/* 随机指定插入点位置，假设在第二个元素前插入新的元素，其值为20 */ ListDelete_Sq(L,4,&t)；/* 随机指定删除点位置，假设对第四个元素进行删除*/ printf("\n The Deleted value is %d",t)；/* 检验一下删除点元素的值*/ ListPrint_Sq(L)；/* 检验一下插入和删除后的结果，输出表La 的内容*/ ListReverse_Sq(L)；/* 将顺序表La 的所有元素进行逆序*/ ListPrint_Sq(L)；/* 检验一下逆序的结果，输出表L 的内容*/ } 三、实验结果 四、实验分析 1)for(p=L. elem+L. length-1；p>=q；--p) /* 插入位置及之后的元素右移*/ 在此处应该填上代码：*(p+1)=*p； 2)for(++p；p<=q；++p) /* 被删除元素之后的元素左移*/ 在此处应该填上代码：*(p-1)=*p； 五、实验总结 此次试验比较难，考察了线性表的逻辑特征，线性表顺序存储结构的特点，线性表的链式存储结构定义 及基本操作，循环链表和双链表的特点和基本运算。 通过此次线性表的存储结构实验，让我明白了线性表的逻辑特征、线性表顺序存储结构的特点，顺序表的基本运算、线性表的链式存储结构定义及基本操作、理解循环链表和双链表的特点和基本运算、加深对顺序存储数据结构的理解和链式存储数据结构的理解，逐步培养解决实际问题的编程能力。 实验项目名称：线性表的顺序存储结构上的基本运算 （所属课程：数据结构--用C语言描述） 院系：计算机科学与信息工程学院专业班级：网络工程 姓名：000000 学号：0000000000 实验日期：2016.10.20 实验地点：A-06 406 合作者：指导教师：孙高飞 本实验项目成绩：教师签字：日期： （以下为实验报告正文） 一、实验目的 本次实验的目的掌握顺序表的存储结构形式及其描述和基本运算的实现；掌握动 态链表结构及相关算法设计 实验要求：输入和验证程序例题。正确调试程序，记录程序运行结果。完成实验报 告。 二、实验条件 Windows7系统的电脑，vc++6.0软件，书本《数据结构--用c语言描述》 三、实验内容 3.1 根据41页代码，用c语言定义线性表的顺序存储结构。 3.2 根据42页算法2.1实现顺序表的按内容查找。 3.3 根据43页算法2.2实现顺序表的插入运算。 3.4 根据45页算法2.3实现顺序表的删除运算。 四、实验步骤 3.2实验步骤 （1）编写头文件，创建ElemType。 （2）根据根据41页代码，“用c语言定义线性表的顺序存储结构”定义顺序表。 （3）根据42页算法2.1实现顺序表的按内容查找，创建Locate函数。 （4）创建main函数，输入SeqList L的数据元素。 （5）输入要查找的数据元素的值，调用Locate函数，输出结果。 3.3实验步骤 （1）编写头文件，创建ElemType。 （2）根据41页代码，“用c语言定义线性表的顺序存储结构”定义顺序表。 （3）根据43页算法2.2实现顺序表的插入运算，创建InsList函数。 （4）创建printList函数，逐项输出顺序表内的元素及顺序表元素的个数。 （5）创建main函数，输入插入的元素和其位置，调用printLinst函数输出顺序表，调用IntList函数，再次调用printLinst函数输出顺序表。 3.4实验步骤 （1）编写头文件，创建ElemType。 （2）根据根据41页代码，“用c语言定义线性表的顺序存储结构”定义顺序表。 （3）根据45页算法2.3实现顺序表的删除运算，创建DelList函数。 （4）创建printList函数，逐项输出顺序表内的元素及顺序表元素的个数。 （5）创建main函数，输入删除元素的位置，调用printLinst函数输出顺序表，调用DelList函数，再次调用printLinst函数输出顺序表。 五、实验结果 （1）实验3.2顺序表的按内容查找 # include 实验1 线性表的基本操作 一、需求分析 目的： 掌握线性表运算与存储概念，并对线性表进行基本操作。 1.初始化线性表； 2.向链表中特定位置插入数据； 3.删除链表中特定的数据； 4.查找链表中的容； 5.销毁单链表释放空间； 二、概要设计 ●基础题 主要函数： 初始化线性表InitList（List* L，int ms） 向顺序表指定位置插入元素InsertList（List* L，int item，int rc）删除指定元素值的顺序表记录DeleteList1(List* L,int item) 删除指定位置的顺序表记录 DeleteList2（List* L,int rc） 查找顺序表中的元素 FindList（List L，int item） 输出顺序表元素OutputList（List L） 实验步骤： 1，初始化顺序表 2，调用插入函数 3，在顺序表中查找指定的元素 4，在顺序表中删除指定的元素 5，在顺序表中删除指定位置的元素 6，遍历并输出顺序表 ●提高题 要求以较高的效率实现删除线性表中元素值在x到y（x和y自定义）之间的所有元素 方法： 按顺序取出元素并与x、y比较，若小于x且大于y，则存进新表中。 编程实现将两个有序的线性表进行合并，要求同样的数据元素只出现一次。 方法： 分别按顺序取出L1，L2的元素并进行比较，若相等则将L1元素放进L中，否则将L 1，L2元素按顺序放进L。 本程序主要包含7个函数 主函数main() 初始化线性表InitList（List* L，int ms） 向顺序表指定位置插入元素InsertList（List* L，int item，int rc）删除指定元素值的顺序表记录DeleteList1(List* L,int item) 删除指定位置的顺序表记录 DeleteList2（List* L,int rc） 查找顺序表中的元素 FindList（List L，int item） 输出顺序表元素OutputList（List L） 提高题的程序 void Combine(List* L1,List* L2,List* L) void DeleteList3(List* L,int x,int y) 二、详细设计 初始化线性表InitList（List* L，int ms） void InitList(List* L,int ms) { L->list=(int*)malloc(LIST_INIT_SIZE*sizeof(int)); L->size=0; L->MAXSIZE=LIST_INIT_SIZE; 数据结构综合练习 一、选择题 1．数据的存储结构包括顺序、链接、散列和（）4种基本类型。 A索引B数组C集合D向量 2．下面程序的时间复杂性的量级为（）。 inti=0，s1=0，s2=0； while（i++ A.查找 B.表尾插入和删除 C.按值插入和删除 D.表头的插入和删除 9. 线性表的顺序存储比链式存储更有利于进行（）操作。 A.查找 B.表尾插入和删除 C.按值插入和删除 D.表头的插入和删除 10. 在一个表头指针为ph的单链表中，若要向表头插入一个由指针p指向的结点，则应执行（）操作。 A. ph=p; p->next=ph; B. p->next=ph; ph=p; C. p->next=ph; p=ph; D. p->next=ph->next; ph->next=p; 11. 在一个表头指针为ph的单链表中，若要在指针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; 12.在一个单链表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; 13.栈的插入和删除操作在（）进行。 A. 栈顶 B. 栈底 C. 任意位置 D. 指定位置 14.若让元素1，2，3，4依次进栈，则出栈次序不可能出现（）的情况。 A.3，2，1，4 B.2，1，4，3 C.4，3，2，1 D.1，4，2，3. 15. 假定一个顺序循环队列的队首和队尾指针分别用f和r表示，则 判断队空的条件为（）。 A.f+1==r B.r+1==f C.f==0 D.f==r 16. 假定一个顺序循环队列存储于数组a[N]，其队首和队尾指针分别 1.3线性表及其顺序存储结构 1.线性表的基本概念 线性表是由n个数据元素组成的一个有限序列，表中的每一个数据元素，除了每一个外，有且只有一个前件，除了最后一个外，有且只有一个后件。即线性表或是一个空表。 显然线性表是一种线性结构，数据元素在线性表中的位置只取决于它们自己的序号，即数据元素之间的相对位置是线性的。 非空线性表有如下一些结构特征： （1）有且只有一个根结点，它无前件； （2）有且只有一个根结点，它无后件； （3）除了根结点与终端结点外，其他所有结点有且只有一个前件，也只有且只有一个后件。 2.线性表的存储结构 线性表的顺序存储结构具有以下两个特征： （1）线性表中所有元素所占的存储空间是连续的； （2）线性表中各数据元素在存储空间中是按逻辑顺序依次存放的。 由此可以看出，在线性表的顺序存储结构中，其前件和后件两个元素在存储空间中是紧邻的，且其前件元素一定存储在后件元素的前面。 在程序设计语言中，通常定义一个一维数组来表示线性表的顺序存储看见。因为程序设计语言中的一维数组与计算机中的实际的存储空间结构是类似的，这就便于用程序设计语言对线性表进行各种运算处理。 在线性表的顺序存储结构中，可以对线性表进行各种处理。主要的运算有如下几种： （1）在线性表的指定位置处加入一个新的元素； （2）在线性表中删除指定的元素； （3）在线性表中查找某个特定的元素； （4）对线性表中的元素进行整序； （5）按要求将一个线性表分解成多个线性表； （6）按要求将多个线性表合并成一个线性表； （7）复制一个线性表； （8）逆转一个线性表等。 3.顺序表的插入运算 设长度为n的线性表为 （a1,a2,a3,a4,…,ai, …,an） 现要在线性表的第i个元素ai之前插入一个新元素b,插入后得到长度为n+1的线性表为 （a1,a2,a3,a4,…,aj,aj+1, …,an,an+1） 则插入前后的两线性表中的元素满足如下关系： a j0 线性表 顺序表 语言级上的类型定义描述 const maxsize=顺序表的容量: typedef struct {datatype data[maxsize]; int last; }sqlist; sqlist L; 基本运算的实现 1.插入 void insert_sqlist(sqlist L,datatype x,int i) 2.删除 void delete_sqlist(sqlist L,int i); 3.定位 int locate_sqlist(sqlist L,datatype X) 4.求表长 5.读表元 单链表 语言级上的类型定义描述 typedef struct node *pointer; struct node {datatype data; pointer next; }; typedef pointer lklist; 基本运算的实现 1.初始化 lklist initiate_lklist() 2.求表长 int length_lklist(lklist head) 3.按序号查找 pointer find_lklist(lklist head,int i) 4.定位 int locate_lklist(lklist head,datatype x) 5.删除 void delete_lklist(lklist head,int i) 6.插入 void insert_lklist(lklist head,datatype x,int i) 7.建表 lklist create_lklist1() 8.清除重复结点 void purge_lklist(lklist head) 双链表 语言级上的类型定义描述typedef struct dnode *dpointer; struct dnode {datatype data; dpointer prior,next; } typedef dpointer dlklist; 串 语言级上的类型定义描述const maxlen=串的最大长度; typedef struct 第2章线性表 班级学号__________-姓名 一、判断正误 （×）1. 链表的每个结点中都恰好包含一个指针。 链表中的结点可含多个指针域，分别存放多个指针。例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。 （×）2. 链表的物理存储结构具有同链表一样的顺序。 链表的存储结构特点是无序，而链表的示意图有序。 （×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。 链表的结点不会移动，只是指针内容改变。 （×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。 （×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。 正好说反了。顺序表才适合随机存取，链表恰恰适于“顺藤摸瓜” （×）6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。 前一半正确，但后一半说法错误，那是链式存储的优点。顺序存储方式插入、删除运算效率较低，在表长为n的顺序表中，插入和删除一个数据元素，平均需移动表长一半个数的数据元素。 （×）7. 线性表在物理存储空间中也一定是连续的。 线性表有两种存储方式，顺序存储和链式存储。后者不要求连续存放。 （×）8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。 线性表有两种存储方式，在顺序存储时，逻辑上相邻的元素在存储的物理位置次序上也相邻。 （×）9. 顺序存储方式只能用于存储线性结构。 顺序存储方式不仅能用于存储线性结构，还可以用来存放非线性结构，例如 完全二叉树是属于非线性结构，但其最佳存储方式是顺序存储方式。（后一节介绍） （×）10. 线性表的逻辑顺序与存储顺序总是一致的。 理由同7。链式存储就无需一致。 二、单项选择题 （C ）1．数据在计算机存储器内表示时，物理地址与逻辑地址相同并且是连续的，称之为：（A）存储结构（B）逻辑结构（C）顺序存储结构（D）链式存储结构（ B ）2. 一个向量第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（A）110 （B）108 （C）100 （D）120 （ A ）3. 在n个结点的顺序表中，算法的时间复杂度是O（1）的操作是： （A）访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） （B）在第i个结点后插入一个新结点（1≤i≤n） （C）删除第i个结点（1≤i≤n） （D）将n个结点从小到大排序 （ B ）4. 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动个元素（A）8 （B）63.5 （C）63 （D）7 （ A ）5. 链式存储的存储结构所占存储空间： 重庆交通大学 《算法与数据结构》课程 实验报告 班级：计算机科学与技术2014级2班 实验项目名称：线性表的顺序储存结构 实验项目性质： 实验所属课程：算法与数据结构 实验室(中心)： B01407 指导教师：鲁云平 实验完成时间：2016 年 3 月21 日 一、实验目的 1、实现线性表的顺序存储结构 2、熟悉C++程序的基本结构，掌握程序中的头文件、实现文件和主文件之间的相互关系及各自的作用 3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现 二、实验内容及要求 对顺序存储的线性表进行一些基本操作。主要包括： （1）插入：操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入 （2）删除：操作方式可分为删除指定元素、删除指定位置的元素等，尝试实现逻辑删除操作。 （3）显示数据 （4）查找：查询指定的元素（可根据某个数据成员完成查询操作）（5）定位操作：定位指定元素的序号 （6）更新：修改指定元素的数据 （7）数据文件的读写操作等。 其它操作可根据具体需要自行补充。 要求线性表采用类的定义,数据对象的类型自行定义。 三、实验设备及软件 VC6.0 四、设计方案 ㈠题目 线性表的顺序存储结构 ㈡设计的主要思路 1、新建SeqList.h头文件，定义SeqList模板类 2、设计类数据成员，包括：T *data（用于存放数组）、int maxSize（最大可容表项的项数）、int last（当前已存表项的最后位置） 3、设计类成员函数，主要包括： int search(T& x)const;//搜索x在表中位置，函数返回表项序号 int Locate(int i)const;//定位第i个表项，函数返回表项序号 bool getData(int i,T& x)const;//去第i个表项的值 void setData(int i,T& x)//用x修改第i个表项的值 bool Insert(int i,T& x);//插入x在第i个表项之后 bool Remove(int i,T& x); //删除第i个表项，通过x返回表项的值 bool IsEmpty();//判表空否，空则返回true；否则返回false bool IsFull();//判表满否，满则返回true；否则返回false void input(); //输入 void output();//输出 交通大学《算法与数据结构》课程 实验报告 班级：计算机科学与技术2014级2班 实验项目名称：线性表的顺序储存结构 实验项目性质： 实验所属课程：算法与数据结构 实验室(中心)： B01407 指导教师：鲁云平 实验完成时间：2016 年 3 月21 日 一、实验目的 1、实现线性表的顺序存储结构 2、熟悉C++程序的基本结构，掌握程序中的头文件、实现文件和主文件之 间的相互关系及各自的作用 3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现 二、实验容及要求 对顺序存储的线性表进行一些基本操作。主要包括： （1）插入：操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入 （2）删除：操作方式可分为删除指定元素、删除指定位置的元素等，尝试实现逻辑删除操作。 （3）显示数据 （4）查找：查询指定的元素（可根据某个数据成员完成查询操作） （5）定位操作：定位指定元素的序号 （6）更新：修改指定元素的数据 （7）数据文件的读写操作等。 其它操作可根据具体需要自行补充。 要求线性表采用类的定义,数据对象的类型自行定义。 三、实验设备及软件 VC6.0 四、设计方案 ㈠题目 线性表的顺序存储结构 ㈡设计的主要思路 1、新建SeqList.h头文件，定义SeqList模板类 2、设计类数据成员，包括：T *data（用于存放数组）、int maxSize （最大可容表项的项数）、int last（当前已存表项的最后位置） 3、设计类成员函数，主要包括： int search(T& x)const;//搜索x在表中位置，函数返回表项序号 int Locate(int i)const;//定位第i个表项，函数返回表项序号 bool getData(int i,T& x)const;//去第i个表项的值 void setData(int i,T& x)//用x修改第i个表项的值 bool Insert(int i,T& x);//插入x在第i个表项之后 bool Remove(int i,T& x); //删除第i个表项，通过x返回表项的值 bool IsEmpty();//判表空否，空则返回true；否则返回false bool IsFull();//判表满否，满则返回true；否则返回false void input(); //输入 void output();//输出 void ofile();/存储在文件中 void ifile();//读取文件并显示 ㈢主要功能 1、建立新表 2、对表进行插入（指定元素前、后以及指定位置插入）、删除（指定 元素删除及指定位置删除）、修改等操作 3、显示当前操作表的全部容 4、存储在文件中 5、从文件中读取表 五、主要代码 ㈠SeqList.h中的主要代码： 1、类成员声明部分： protected: T *data; //存放数组 int maxSize; //最大可容纳表项 《数据结构》 第二章线性表习题 一、单项选择题 1. 线性表是________。 A．一个有限序列，可以为空B．一个有限序列，不可以为空 C．一个无限序列，可以为空D．一个无限序列，不可以为空 2. 在一个长度为n的顺序表中删除第i个元素(0<=i<=n)时，需向前移动个元素。 A．n-i B．n-i+l C．n-i-1 D．i 3. 线性表采用链式存储时，其地址________。 A．必须是连续的B．一定是不连续的 C．部分地址必须是连续的D．连续与否均可以 4. 从一个具有n个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较________个元素结点。 A．n/2 B．n C．（n+1）/2 D．（n-1）/2 5. 在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是____。 A． p->next=s; s->prior=p; p->next->prior=s; s->next=p->next; B． s->prior=p; s->next=p->next; p->next=s; p->next->prior=s; C． p->next=s; p->next->prior=s; s->prior=p; s->next=p->next; D． s->prior=p; s->next=p->next; p->next->prior=s; p->next=s; 6. 设单链表中指针p指向结点m，若要删除m之后的结点（若存在），则需修改指针的操作为________。A．p->next=p->next->next; B．p=p->next; C．p=p->next->next; D．p->next=p; 7. 在一个长度为n的顺序表中向第i个元素(0< i 第二章线性表 一、填空题 1、数据逻辑结构包括线性结构、树型结构、图型结构这三种类型，树形结构和图形结构合称为非线性结构。 2、在线性结构中，第一个结点没有前驱结点，其余每个结点有且只有个前驱结点，最后一个结点没有后续结点，其余每个结点有且只有一个后续结点。 3、在顺序表中插入或删除一个元素，需要平均移动一半元素，具体移动的元素个数与插入或删除的位置有关。 4、在顺序表中，逻辑上相邻的元素，其物理位置一定相邻。在单链表中，逻辑上相邻的元素，其物理位置不一定相邻。 5、在带头结点的非空单链表中，头结点的存储位置由头指针指示，首元素结点的存储位置由头结点的next域指示，除首元素结点外，其它任一元素结点的存储位置由其直接前趋结点的next域指示。 6、阅读下列算法，并补充所缺内容。 void purge_linkst( ListNode *& la ) { // 从头指针为 la 的有序链表中删除所有值相同的多余元素，并释放被删结点空间ListNode *p,*q; if(la==NULL) return; q=la; p = la->link; while (p) { if (p && ___(1)p->data!=q->data___) {q=p; p = p->link;} else { q->link= ___(2)p->link___; delete(p); p=___(3)q->link___; } }//while }// purge_linkst 二、选择题 1、在数据结构中，从逻辑上可以把数据结构分成 C。 A、动态结构和静态结构 B、紧凑结构和非紧凑结构 C、线性结构和非线性结构 D、内部结构和外部结构 2、线性表的逻辑顺序与存储顺序总是一致的，这种说法 B。 A、正确 B、不正确 3、线性表若采用链式存储结构时，要求内存中可用存储单元的地址D。 A、必须是连续的 B、部分地址必须是连续的 C、一定是不连续的 D、连续或不连续都可以 4、在以下的述叙中，正确的是B。 A、线性表的线性存储结构优于链表存储结构 B、二维数组是其数据元素为线性表的线性表 C、栈的操作是先进先出 D、队列的操作方式是先进后出 三、综合题 1、已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。 A、在P结点后插入S结点的语句序列是（（4）、（1））； B、在P结点前插入S结点的语句序列是（（7）、（11）、（8）、（4）、（1））； C、在表首插入S结点的语句序列是（（5）、（12））； 南昌航空大学实验报告 课程名称：数据结构实验名称：实验二线性表的链式存储结构 班级：学生姓名：冯华华学号：11046213 指导教师评定： XXX 签名: XXX 一、问题描述 1单链表的实现与操作。 2设计一个程序求出约瑟夫环的出列顺序。约瑟夫问题的一种描述是：编号为1，2，…， n的n个人按顺时针方向围坐一圈，每个人持有一个密码（正整数）。一开始任选一个正整 数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。 报m的人出列，将他的密码作为新的m 值，从他在顺时针方向上的下一个人开始重新从1 报数，如此下去，直到所有人全部出列为止。例如，n=7,7个人的密码依次为： 3,1,7,2,4,8,4,m的初值取6，则正确的出列顺序应为6,1,4,7,2,3,5。要求使用单向循环 链表模拟此出列过程。 二、程序分析 约瑟夫环的大小是变化的，因此相应的结点也是变化的，使用链式存储结构可以动态的 生成其中的结点，出列操作也非常简单。用单向循环链表模拟其出列顺序比较合适。 用结构指针描述每个人： struct Joseph {int num;/*环中某个人的序号*/ int secret;/环中某个人的密码*/ struct Joseph *next;/指向其下一个的指针*/}; 1）初始化约瑟夫环： 调用函数struct Joseph *creat()生成初始约瑟夫环。在该函数中使用head 指向 表头。输入序号为0时结束，指针p1指向的最后结束序号为0的结点没有加入到 链表中，p2 指向最后一个序号为非0 的结点（最后一个结点）。 2）报数出列： 调用函数voil sort(struct Joseph * head,int m)，使用条件p1->next!=p1判断 单向链表非空，使用两个指针变量p1和p2，语句p2=p1;p1=p1->next;移动指针， 计算结点数（报数）；结点p1出列时直接使用语句：p2->next=p1->next，取出该 结点中的密码作为新的循环终值。 三、调试过程及实验结果 最后程序运行结果如下所示： 输入数据：数据格式为序号，密码 输入0，0为结束 1，3↙<回车> 2，1↙<回车> 第2章线性表 1．下面关于线性表的叙述中，错误的是哪一个？（）A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表采用链接存储，便于插入和删除操作。 2．线性表是具有n个（）的有限序列（n>0）。 A．表元素 B．字符 C．数据元素 D．数据项 E．信息项 3.线性表（ a1,a2,…,an）以链接方式存储时，访问第i位置 元素的时间复杂性为（） A．O（i） B．O（1） C．O（n） D．O（i-1） 4.若长度为n的线性表采用顺序存储结构，在其第i个位置插 入一个新元素的算法的时间复杂度为（）(1<=i<=n+1)。 A. O(0) B. O(1) C. O(n) D. O(n2) 5. 对于顺序存储的线性表，访问结点和增加、删除结点的时间 复杂度为（）。 A．O(n) O(n) B. O(n) O(1) C. O(1) O(n) D. O(1) O(1) 6．对于一个头指针为head的带头结点的单链表，判定该表为空 表的条件是（） A．head==NULL B．head→next==NULL C．head→next==head D．head!=NULL 7.链表不具有的特点是（） A．可随机访问任一元素 B．插入、删除不需要移动元素 C．不必事先估计存储空间 D．所需空间与线性长度成正比 8.在双向链表指针p的结点前插入一个指针q的结点操作是（）。 >Llink=q;q->Rlink=p;p->Llink->Rlink=q;q->Llink=q； >Llink=q;p->Llink->Rlink=q;q->Rlink=p;q->Llink=p->Llink ; C. q->Llink=p->Llink;q->Rlink=q;p->Llink=q;p->Llink=q; >Rlink=p;q->Llink=p->Llink;p->Llink->Rlink=q;p->Llink=q ; 9.在单链表指针为p的结点之后插入指针为s的结点，正确的 操作是：（）。 A． s->next=p->next;p->next=s; B． p->next=s;s->next=p->next; C．p->next=s;p->next=s->next; D． p->next=s->next;p->next=s; 10．对于一个头指针为head的带头结点的单链表，判定该表为 线性表典型例题 一、单项选择题 [例7-1]在数据结构中，与所使用计算机无关的数据叫( ①)结构；链表是一种采用( ②)存储结构存储的线性表；链表适用于( ③)查找；在链表中进行( ④)操作的效率比在线性表中进行该操作的效率高。 ①A．存储B．物理C．逻辑D．物理和逻辑 ②A．顺序B．网状C．星式D．链式 ③A．顺序B．二分法C．顺序及二分法D．随机 ④A．二分法查找B．快速查找C．顺序查找D．插入 解析：本题考查的是基本概念。本题答案为：①C；②D；③A；④D。 [例7-2] 链表不具备的特点是( )。 A．插入和删除不需要移动元素B．可随机访问任一结点 C．不必预分配空间D．所需空间与其长度成正比 解析：线性表可随机访问任一结点，而链表必须从第一个数据结点出发逐一查找每个结点。本题答案为：B。 [例7-3] 不带头结点的单链表head为空的判定条件是( )。 A．head＝＝NULL B．head_>next＝＝NULL C．head_>next＝＝head D．head!＝NULL 解析：在不带头结点的单链表head中，head指向第一个数据结点。空表即该表没有结点，head＝＝NULL表示该单链表为空。本题答案为：A。 [例7-4] 带头结点的单链表head为空的判定条件是( )。 A．head＝＝NULL B．head—>next＝＝NULL C．head—> next＝＝head D．head!＝NULL 解析：在带头结点的单链表head中，head指向头结点。空表即该表只有头结点，head —>next＝＝NULL表示该单链表为空。本题答案为：B。 [例7-5] 带头结点的循环单链表head中，head为空的判定条件是( )。 A．head＝＝NULL B．head—>next＝＝NULL C．head—> next＝＝head D．head!＝NULL 解析：在带头结点的循环单链表head中，head指向头结点。空表即该表只有头结点，head—>next＝＝head表示该单链表为空。本题答案为：C。 [例7-6] 线性表采用链式存储时其存储地址( )。 A．必须是连续的B．部分地址必须是连续的 C．一定是不连续的D．连续不连续都可以 解析：链式存储采用动态存储，地址一般不连续。本题答案为：D。 [例7-7] 在双向链表的* p结点前插入新结点*s的操作为( )。 A．p—>prior=s；s—>next=p；p—>prior—>next=s；s—>prior=p—>prior； B．p—>prior=s；p—>prior—>next=s；s—>next=p；s—>prior=p—>prior； C．s—>next=p；s—>prior=p—>prior；p—>prior=s；p—>prior—>next=s； D．s—>next=p；s—>prior=p—>prior；p—>prior—>next=s；p—>prior=s； 解析：在双向链表的* p结点前插入新结点* s的操作如图7.12所示，图中虚线为所作的操作，序号为操作顺序。本题答案为：D。 1.实验目的 掌握线性表的链式存储结构设计与基本操作的实现。 2.实验内容与要求 ⑴定义线性表的链式存储表示； ⑵基于所设计的存储结构实现线性表的基本操作； ⑶编写一个主程序对所实现的线性表进行测试； ⑷线性表的应用：①设线性表L1和L2分别代表集合A和B，试设计算法求A和B的并集C，并用线性表L3代表集合C；②设线性表L1和L2中的数据元素为整数，且均已按值非递减有序排列，试设计算法对L1和L2进行合并，用线性表L3保存合并结果，要求L3中的数据元素也按值非递减有序排列。 ⑸设计一个一元多项式计算器，要求能够：①输入并建立多项式；②输出多项式；③执行两个多项式相加；④执行两个多项式相减； 3.数据结构设计 逻辑结构：线性结构 存储结构：链式存储结构 4.算法设计 #include #include 抽象数据类型线性表的定义如下： ADT List { 数据对象：D={ a i | a i∈ElemSet, i =1, 2, ……, n, n≥0} 数据关系：R1 = { < a i-1 , a i > | a i-1 , a i ∈D, i =2, ……, n } 基本操作： InitList (&L ) 操作结果：构造一个空的线性表L 。 DestoryList (&L) 初始条件：线性表L已存在。 操作结果：销毁线性表L。 ClearList (&L) 初始条件：线性表L已存在。 操作结果：将L重置为空表。 ListEmpty (L) 初始条件：线性表L已存在。 操作结果：若L 为空表，则返回TRUE，否则返回FALSE。 ListLength (L) 初始条件：线性表L已存在。 操作结果：返回L中数据元素个数。 GetElem ( L, i, &e ) 初始条件：线性表L已存在，1≤i≤ListLength(L)+1。 操作结果：用e返回L中第i个数据元素的值。 LocateElem ( L,e, compare() ) 初始条件：线性表L已存在，compare()是判定函数。 操作结果：返回L中第1个与e满足关系compare() 的数据元素的位序。若这样的数据元素不存在，则返 回值0。 PriorElem ( L, cur_e, &pre_e ) 初始条件：线性表L已存在。 操作结果：若cur_e是L的数据元素且不是第1个， 则用pre_e返回它的前驱，否则操作失败。 NextElem ( L, cur_e, &next_e ) 初始条件：线性表L已存在。 操作结果：若cur_e是L的数据元素且不是最后一个， 则用next_e返回它的后继，否则操作失败。 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返回其值， 第二章线性表练习题 一、选择题 1.线性表是具有n个的有限序列。 A、表元素 B、字符 C、数据元素 D、数据项 E、信息项 2.线性表的静态链表存储结构与顺序存储结构相比优点是。 A、所有的操作算法实现简单 B、便于随机存储 C、便于插入和删除 D、便于利用零散的存储器空间 3.若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素算法的时间复杂度为。 A、O(log2n) B、O(1) C、O(n) D、O(n2) 4.（1）静态链表既有顺序存储的特点，又有动态链表的优点。所以，它存取表中第i个元素的时间与i无关； （2）静态链表中能容纳元素个数的最大数在定义时就确定了，以后不能增加；（3）静态链表与动态链表在元素的插入、删除上类似，不需做元素的移动。 以上错误的是。 A、（1）、（2） B、（1） C、（1）、（2）、（3） D、（2） 6.在双向链表存储结构中，删除p所指的结点时须修改指针。 A、p－＞next－＞prior=p－＞prior; p－＞prior－＞next=p－＞next; B、p－＞next=p－＞next－＞next;p－＞next－＞prior=p; C、p－＞prior－＞next=p;p－＞prior=p－＞prior－＞prior; D、p－＞prior=p－＞next－＞next;p－＞next=p－＞prior－＞prior; 7.在双向循环链表中，在P指针所指的结点后插入q所指向的新结点，其修改指针的操作是。 A、p－＞next=q; q－＞prior=p;p－＞next－＞prior=q;q－＞next=q; B、p－＞next=q;p－＞next－＞prior=q;q－＞prior=p;q－＞next=p－＞next; C、q－＞prior=p; q－＞next=p－＞next; p－＞next－＞prior=q; p－＞next=q; D、q－＞next=p－＞next;q－＞prior=p;p－＞next=q;p－＞next=q; 8.将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是。 A、 n b、2n－1 c、2n d、n－1 9.在一个长度为n的顺序表中，在第i个元素（1≤i≤n+1）之前插入一个新元素时须向后移动个元素。 A、n－i B、n－i+1 C、n－i－1 D、i 10.线性表L=(a1，a2,……an)，下列说法正确的是。 A、每个元素有有一个直接前驱和一个直接后继 B、线性表中至少有一个元素 C、表中诸元素的排列必须是由小到大或由大到小。 D、除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。 11.对单链表表示法，以下说法错误的是。 A、数据域用于存储线性表的一个数据元素 B、指针域(或链域)用于存放一指向本结点所含数据元素的直接后继所在结点的指针 C、所有数据通过指针的链接而组织成单链表 D、NULL称为空指针，它不指向任何结点只起标志作用线性表顺序存储结构上的基本运算
数据结构_实验1_线性表的基本操作
数据结构(含答案)
3线性表及其顺序存储结构
线性表类型定义
数据结构第2章作业 线性表(答案)
线性表的顺序储存结构
线性表的顺序储存结构
数据结构 第二章 线性表习题
第二章_线性表(参考答案)
实验二 线性表的链式存储结构
第2章线性表(课堂作业)
线性表习题2
数据结构线性表的链式存储结构
线性表顺序存储实现、插入、删除操作
抽象数据类型线性表的定义
第2章线性表习题解析(答)