本章主要介绍下列内容1、线性表及其逻辑结构;2、线性表的顺序.
本章主要介绍下列内容：1、线性表及其逻辑结构；2、线性表的顺序存储结构；3、线性表的链式存储结构；
4、线性表的应用举例
课时分配：1、2占2学时，3占2学时, 4占2学时，上机2学时
重点、难点：线性表的顺序存储结构、链式存储结构、循环链表
§2.1 线性表及其逻辑结构
2.1.1 线性表的定义
线性表是由n（n≥0）个类型相同的数据元素组成的有限序列。通常表示成下列形式：
L=( a1, a2,...,a i-1,a i,a i+1,...,a n)
其中：L为线性表名称，习惯用大写书写；
a i为组成该线性表的数据元素，习惯用小写书写；
线性表中数据元素的个数被称为线性表的长度，当n=0时，线性表为空，又称为空线性表。
例2-1 线性表形式
La=（34，89，765，12，90，-34，22）数据元素类型为int。
Ls=(“Hello”,“World”, “China”, “Welcome”) 数据元素类型为string。
Lb=(book1,book2,...,book100) 数据元素类型为下列所示的结构类型：
struct bookinfo{
int No; //图书编号
char *name; //图书名称
char *author; //作者名称
...;
}
2.1.2 线性表的抽象数据类型描述
ADT List
{
数据对象：
D＝{a i| 1<=i<=n,n>=0, a i属ElemType类型}
数据关系：
基本运算：（略介绍）
（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)
（11）删除线性表L中第i个数据元素ListDelete(L,i,e)
}
§2.2 线性表的顺序存储结构
2.2.1 线性表的顺序存储结构
线性表的顺序存储结构是指用一组连续的存储单元依次存储线性表中的每个数据元素，也称为顺序表。如
下图所示：
其中，L为每个数据元素所占据的存储单元数目。
相邻两个数据元素的存储位置计算公式：LOC(ai+1)=LOC(ai)+L
线性表中任意一个数据元素的存储位置的计算公式为：LOC(ai+1)=LOC(a1)+(i-1)*L
顺序存储结构的特点：
（1）利用数据元素的存储位置表示线性表中相邻数据元素之间的前后关系，即线性表的逻辑结构与存储结构（物理结构）一致；
（2）在访问线性表时，可以利用上述给出的数学公式，快速地计算出任何一个数据元素的存储地址。因此，我们可以粗略地认为，访问每个数据元素所花费的时间相等。这种存取元素的方法被称为随机存取法，使用这种存取方法的存储结构被称为随机存储结构。
在C语言中，实现线性表的顺序存储结构的类型定义：
#define MAXSIZE 100 /* MAXSIZE 为线性表可能的最大长度*/
#define ERROR -1
typedef struct
{ /* 线性表定义*/
int elements[MAXSIZE];
int last; /* last为线性表的长度*/
} SqList; 注：为帮助学生考研，上课讲解用指针形式。
2.2.2典型操作的算法实现：
（1）初始化线性表L
void InitList(SqList *L)
{ /*初始化操作，将线性表L置空*/
L->last = 0;
}
（2）销毁线性表L
void DestroyList(SqList *L)
{
if (L->elem) free(L->elem); //释放线性表占据的所有存储空间
}
（3）清空线性表L
void Clear(SqList *L)
{ /* 清空线性表L */
InitList( L );
}
（4）求线性表L的长度
{
return (L.length);
}
（5）判断线性表L是否为空
bool IsEmpty( SqList L)
{ /*判断表是否为空。如果L是空表，返回true，否则返回false*/
if( https://www.360docs.net/doc/d63991203.html,st == 0 ) return true;
else return false;
}
（6）获取线性表L中的某个数据元素的内容
int GetElem(SqList L,int i)
{ /* 取表中第i元素。*/
if(i<0 || i>=https://www.360docs.net/doc/d63991203.html,st) return ERROR;
else return L.elements[i]; /*C语言中数组的下标从"0"开始*/
}
（7）在线性表L中检索值为e的数据元素
int LocateElem(SqList L,int x)
{ /*定位函数。返回L中第1个与x相等的数据元素的位置（从0算起）。*/ /*否则返回值为0。*/
int k;
k=0;
while (k k++; if(k else return ERROR; } （8）在线性表L中第i个数据元素之前插入数据元素e int Insert(SqList *L,int x,int i) { /*在线性表L中第i（0≤i≤https://www.360docs.net/doc/d63991203.html,st）个数据元素之前插入一个数据元素x*/ int k; if(i<0 || i>L->last || L->last == MAXSIZE) return ERROR; else { for( k=L->last; k>=i; k-- ) L->elements[k]= L->elements[k-1]; L->elements[i]=x; L->last=L->last+1; } return true; } （9）将线性表L中第i个数据元素删除 { /*删除线性表L 中第i （0≤I if( i<0 || i>=L->last ) /* 下标越界 */ return ERROR; else { /* 移动后面的元素 */ for(k=i;k L->elements[k]= L->elements[k+1]; L->last--; } return true; } 插入算法的分析： 设P i 是在第i 个元素之前插入一个元素的概率，假定在顺序表中任何位置插入元素的机会相等，即设P i ＝ 1 1 +n ，则在长度为n 的线性表中插入一个元素时所需移动元素的平均次数为 E （n ）=∑+=+-1 1 )1(P i n i i n = 11 +n ∑ +=+-1 1 )1(n i i n = 2 n 删除算法的分析： 设q i 是删除第i 个元素的概率，假定在顺序表中删除元素的机会相等，即设q i ＝n 1，则在长度为n 的线性表中删除一个元素时所需移动元素的平均次数为 E （n ）=∑=-n i i n 1 )(q i = n 1 ∑=-n i i n 1 )(= 2 1 -n 结论： 在顺序表中插入或删除一个数据元素，平均大约移动表中一半元素。当线性表的长度较大，且插入和删除操作的频度较高时，则花费时间较多，不宜采用顺序存储结构。但是顺序表存储结构简单，便于顺序存储，存储空间的利用率高。 顺序表应用举例： 例2－1 清除顺序表中的重复数据元素。例如，顺序表（2，3，3，4，3，5，4）清除后变为（2，3，4，5）。注：清除重复元素是指删除重复元素，只保留序号最小的一个。 解：具体的算法实现思路是：从顺序表中依次取出每一个元素a i ，并检查a i+1到a n-1中是否有元素与a i 值相等，有就删除重复元素。 v oid ClearList(SqList *L) { /* 清除顺序表中的重复数据元素 */ int i = 0, j; while( i < L->last ) { j = i + 1; while(j<=L->last) { /* 找重复数据元素并删除 */ if( L->elements[i] == L->elements[j] ) Dlete(L,j); /* 下一个元素自动向前移动过来 */ else j++; /* 指针向下移动一个位置 */ } i++; } } §2.3 线性表的链式存储结构 2.3.1 线性表的链式存储结构——链表 线性表顺序存储结构的特点： （1） 简单、方便，要求表中数据元素依次存放在连续的存储单元中，利用数据元素的存储顺序表示相应的逻辑顺序，属于静态存储形式；（2） 在做插入或删除元素的操作时，会产生大量的数据元素移动；（3） 对于长度变化较大的线性表，要一次性地分配足够的存储空间，但这些空间常常又得不到充分的利用；（4） 线性表的容量难以扩充。 线性表的链式存储结构 线性表的链式存储结构是指用一组任意的存储单元（可以连续，也可以不连续）存储线性表中的数据元素。为了反映数据元素之间的逻辑关系，对于每个数据元素不仅要表示它的具体内容，还要附加一个表示它的直接后继元素存储位置的信息。假设有一个线性表（a,b,c,d ），可用下图所示的形式存储： 可以形象地描述为： 链式存储结构的特点： （1）线性表中的数据元素在存储单元中的存放顺序与逻辑顺序不一定一致； （2）在对线性表操作时，只能通过头指针进入链表，并通过每个结点的指针域向后扫描其余结点，这样就会造成寻找第一个结点和寻找最后一个结点所花费的时间不等，具有这种特点的存取方式被称为顺序存取方式。 用C 语言描述单链表的结点结构如下： typedef struct node { /* 单链表结点结构 */ DataType data; /*DataType 可以是任何相应的数据类型如int,char 等*/ struct node *next; } LinkList; 2.3.2 典型操作的算法实现 … head （1）初始化链表L void InitList1( LinkList **head ) { /* 初始化不带头结点的链表头指针*/ *head = NULL; } } （2）销毁链表L void DestoryList(LINK_LIST *L) { LINKLIST *p; while (L->head){ //依次删除链表中的所有结点 p=L->head; L->head=L->head->next; free(p); } } （3）清空链表L void ClearList(LINK_LIST *L) { LINKLIST *p; while (L->head->next){ p=L->head->next; //p指向链表中头结点后面的第一个结点L->head->next=p->next; //删除p结点 free(p); //释放p结点占据的存储空间 } } （4）求链表L的长度 int Length(LinkList *head) {/* 在带头结点的单链表中求表的长度*/ LinkList *p=head; int j=0; while (p->next!=NULL) { j++; p=p->next; /* p右移一个结点*/ } return j; } （5）判链表L空否。 int IsEmpty(LINK_LIST L) { if (L.head->next==NULL) return TRUE; else return FALSE; } （6）通过e返回链表L中第i个数据元素的内容 void GetElem(LINK_LIST L,int i,Elemtype *e) { LINKLIST *p; int j; if (i<1||i>ListLength(L)) exit ERROR; //检测i值的合理性for (p=L.head,j=0; j!=i;p=p->next,j++); //找到第i个结点 *e=p->elem; //将第i个结点的内容赋给e指针所指向的存储单元中 } （7）在链表L中检索值为e的数据元素 LinkList *LocateNode(LinkList *head, int x) {/* 在带头结点的单链表中查找值为x的结点，找到返回结点指针，否则返回NULL */ LinkList *p = head->next; while( p && p->data != x ) p=p->next; return p; } （8）返回链表L中结点e的直接前驱结点 LINKLIST *PriorElem(LINK_LIST L,LINKLIST* e) { LINKLIST *p; if (L.head->next==e) return NULL; //检测第一个结点 for (p=L.head;p->next&&p->next!=e;p=p->next); if (p->next==e) return p; esle return NULL; } （9）返回链表L中结点e的直接后继结点 LINKLIST *NextElem(LINK_LIST L,LINKLIST* e) { LINKLIST *p; for(p=L.head->next;p&&p!=e;p=p->next); if (p) p=p->next; return p; } （10）在链表L中第i个数据元素之前插入数据元素e void AddHead1(LinkList **head, int x ) {/* 向头指针为head的链表中插入一个结点，其值为x */ LinkList *p; p=( LinkList *)malloc(sizeof(LinkList)); p->data = x; p->next = *head; *head = p; /* 调整链表头指针head */ } （11）将链表L中第i个数据元素删除，并将其内容保存在e中。 void DeleteNode（LinkList *head, int i） {/* 在带头结点的单链表中删除第i个结点*/ LinkList *p,*q； p=GetNode(head,i-1); /*找到第i-1个结点 */ if （(p!=NULL)&&(p->next!=NULL)） { q=p->next; /*对应图2.8 ① */ p->next=q->next; /*对应图2.8 ② */ free(q);} /*对应图2.8 ③*/ else printf(“结点未找到！\n ”); } 2.3.3 循环链表 若将单链表中最后一个结点的指针指向链表的第一个结点，那么整个链表就形成了一个环形结构，故称为单链形式的循环链表，并简称为单循环链表。 循环链表的特点：从表中任一结点出发均可访问其他所有结点。 实现循环链表的类型定义与单链表完全相同，它的所有操作也都与单链表类似。只是判断链表结束的条件有所不同。 2.3.4 双向链表 可以在单链表的每个结点内再增加一个指向其直接前驱的链域，这样形成的链表中就有两条方向不同的链，故称为双向链表（Double linked list ）。 双向链表的结点结构C 语言描述： typedef struct dnode { /* 双向链表结点结构 */ DataType data; /*DataType 可以是任何相应的数据类型如int,char 等*/ struct dnode *prior,*next; } DLinkList; 双链表的*p 结点之前插入值为x 的结点插入的过程： 对应算法如下： void InsertDNode(DLinkList *p, int x) {/* 在双链表的*p 结点之前插入值为x 的结点 */ DLinkList *q; q=( DLinkList *)malloc(sizeof(DLinkList)); q->data=x; q->prior=p->prior; /*对应图2.11 ① */ q->next=p; /*对应图2.11 ② */ （a ） 非空循环链表 head 头结点 (b) 空循环链表 头结点 … p->prior->next=q; /*对应图2.11 ③*/ p->prior=q; /*对应图2.11 ④*/ } 在双链表中删除p指针指向的结点的过程： 对应算法如下： void DeleteDNode(DLinkList *p) {/* 在双链表中删除p指针指向的结点 */ p->prior->next=p->next; /*对应图2.12 ① */ p->next->prior=p->prior; /*对应图2.12 ② */ free(p); } 2.3.4 线性表的应用举例 例2－2 有一个不带头结点的单链表L（至少有1个结点），第一个结点指针为head，编写算法将L逆置，即最后一个结点变成第一个结点，倒数第二个结点变成第二个结点，如此等等。 解：逆置的方法是：从头到尾扫描单链表L，将第一个结点的next域设置为NULL，将第二个结点的next域指向第一个结点，将第三个结点的next域指向第二个结点，如此进行直到最后一个结点，用head 指向它。其算法如下： void Invert1( LinkList **head ) { /* 将不带头指针的单链表倒置*/ LinkList *p = *head, *r; LinkList *q = NULL;/* q始终指向当前插入点*/ while( p ) { /* 还有剩余元素时*/ r = p->next; /* r缓存下一个待插入元素指针*/ p->next = q; /* 插入当前的待插元素到新表中*/ q = p; p = r; /* 调整*/ } *head = q; /* 更新头指针*/ } 例2－3 有两个带头结点的单循环链表L1和L2，编写算法将链表L2链接到链表L1之后成为一个单循环链表。 解决本题的具体方法是：如果在用头指针指向的单循环链表上做这个操作，都需要先找到两链表的尾指针，要找尾指针就必须遍历整个链表，找到后将第二个链表的尾指针与第一个链表的头结点链接起来，使之成为循环的链表。若在用尾指针指向的单循环链表上做这个操作，则只需修改指针，操作过程如下图所示。其算法如下： LinkList *InsertOrder(LinkList *rear1, Node *rear2) { /* 在有序单链表L中插入值为x的结点，插入后仍然有序*/ LinkList *p = rear1->next; /*对应图2.13中的①*/ LinkList *q = rear2->next; /*对应图2.13中的②*/ rear1->next = q->next; /*对应图2.13中的③*/ rear2->next = p; /*对应图2.13中的④*/ free(q); return( rear2 ); } §2.5 线性表的应用 约瑟夫（Joseph）问题：编号为1，2，···，n的n个人按顺时针方向围坐在一张圆桌旁，每个人手中持有一个密码（正整数）。首先输入一个正整数作为报数上限值m，然后，从第一个人开始按顺时针方向自1开始顺序报数，报到m的人离开桌旁，并将他手中的密码作为新的m值，从顺时针方向的下一个就坐在桌旁的人人开始重新从1报数，如此下去，直至所有人全部离开桌旁为止。 解：假设有7个人，编号从1到7，他们手中的密码分别是3，1，7，2，4，8，4，最初的m=2，通过报数，这7个人离开桌旁的顺序应该是：2，3，5，4，7，6，1。 数据结构的分析：这个问题的主角是n个人，每个人需要描述的信息有：编号、密码和是否在桌旁的状态。假设有7个人，他们的信息可以表示成下面的形式。 算法描述： 让n个人围坐在一张圆桌旁； for (i=1;i<=n;i++) { 从1开始报数，报到m停止； 报到m的人离开桌子； } 代码实现一（顺序存储方式）： #define LIST_MAX_LENGTH 7 #define n LIST_MAX_LENGTH typedef int Elemtype; //将Elemtype定义为int类型 void Joseph(int code[],int n) {//通过一维数组code带入n个人手中的密码，n是开始就坐在桌旁的人数 SqList people; int temp,m; //m是报数的上限值 scanf("%d",&m); //输入最初的m if (InitList(&people)==ERROR) exit ERROR; for (i=1;i<=n;i++) if (ListInsert(&people,i,code[i-1])==ERROR) exit ERROR; position=0; //记录当前报数人的编号 for (i=1;i<=n;i++) { count=0; //记录当前所报的数目 do{ //报数 position=(position+1)%n; GetElem(people,position,&temp); if (temp>0) count++; }while (count!=m); printf("%d",position); //输出当前离开桌旁人的编号 GetElem(people,position,&m); people.elem[position-1]=-people.elem[position-1]; //将密码变为负值 } } 代码实现二（链式存储方式） 使用一个不带头结点的循环单链表结构。结点结构为： 用C语言定义： typedef struct{ //循环链表中每个结点的数据域部分的类型 int No; //编号 int code; //密码 }INFO; typedef INFO Elemtype; void Joseph(int code[],int n) { LINK_LIST people; LINKLIST *position,*pre; //position指向当前报数的结点 if (InitList(&people)==ERROR) exit ERROR; //初始化链表people for (i=1;i<=n;i++) //以n个人的信息为数据域内容向链表插入n个结点 if (ListInsert(&people,i,code[i-1])==ERROR) exit ERROR; position=people.head; //让position指向最后一个结点，以便报数从第一个开始while (position->next!=people.head) position= NextElem(people,position); scanf("%d",&m); //输入最初的m for (i=1;i { count=0; //报数处理 do{ position=NextElem(people,position); count++; }while (count!=m); printf("%d",position->elem.No); //离开桌子处理 m=position->elem.code; pre=PriorElem(people,position); pre->next=position->next; free(position); position= pre; } printf("%d",position->elem.No); //处理最后一个人free(position); } 实验项目名称：线性表的顺序存储结构上的基本运算 （所属课程：数据结构--用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 昆明理工大学信息工程与自动化学院学生实验报告 （201 —201 学年第一学期） 课程名称：数据结构开课实验室：年月日年级、专业、班学号姓名成绩 实验项目名称线性表链式存储运算的算法实现指导教师 教 师 评语教师签名： 年月日 一.实验内容： 线性表链式存储运算的算法实现，实现链表的建立、链表的数据插入、链表的数据删除、链表的数据输出。 二.实验目的： 1.掌握线性表链式存储结构的C语言描述及运算算法的实现； 2.分析算法的空间复杂度和插入和删除的时间复杂度； 3.总结比较线性表顺序存储存储与链式存储的各自特点。 三.主要程序代码分析： LinkList creatListR1() //用尾插入法建立带头结点的单链表 { char *ch=new char(); LinkList head=(LinkList)malloc(sizeof(ListNode)); //生成头结点*head ListNode *s,*r,*pp; r=head; //尾指针初值指向头结点 r->next=NULL; scanf("%s",ch); //读入第一个结点的值 while(strcmp(ch,"#")!=0) { //输入#结束 pp=LocateNode(head,ch); if(pp==NULL) { s=(ListNode *)malloc(sizeof(ListNode)); //生成新的结点*s strcpy(s->data,ch); r->next=s; //新结点插入表尾 r=s; //尾指针r指向新的表尾 r->next=NULL; } scanf("%s",ch); //读入下一个结点的值 } return head; //返回表头指针 } int Insert(ListNode *head) //链表的插入 { ListNode *in,*p,*q; int wh; in=(ListNode *)malloc(sizeof(ListNode));in->next=NULL; //生成新结点p=(ListNode *)malloc(sizeof(ListNode));p->next=NULL; q=(ListNode *)malloc(sizeof(ListNode));q->next=NULL; scanf("%s",in->data); //输入插入的数据 scanf("%d",&wh); //输入插入数据的位置 for(p=head;wh>0;p=p->next,wh--); q=p->next; p->next=in; in->next=q; } void DeleteList(LinkList head,char *key) //链表的删除 { ListNode *p,*r,*q=head; p=LocateNode(head,key); //按key值查找结点的 if(p==NULL) exit(0); //若没有找到结点，退出 while(q->next!=p) //p为要删除的结点，q为p的前结点q=q->next; r=q->next; q->next=r->next; free(r); //释放结点*r } 四.程序运行结果： 第2章线性表 一选择题 下列程序段的时间复杂度为（ C ）。 for( int i=1;i<=n;i++) for( int j=1;j<= m; j++) A[i][j] = i*j ; A. O(m2) B. O(n2) C. O(m*n) D. (m+n) 下面关于线性表的叙述中，错误的是哪一个？（B ） A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表采用链接存储，便于插入和删除操作。 线性表是具有n个（ C ）的有限序列（n>0）。 A．表元素B．字符C．数据元素D．数据项 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用（ A ）存储方式最节省时间。 A．顺序表B．双链表C．带头结点的双循环链表D．单循环链表 某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用（ D ）存储方式最节省运算时间。 A．单链表B．仅有头指针的单循环链表 C．双链表D．仅有尾指针的单循环链表 设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用( D )最节省时间。A. 单链表 B.单循环链表 C. 带尾指针的单循环链表 D.带头结点的双循环链表 若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。则采用（ D ）存储方式最节省运算时间。 A．单链表B．双链表C．单循环链表D．带头结点的双循环链表 链表不具有的特点是（ B ） A．插入、删除不需要移动元素B．可随机访问任一元素 C．不必事先估计存储空间D．所需空间与线性长度成正比 下面的叙述不正确的是（B,C ） A．线性表在链式存储时，查找第i个元素的时间同i的值成正比 B. 线性表在链式存储时，查找第i个元素的时间同i的值无关 C. 线性表在顺序存储时，查找第i个元素的时间同i 的值成正比 D. 线性表在顺序存储时，查找第i个元素的时间同i的值无关 若长度为n的线性表采用顺序存储结构，在其第i个位置插入一个新元素的算法的时间复杂度为（ C ）(1<=i<=n+1)。 A. O(0) B. O(1) C. O(n) D. O(n2) 对于顺序存储的线性表，访问结点和增加、删除结点的时间复杂度为（C ）。 A．O(n) O(n) B. O(n) O(1) C. O(1) O(n) D. O(1) O(1) 线性表（a1,a2,…,an）以链接方式存储时，访问第i位置元素的时间复杂性为（ C ）A．O（i）B．O（1）C．O（n）D．O（i-1） 循环链表H的尾结点P的特点是（A ）。 A．P->next=H B．P->next= H->next C．P=H D．P=H->next 完成在双循环链表结点p之后插入s的操作是（D ）； 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 实验报告 题目：完成线性表ADT的顺序存储和链式存储方式的实现 一、需求分析 1、本演示程序中，线性表的数据元素类型限定为整型 2、演示程序以用户和计算机的对话方式执行，即在计算机的终端上显示“提 示信息”之后由用户在键盘上键入演示程序规定的运算命令，相应的输出 结果显示在后面。 3、程序的执行命令包括： 创建、撤销、清空、插入、修改、删除、定位等线性表ADT各项基本操作二、概要设计 为实现上述功能，我们给出线性表的抽象数据类型定义，具体的有单向链，双向 链，顺序表等，同时对于上述功能的实现还采用有/无头结点两种方式来实现 1.线性表的抽象数据类型定义为 ADT List{ 数据对象：D={a i|a i∈ElemSet，i=1,2,…,n,n≥0} 数据关系：R1={|ai-1,ai∈D，i=2,…,n} 基本操作： InitList(&L) 操作结果：构造一个空的线性表L DestroyList(&L) 初始条件：线性表L已存在。 操作结果：销毁线性表L。 ClearList(&L) 初始条件：线性表L已存在。 操作结果：将L重置为空表。 ListEmpty(L) 初始条件：线性表L已存在。 操作结果：若L为空表，则返回TRUE，否则返回FALSE。 ListLength(L) 初始条件：线性表L已存在。 操作结果：返回L中的i个数据元素的值。 GetElem(L,i,&e) 初始条件:线性表L已存在，1≤i≤ListLength（L）。 操作结果：用e返回L中第i个数据元素的值。 LocateElem（L,e,compare()） 初始条件：线性表L已存在，compare()是数据元素判定函数 操作结果：返回L中第一个与e满足compare()的数据元素的位序。 若这样的数据元素不存在，则返回值为0. PriorElem（L,cur_e,&pre_e） 初始条件：线性表已存在 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e 返回它的前驱，否则操作失败，pre_e无定义。 /************线性表的顺序存储结构定义和基本操作算法实现************/ #include "stdio.h" /***********************线性表的顺序存储结构定义*******************/ #define MAX 11 /*线性表可能达到的最大长度值*/ typedef int datatype; typedef struct {datatype data[MAX]; int last;}list; /************************1.线性表的初始化***************************/ void init(list *lp) {lp->last=0;} /************************2.求线性表的长度***************************/ int length(list *lp) { return (lp->last);} /***************3.插入运算,在表第i个位置插入一个值为x的新元素******/ void insert(list *lp,int i,datatype x) { int j; if(lp->last==MAX-1) printf("Overflow!\n"); /*表已满*/ else if(i<1||i>lp->last+1) printf("Error!\n"); /*插入位置错误*/ else {for(j=lp->last;j>=i;j--) lp->data[j+1]=lp->data[j]; /*数据元素后移*/ lp->data[i]=x; /*插入x */ lp->last++; /*表长度加1*/ } } /***************4.删除运算,在表中删除第i个数据元素***************/ void delete(list *lp,int i) { int j; if(i<1||i>lp->last) /*检查空表及删除位置的合法性*/ printf("The %dth element is not exist!",i); /*不存在第i个元素*/ else {for(j=i+1;j<=lp->last;j++) lp->data[j-1]=lp->data[j]; /*向前移动元素*/ lp->last--; /*表长度减1 */ } } /*****************5.查找运算,在表中查找x数据元素*****************/ int locate(list *lp,datatype x) { int i=lp->last; while(i>0 && lp->data[i]!=x)i--; return i; 第一章线性表 2.1 描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。 解：头指针是指向链表中第一个结点的指针。首元结点是指链表中存储第一个数据元素的结点。头结点是在首元结点之前附设的一个结点，该结点不存储数据元素，其指针域指向首元结点，其作用主要是为了方便对链表的操作。它可以对空表、非空表以及首元结点的操作进行统一处理。 2.2 填空题。 解：(1) 在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与元素在表中的位置有关。 (2) 顺序表中逻辑上相邻的元素的物理位置必定紧邻。单链表中逻辑上相邻的元素的物理位置不一定紧邻。 (3) 在单链表中，除了首元结点外，任一结点的存储位置由其前驱结点的链域的值指示。 (4) 在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。 2.3 在什么情况下用顺序表比链表好？ 解：当线性表的数据元素在物理位置上是连续存储的时候，用顺序表比用链表好，其特点是可以进行随机存取。 2.4 对以下单链表分别执行下列各程序段，并画出结果示意图。 解： 2.5 画出执行下列各行语句后各指针及链表的示意图。 L=(LinkList)malloc(sizeof(LNode)); P=L; for(i=1;i<=4;i++){ P->next=(LinkList)malloc(sizeof(LNode)); P=P->next; P->data=i*2-1; } P->next=NULL; for(i=4;i>=1;i--) Ins_LinkList(L,i+1,i*2); for(i=1;i<=3;i++) Del_LinkList(L,i); 解： 2.6 已知L是无表头结点的单链表，且P结点既不是 南昌航空大学实验报告 课程名称：数据结构实验名称：实验一线性表的链式存储结构班级：080611 学生姓名：冯武明学号：16 指导教师评定：XXX 签名: XXX 题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。 一、需求分析 ⒈先构造两个多项式链表，实现两个多项式的和及删除值为零元素的操作，不同用户输入 的多项式不同。 ⒉在演示过程序中，用户需敲击键盘输入值，即可观看结果。 ⒊程序执行的命令包括： （1）构造多项式链表A （2）构造多项式链表B （3）求两张链表的和（4）删除值为零元素，即不创建链表。 二、概要设计 ⒈为实现上述算法，需要线性表的抽象数据类型： ADT Stack { 数据对象：D={a i:|a i∈ElemSet,i=1…n,n≥0} 数据关系：R1={|a i-1,a i∈D,i=2,…n≥0} 基本操作: init(linklist *L) 操作结果： destroylist(List *L) clearlist(List *L) 初始条件：线性表L已经存在，1≤i≤ListLength(&L) 操作结果：用e返回L中第i个数据元素的值。 insfirst(link h,link s) 初始条件：数据元素e1,e2存在 操作结果：以e1,e2中的姓名项作为判定e1,e2是否相等的依据。 delfirst(link h,link *q) 初始条件：数据元素e1,e2存在 操作结果：以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有 ≤的关系。 交通大学《算法与数据结构》课程 实验报告 班级：计算机科学与技术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.熟悉线性表的基本运算在两种存储结构（顺序结构和链式结构）上的实现； 2.以线性表的各种操作的实现为重点； 3.通过本次学习帮助学生加深C语言的使用，掌握算法分析方法并对已经设计 出的算法进行分析，给出相应的结果。 二、实验要求： 编写实验程序，上机运行本程序，保存程序的运行结果，结合程序进行分析并写出实验报告。 三、实验容及分析： 1.顺序表的建立 建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。 程序如下： 头文件SqList.h的容如下： #include if(!L->elem) return(OVERFLOW); L->length=0; L->listsize=LIST_INIT_SIZE; return OK; } Status CreatList_Sq(SqList *L,int n) { int i; printf("输入%d个整数:\n",n); for(i=0;i 实验一：线性表逆置（顺序表）实验报告 （一）问题的描述： 实现顺序表的逆置算法 （二）数据结构的设计： 顺序表是线性表的顺序存储形式，因此设计如下数据类型表示线性表： typedef struct { ElemType *elem; /* 存储空间基址*/ int length; /* 当前长度*/ int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */ }SqList; （三）函数功能、参数说明及概要设计： 1.函数Status InitList(SqList *L) 功能说明：实现顺序表L的初始化 算法设计：为顺序表分配一块大小为LIST_INIT_SIZE的储存空间 2.函数int ListLength(SqList L) 功能说明：返回顺序表L长度 算法设计：返回顺序表中的length变量 3.函数Status ListInsert(SqList *L,int i,ElemType e) 功能说明：将元素e插入到顺序表L中的第i个节点 算法设计：判断顺序表是否已满，已满则加空间，未满则继续，将元素e插入到第i个元素之前，并将后面的元素依次往后移 4.函数Status ListTraverse(SqList L,void(*vi)(ElemType*)) 功能说明：依次对L的每个数据元素调用函数vi() 算法设计：依次对L的每个数据元素调用函数vi() 5.函数void Exchange(SqList *L) 功能说明：实现顺序表L的逆置 算法设计：用for循环将顺序表L中的第i个元素依次与第（i+length）个元素交换6.函数void print(ElemType *c) 功能说明：打印元素c 算法设计：打印元素c 2. （四）具体程序的实现 #include "" /***********************线性表的顺序存储结构定义*******************/ #define MAX 11 /*线性表可能达到的最大长度值*/ typedef int datatype; typedef struct {datatype data[MAX]; int last;}list; /************************1.线性表的初始化***************************/ void init(list *lp) {lp->last=0;} /************************2.求线性表的长度***************************/ int length(list *lp) { return (lp->last);} /***************3.插入运算,在表第i个位置插入一个值为 x的新元素******/ void insert(list *lp,int i,datatype x) { int j; if(lp->last==MAX-1) printf("Overflow!\n"); /*表已满*/ else if(i<1||i>lp->last+1) printf("Error!\n"); /*插入位置错误*/ else {for(j=lp->last;j>=i;j--) lp->data[j+1]=lp->data[j]; /*数据元素后移*/ lp->data[i]=x; /*插入x */ lp->last++; /*表长度加1*/ } } /***************4.删除运算,在表中删除第i个数据元素***************/ void delete(list *lp,int i) { int j; if(i<1||i>lp->last) /*检查空表及删除位置的合法性*/ printf("The %dth element is not exist!",i); /*不存在第i个元素*/ else {for(j=i+1;j<=lp->last;j++) lp->data[j-1]=lp->data[j]; /*向前移动元素*/ lp->last--; /*表长度减1 */ } } /*****************5.查找运算,在表中查找x数据元素*****************/ int locate(list *lp,datatype x) { int i=lp->last; while(i>0 && lp->data[i]!=x)i--; return i; } 数据结构顺序表的主要代码（LIZHULIN） 1．/***有头结点的单链表的初始化、建立（表头插入、表尾插入）、求长度、插入、删除、输出***/ /***********单链表的初始化、建立、输出*****************/ #include 实验一线性表及其应用 一、实验目的 1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。 2.掌握线性表的顺序存储结构的定义及C语言实现。 3.掌握线性表的链式存储结构——单链表的定义及C语言实现。 4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。 5.掌握线性表在链式存储结构——单链表中的各种基本操作。 二、实验内容 1.顺序线性表的建立、插入及删除。 2.链式线性表的建立、插入及删除。 三、实验步骤 1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。 2.利用前面的实验先建立一个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插入元素68。 3.建立一个带头结点的单链表，结点的值域为整型数据。要求将用户输入的数据按尾插入法来建立相应单链表。 四、实现提示 1.由于C语言的数组类型也有随机存取的特点，一维数组的机内表示就是顺序结构。因此，可用C语言的一维数组实现线性表的顺序存储。 在此，我们利用C语言的结构体类型定义顺序表： #define MAXSIZE 1024 typedef int elemtype; /* 线性表中存放整型元素*/ typedef struct { elemtype vec[MAXSIZE]; int len; /* 顺序表的长度*/ }sequenlist; 将此结构定义放在一个头文件sqlist.h里，可避免在后面的参考程序中代码重复书写，另外在该头文件里给出顺序表的建立及常量的定义。 2. 注意如何取到第i个元素，在插入过程中注意溢出情况以及数组的下标与位序（顺序表中元素的次序）的区别。 3.单链表的结点结构除数据域外，还含有一个指针域。用C语言描述结点结构如下： typedef int elemtype; typedef struct node 顺序存储结构的线性表 线性表是最常用且比较简单的一种结构，它是由有限个数据元素组成的有序集合，每个数据元素有一个数据项或者含多个数据项。例如26个英文字母表（A，B，……Z）是一个线性表，表中每一个数据元素由单个字母组成数据项。又如表5.0.1也是一个线性表，表中含八个数据元素，每一个数据元素由n个选手在该项目的竞赛成绩组成。 线性表具有如下结构特征： （1）均匀性。即同一线性表的名数据元素的数据类型一致且数据项相同。 （2）有序性。表中数据元素之间的相对位置是线性的，即存在性一的“第一个”和“最后一个”数据元素。除第一个 和最后一个外，其他元素前面均只有一个数据元素（直接前趋）和后面均只有一个数据元素（直接后继）。 按照表中数据元素的存储方式分顺序存储结构和链式存储结构两类线性表。 1、序存储结构 顺序存储结构是指用一组地址连续的存储单元依次线性表的元素，通常用数组实现。数组的物理实现是一块连续的存储空间，它是按首址（表中第1个元素的地址）+位移来访问每一个元素。 设 loc(a[i])-----A数组中元素i的内存地址(c<=i<=d); loc(b[i,j])----Bo数组中（i,j）元素的内存地址 (c1<=I<=d1,c2<=j<=d2); loc(a[i])=loc(a[c])+(i-c)*la，la-------atype类型的长度； loc(b[i,j]=loc(b[c1,c2])+((d2-c2+1)*(i-c1)+(j-c2))*lb，lb----atype 类型长度； 一维数组按照下标递增的顺序访问表中元素； a[c]->a[c+1]->……->a[d] 二维数按照先行后列的顺序访问表中元素： b[c1,c2]->b[c1,c+1]->……b[c1,d2]->……>b[i-1,d2]->b[i,c2]-> ……->b[d1,d2-1]->b[d1,d2] 在数组中，数据元素的下标间接反映了数据据元素的存储地址。而计算机内存是随机存储取的装置，所以在数组中存取一个数据元素只要通过下标计算它的存储地址就行了，数组中任意一个元素的存取时间都相等。从这个意义上讲，数组的存储存储结构是一个随机存取的结构。 问题是，虽然数组的顺序分配结构比较简单，便于随机访问数组中的任一元素。但如果数组要保持线性表的特征的话（由下标指明元素间的有序性），其增删操作的效率比较低。特别，当数组很大时，插入与删除运算颇为费时。因此，比较小的数组或元素不常变（很少进行插入与删除运算）的数组可用作线性表，而对于大的线性表或元素经常变动的线性表，可以采链式存储结构。 2、链式存储结构 #include 第2章线性表 1．选择题 （1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（）。 A．110 B．108 C．100 D．120 答案：B 解释：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。 （2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（）。 A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） B．在第i个结点后插入一个新结点（1≤i≤n） C．删除第i个结点（1≤i≤n） D．将n个结点从小到大排序 答案：A 解释：在顺序表中插入一个结点的时间复杂度都是O(n2)，排序的时间复杂度为O(n2)或O(nlog2n)。顺序表是一种随机存取结构，访问第i个结点和求第i个结点的直接前驱都可以直接通过数组的下标直接定位，时间复杂度是O(1)。 （3）向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动的元素个数为（）。 A．8 B．63.5 C．63 D．7 答案：B 解释：平均要移动的元素个数为：n/2。 （4）链接存储的存储结构所占存储空间（）。 A．分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针 B．只有一部分，存放结点值 C．只有一部分，存储表示结点间关系的指针 D．分两部分，一部分存放结点值，另一部分存放结点所占单元数 答案：A （5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（）。 A．必须是连续的B．部分地址必须是连续的 C．一定是不连续的D．连续或不连续都可以 答案：D （6）线性表Ｌ在（）情况下适用于使用链式结构实现。 A．需经常修改Ｌ中的结点值Ｂ．需不断对Ｌ进行删除插入 C．Ｌ中含有大量的结点Ｄ．Ｌ中结点结构复杂 答案：B 数据结构实验一 1、实验目的 ?掌握线性表的逻辑特征 ?掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算 2、实验内容： 建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空； 1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作： ?创建一个新的顺序表，实现动态空间分配的初始化； ?根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表； ?根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)； ?利用最少的空间实现顺序表元素的逆转； ?实现顺序表的各个元素的输出； ?彻底销毁顺序线性表，回收所分配的空间； ?对顺序线性表的所有元素删除，置为空表； ?返回其数据元素个数； ?按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回； ?按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回； ?判断顺序表中是否有元素存在，对判断结果进行返回； .编写主程序，实现对各不同的算法调用。 2．实现要求： ?“初始化算法”的操作结果：构造一个空的顺序线性表。对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间； ?“位置插入算法”的初始条件：顺序线性表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 已存在； /////////////////////////////////////////////////////////// //--------------------------------------------------------- // 顺序存储结构线性表基本操作纯C语言实现 // // a simple example of Sq_List by C language // // by wangweinoo1[PG] //--------------------------------------------------------- /////////////////////////////////////////////////////////// #include 线性表顺序存储结构上的基本运算
数据结构实验报告 实验一 线性表链式存储运算的算法实现
线性表练习题(答案)
3线性表及其顺序存储结构
线性表ADT的顺序存储与链式存储实验报告
线性表的顺序存储结构定义和基本操作算法实现
数据结构线性表答案
数据结构实验线性表的顺序存储结构
线性表的顺序储存结构
数据结构实验一顺序表的实现
线性表逆置(顺序表)实验报告
线性表的顺序存储结构定义和基本操作算法实现
数据结构线性表的主要程序代码
《数据结构》实验一 线性表及其应用
顺序存储结构的线性表
线性表顺序存储实现、插入、删除操作
数据结构 线性表 课后答案
数据结构实验一顺序表
顺序存储结构线性表基本操作 纯C语言实现