数据结构第二章线性表
第二章线性表
教学目的：掌握线性表的抽象数据类型的定义，掌握线性表的逻辑结构和存储结构，及线性表在不同的存储结构下的各种运算的实现技巧。
教学重点：线性表的概念、线性表的存储结构及运算的实现
线性结构是一个数据元素的有序（次序）。
线性结构的基本特征:
1．集合中必存在唯一的一个“第一元素”；
2．集合中必存在唯一的一个“最后元素”；
3．除最后元素在外，均有唯一的后继；
4．除第一元素之外，均有唯一的前驱。
第二章至第四章讨论的内容都是线性结构。
2.1线性表的概念
线性表简称为表，是零个或多个元素的有穷序列，通常可以表示成k
，
k 1, …，k
n-1
（n≥1）。
表中所含元素的个数称为表的长度。长度为零的表称为空表。表中的元素又
称表目。
当长度n≥1时，k
0称为第一个元素，k
n-1
称为最后一个元素，称k
i
（0≤i≤
n-2）是k
i+1的前驱， k
i+1
是k
i
的后继。
i称为表目k
i
的索引或下标。
常把数据元素称为记录。含大量记录的线性表又称为文件。
关系：< k0，k1>,
线性表的类型的形式说明：
List list;
DataType x;
Index p;
线性表有以下几种基本运算：
List createNullList(void)
int insert(List list,Index p,DataType x)
int delete(List list,Index p)
index Locate(List list,DataType x)
int isNull(List list)
C中，常用整型值0,1表示假、真，更一般地，可以定义布尔类型：typedef enum{false=0,true=1} Boolean;
2.2线性表的顺序表示
在计算机内，线性表有两种基本的存储结构：
顺序存储结构：
线性表最简单的存储方法是采用顺序方式：称作线性表的顺序表示，通常可称此时的线性表为顺序表。以元素在计算机内存中的“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。
其存储结构如图2.2所示。
图2.2 线性表的顺序存储结构示意图
此时有：Loc(k
i )=Loc(k
)+i×c
顺序表的存储结构定义：
形式１：
＃define MAXNUM 100
DataType element[MAXNUM];
Int n;
形式2：
struct SeqList{ DataType element[MAXNUM];
int n;
}
比较这两种定义顺序表的方法，后者概念较为清晰，符合数据抽象的原则，今后我们的定义一般采用后者。
在实际应用中，为了使用方便，通常定义一个struct SeqList类型的指针类型：typedef struct SeqList *PSeqList;
pSeqList palist; /*指针变量*/
f函数的首部为：
void f(PSeqList pl)
在主函数中调用函数f采用以下语句：
pl=&L1;
f(pl);
顺序表示中基本运算的实现
算法2.1创建空顺序表
PSeqList createNullList_seq( void )
{ PSeqList palist;
palist = (PSeqList)malloc(sizeof(struct SeqList));
if (palist!=NULL)
palist ->n = 0; /* 空表长度为0 */ else
printf("Out of space!!\n"); /* 存储分配失败 */ return (palist);
}
算法2.2顺序表的插入
int insert_seq( PSeqList palist, int p, DataType x )
/* 在palist所指顺序表中下标为p的元素之前插入元素x */
{ int q;
if ( palist->n == MAXNUM ) /* 溢出 */
{ printf("Overflow!\n"); return ( FALSE ); }
if ( p<0 || p>palist->n ) /* 不存在下标为p的元素 */
{ printf("Not exist! \n"); return ( FALSE ); }
for(q=palist->n - 1; q>=p; q--) /* 插入位置及之后的元素均后移一个位置 */
palist->element[q+1] = palist->element[q];
palist->element[p] = x; /* 插入元素x */
palist->n = palist->n + 1; /* 元素个数加1 */
return ( TRUE );
}
算法2.3 顺序表的删除
int delete_seq( PSeqList palist, int p )
/* 在palist所指顺序表中删除下标为ｐ的元素 */
{ int q;
if ( p<0 || p>palist->n – 1 ) /* 不存在下标为p的元素*/
{ printf("Not exist!\n ");
return (FALSE); }
for(q=p; q
一个位置 */
palist->element[q] = palist->element[q+1];
palist->n = palist->n - 1; /* 元素个数减1 */
return ( TRUE );
}
算法分析:
? 在有n 个元素的线性表里，在下标为i （第i+1个）的元素之前插入一个元素需要移动n - i 个元素；删除下标为i （第i+1个）的元素需要移动n - i - 1个元素。如果在下标为i 的位置上插入和删除元素的概率分别是Pi 和Pi ’，则插入时的平均移动数是：
∑=-=n i i
i p i n m 0)(
设在n+1个插入位置都是等概率的，则有，
11
+=n p i 22)1(11)(11)(00n n n n i n n p i n m n i n i i i =+?+=-+=-=∑∑== ? 删除的平均移动数是(n p i /1'=)：
21)1(10'-=--=∑-=n p i n m n i i i
? 所以顺序表的插入和删除操作的时间代价为O(n)。
? 类似地，在顺序表中进行定位(locate_seq)操作，则要依次与表中元素进行比较，当定位的概率平均分布在所有元素上时，一次定位平均需要和n/2个元素进行比较，其时间代价为O (n)。
算法2.4 在顺序表中求某元素的下标
int locate_seq( PSeqList palist, DataType x )
/* 求x 在palist 所指顺序表中的下标 */
{ int q;
for ( q=0; q
return (q);
return (-1);
}
算法2.5 求palist 所指顺序表中下标为ｐ的元素值
DataType retrieve_seq( PSeqList palist, int p )
/* 求palist 所指顺序表中下标为p 的元素值 */
{
if ( p>=0 && p
return ( palist->element[p] );
printf("Not exist.\n ");
return(SPECIAL); /* 返回一个顺序表中没有的特殊值 */ }
算法2.6判断线性表是否为空
int isNullList_seq( PSeqList palist )
{
return ( palist->n == 0 );
}
由上述操作可知：
顺序存储的优点:不需要附加空间,随机存取任一个元素;
缺点: 很难估计所需空间的大小,且开始就要分配足够大的一片连续的内存空间.
2.3线性表的链接表示
链式存储结构
单链表：
每个元素除了需要存储自身的信息外，还要存储一个指示其后继的信息（即后继元素存储位置），这两部分信息组成了一个数据元素的存储结构，称为一个
结点（注意：每个结点所占用的存储单元应该是连续的）。
每个结点包括两个域：
数据域（info）—存放数据元素本身的信息；
指针域（link）—存放其后继结点的存储位置。
假设一线性表有n个元素，则这n个元素所对应的n个结点就通过指针链接成一个链表，
由于这种链表中每个结点只有一个指针域，故又称为单链表。
头指针指示单链表中第一个结点的存储位置。如图2.5所示
图2.5 链表示例
struct LinkList /* 单链表类型定义 */
{
PNode head; /* 指向单链表中的第一个结点 */
};
/* 单链表类型的指针类型 */
typedef struct LinkList *PLinkList;
PLinkList pllist;
/* pllist是指向单链表的一个指针变量 */
循环链表：将单链表的形式稍作改变，让最后一个结点的指针指向头一个结点，这样就得到了循环链表。
使用循环链表的主要优点是：从循环链表中任一结点出发，都能访问遍所有结点。
图2.11 循环链表
双链表：
双链表中每个结点除了数据域以外有两个指针域：一个指向其前驱结点，一个指向其后继结点。每个结点的实际结构可以形象地描述如下：
struct DoubleNode; /* 双链表结点 */
typedef struct DoubleNode *PDoubleNode;/* 结点指针类型 */
struct DoubleNode /* 双链表结点结构 */
{ DataType info;
PDoubleNode llink, rlink;};
为了灵活地处理，可对双链表进行封装，引入双链表结构：
struct DoubleList /* 双链表类型 */
{ PDoubleNode head; /* 指向第一个结点 */
PDoubleNode rear; }; /* 指向最后一个结点 */
双链表带来的最大好处是可以很容易地找到前驱和后继。
运算的实现：
单链表上的算法的实现：
算法2.7创建空链表
LinkList createNullList_link( void )
/* 创建一个带头结点的空链表 */
{ LinkList llist;
llist = (LinkList)malloc( sizeof( struct Node ) );
/* 申请表头结点空间 */
if( llist != NULL )
llist->link = NULL;
return (llist);
}
算法2.8单链表的插入
int insert_link(LinkList llist, int i, DataType x)
/* 在llist带头结点的单链表中下标为i的(第i+1个)结点前插入元素x */ { PNode p,q; int j; p = llist; j = 0;
while (p!=NULL && j { p=p->link; j++; } if (j!=i) /* i<1或者大于表长 */ { printf("The value of i=%d is not reasonble.\n",i); return(0); } q = (PNode)malloc( sizeof( struct Node ) ); /* 申请新结点 */ if( q == NULL ) { printf( "Out of space!!!\n" ); return(0); } else { /* 插入链表中 */ q->info = x; q->link = p->link; p->link = q; /* 注意该句必须在上句后执行 */ return(1); } } 算法2.9 单链表的删除 void delete_link( LinkList llist, DataType x ) /* 在llist带有头结点的单链表中删除第一个值为x的结点 */ { PNode p, q; p = llist; /*找值为x的结点的前驱结点的存储位置 */ while( p->link != NULL && p->link->info != x ) p = p->link; if( p->link == NULL ) /* 没找到值为x的结点 */ { printf(”Not exist!\n ”); return(0); } else { q = p->link; /* 找到值为x的结点 */ p->link = p->link->link; /* 删除该结点 */ free( q ); return(1); } } 算法2.10在单链表中求某元素的存储位置 PNode locate_link(LinkList llist, DataType x ) /* 在llist带有头结点的单链表中找第一个值为x的结点存储位置 */ { PNode p; if (llist==NULL) return(NULL); p = llist->link; while( p != NULL && p->info != x ) p = p->link; return (p); } 算法2.11求单链表中下标为i的(第i+1个)元素的存储位置 PNode find_link( LinkList llist, int i ) /* 在带有头结点的单链表llist中求下标为i的(第i+1个)结点的存储位置;当表中无下标为i的(第i+1个)元素时，返回值为NULL */ { PNode p; int j; if (i<0) /* 检查i的值 */ { printf("The value of i=%d is not reasonable.\n",i); return (NULL); } p=llist; for ( j=0;j<=i;j++ ) { p = p->link; if ( p == NULL ) return (NULL); } return (p); } 算法2.12判断单链表是否为空 int isNullList_link( LinkList llist) /* 判断llist带有头结点的单链表是否是空链表 */ { if (llist==NULL) return(1); else return (llist->link == NULL); } 线性表的周游： 根据线性表的存储表示不同,其周游算法也不同: 顺序表示的周游 线性表的顺序表示的遍历 void visit_seq(Pseqlist palist) { int i=0; for(i=0;i visit(palist->element[i]); } 线性表的单链表表示的遍历周游 void visit_link(LinkList llist) { Pnode p=llist; for(p=llist;p!=NULL;p=p->link) visit(p); 单链表与顺序表的比较： ?单链表的存储密度比顺序表低，它多占用了存储空间。 存储密度＝单链表数据项所占的空间/结点所占的空间 ?在单链表里进行插入、删除运算比在顺序表里容易得多。 ?对于顺序表，可随机访问任一个元素，而在单链表中，需要顺着链逐个进行 查找，因此单链表适合于成批地、顺序地处理线性表中的元素时采用。 ?静态数据结构顺序表，在程序的运行期间数组的大小不再变化 ?动态数据结构链表，在程序的运行期间大小可自由变化 2.4应用举例――Josephus问题 问题提出 设有n个人围坐在一个圆桌周围，现从第s个人开始报数，数到第m的人出列，然后从出列的下一个人重新开始报数，数到第m的人又出列，…，如此反复 直到所有的人全部出列为止。Josephus问题是：对于任意给定的n,s和m，求出按出列次序得到的n个人员的序列。 问题解答思路 数据结构 Josephus问题讨论的是一个圆链，所以自然想到使用线性表作为存储这个圆链的数据结构。根据线性表种类的不同，就可以有2种不同的方法来表示圆链：顺序表表示，循环单链表表示。 算法 在建立好线性表后，重复的对表中的元素实行检索和删除操作，将删除的元素依次输出就得到了Josephus问题的答案。 解答框架 1.对n,s,m进行赋值 2.插入元素构造Josephus表（对线性表初始化） 3.报数出列过程 源程序 顺序表 子程序 顺序表程序中对n,s,m进行赋值 void inputnsm(int* n,int* s,int* m) { printf("\n please input the values(<100) of n = "); scanf("%d",n); printf("\n please input the values of s = "); scanf("%d",s); printf("\n please input the values of m = "); scanf("%d",m); } 插入元素构造Josephus表（对线性表初始化） 顺序表的初始化 void initlist(PSeqList jos_alist,int n) { int i,k; if (jos_alist==NULL) exit(1); for( i = 0; i < n; i++ ) { k=insert_seq( jos_alist, i, i+1); if (k==FALSE) exit(1); } } 顺序表的报数出列过程 void josephus_seq( PSeqList palist, int s, int m) { int s1, i, w; s1 = s - 1; /* 找出列的元素 */ for(i = palist->n; i>0; i--) { s1 = ( s1 + m - 1 ) % i ; w = retrieve_seq(palist,s1); /* 求下标为s1的元素的值 */ printf("Out element %d \n",w); /* 元素出列 */ delete_seq(palist,s1); /* 删除出列的元素 */ } } 顺序表的主程序 #define MAXNUM 100 #define FALSE 0 #define TRUE 1 typedef int DataType; main( ) { PSeqList jos_alist; int n,s,m; inputnsm(&n,&s,&m); jos_alist=createNullList_seq( ); /* 创建空顺序表 */ initlist(jos_alist,n); josephus_seq(jos_alist,s,m); free(jos_alist); return 0; } 顺序存储结构Josephus 算法时间复杂性： )(2n O 循环单链表的子程序 对n,s,m 进行赋值 插入元素构造Josephus 表（对线性表初始化） 报数出列过程 循环单链表的报数出列过程 void josephus_clink( PLinkList pclist, int s,int m ) { PNode p,pre; int i; p=*pclist; /* 找第s个元素 */ if (s==1) { pre =p; p=p->link; while (p!=*pclist) {pre =p; p=p->link;} } else for(i=1;i { pre =p; p=p->link; } while (p!=p->link) /* 当链表中结点个数大于1时 */ { for (i=1;i { pre = p; p = p->link;} printf(" out element: %d \n",p->info); /* 输出该结点 */ if (*pclist ==p) /* 该结点是第一个结点时，删除时需特殊处理一下 */ *pclist =p->link; pre->link = p->link; /* 删除该结点 */ free(p); p = pre->link; } printf(" out element: %d \n",p->info); /* 输出最后一个结点*/ *pclist=NULL; free(p); 简单示范程序： #include "stdio.h" #include "conio.h" #define N 10 #define s 1 #define m 4 typedef struct Student{ int No; char Name[15]; }StudentData; typedef struct LNode{ StudentData StuData; struct LNode *link; }LNode,*PList; PList clist; StudentData StuData[N]={ {1,"Chen Nan"}, {2,"Chen Xiaobo"}, {3,"Chen Ying"}, {4,"Cheng Liang"}, {5,"Chent Wenping"}, {6,"Dai Guoxiong"}, {7,"Gao Huan"}, {8,"Gong Fanghua"}, {9,"Gou Jianting"}, {10,"Guan Qiang"}}; PList CreatLinkList() { int i; PList p, q, cl=NULL; for(i=0;i { p=(PList)malloc(sizeof(LNode)); p->StuData.No=StuData[i].No; strcpy(p->https://www.360docs.net/doc/9112967984.html,, StuData[i].Name); if(cl==NULL) { cl=p; q=p;} else { q->link=p; q=p; } } q->link=cl; return cl; } void Josephus(int sta, int ms, PList clst) { PList p,q; int i; p=clst; for(i=1;i p=p->link; while(p->link!=p) { for(i=1;i q=p->link; p->link=q->link; printf("%2d, %s\n",q->StuData.No,q->https://www.360docs.net/doc/9112967984.html,); free(q); } printf("%2d, %s\n",p->StuData.No,p->https://www.360docs.net/doc/9112967984.html,); free(p); } main() { clrscr(); clist=CreatLinkList(); Josephus(s,m,clist); } 小结： 本章主要讨论了线性表的概念、存储表示以及基本运算的实现。线性表是一种比较简单的数据结构，它是n个数据元素的有限序列。线性表常用的存储方式有两种：顺序存储和链式存储。 在线性表的顺序存储结构中，元素之间的逻辑关系是通过存储位置直接反映的，顺序存储结构中只需存放数据元素自身的信息，因此，存储密度大、空间利用率高；另外，元素的存储位置可以用元素的下标通过简单的解析式计算出来，因此可以随机存取。这些都是顺序存储结构的优点。但是，在顺序表中，元素的插入和删除运算可能需要移动许多其它元素的位置，一些长度变化较大的线性表必须按最大需要的空间分配存储，这些都是线性表顺序存储结构的缺点。 数据结构实验报告全集 实验一线性表基本操作和简单程序 1．实验目的 （1）掌握使用Visual C++ 6.0上机调试程序的基本方法； （2）掌握线性表的基本操作：初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。 2．实验要求 （1）认真阅读和掌握和本实验相关的教材内容。 （2）认真阅读和掌握本章相关内容的程序。 （3）上机运行程序。 （4）保存和打印出程序的运行结果，并结合程序进行分析。 （5）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果 实验代码： 1）头文件模块 #include iostream.h>//头文件 #include nodetype *create()//建立单链表，由用户输入各结点data域之值，//以0表示输入结束 { elemtype d;//定义数据元素d nodetype *h=NULL,*s,*t;//定义结点指针 int i=1; cout<<"建立一个单链表"< 实验一线性表的基本操作 一、实验目的与基本要求 1．掌握数据结构中的一些基本概念。数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。 2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。 3．掌握顺序表和链表的基本操作：插入、删除、查找以及表的合并等运算。4．掌握运用C语言上机调试线性表的基本方法。 二、实验条件 1．硬件：一台微机 2．软件：操作系统和C语言系统 三、实验方法 确定存储结构后，上机调试实现线性表的基本运算。 四、实验内容 1．建立顺序表，基本操作包括：初始化，建立一个顺序存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。 2．建立单链表，基本操作包括：初始化，建立一个链式存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。 3．假设有两个按数据元素值非递减有序排列的线性表A和B，均以顺序表作为存储结构。编写算法将A表和B表归并成一个按元素值非递增有序（允许值相同）排列的线性表C。（可以利用将B中元素插入A中，或新建C表）4．假设有两个按数据元素值非递减有序排列的线性表A和B，均以单链表作为存储结构。编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许值相同）排列的线性表C。 五、附源程序及算法程序流程图 1.源程序 （1）源程序(实验要求1和3) #include 北京邮电大学电信工程学院 数据结构实验报告 实验名称：实验1——线性表 学生姓名： 班级： 班内序号： 学号： 日期： 1．实验要求 1、实验目的：熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法 学习指针、模板类、异常处理的使用 掌握线性表的操作的实现方法 学习使用线性表解决实际问题的能力 2、实验内容： 题目1： 线性表的基本功能： 1、构造：使用头插法、尾插法两种方法 2、插入：要求建立的链表按照关键字从小到大有序 3、删除 4、查找 5、获取链表长度 6、销毁 7、其他：可自行定义 编写测试main()函数测试线性表的正确性。 2. 程序分析 2.1 存储结构 带头结点的单链表 2.2 关键算法分析 1.头插法 a、伪代码实现：在堆中建立新结点 将x写入到新结点的数据域 修改新结点的指针域 修改头结点的指针域,将新结点加入链表中b、代码实现： Linklist::Linklist(int a[],int n)//头插法 {front=new Node; front->next=NULL; for(int i=n-1;i>=0;i--) {Node*s=new Node; s->data=a[i]; s->next=front->next; front->next=s; } } 2、尾插法 a、伪代码实现：a.在堆中建立新结点 b.将a[i]写入到新结点的数据域 c.将新结点加入到链表中 d.修改修改尾指针 b、代码实现: Linklist::Linklist(int a[],int n,int m)//尾插法 {front=new Node; Node*r=front; for(int i=0;i 实验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; 序号 数据结构实验报告 班级姓名同组者/ 成绩 日期 3.9指导教师 实验名称实验一线性表及其应用 一、实验目的 1、深刻理解线性表的逻辑特性及其顺序、链式存储方式的特点。 2、熟练掌握线性表的常用操作（建立、插入、删除、遍历等）在顺序、链式存储上的实现。 3、加深对C/C++等编程语言的相关知识点的理解（如结构体、指针、函数、引用参数等）。 二、实验内容 1、根据给定的整型数组，以尾插法建立一个单链表，并实现以下操作： ①查找：输入一个欲查找的整数，找到则显示第一个相匹配的整数在单链表中所处的位置，若不存在，则显示提示信息。 ②删除：输入一个欲删除的整数e ，若存在则在单链表中删除第一个值为 e 的元素。 ③插入：输入一个欲插入位置i 和欲插入元素e，将e 插入到第i 个整数之前（注意i 的合法性）。 A、算法思想 ①创建 head 为头结点指针，初始时head->next 为NULL ；tail 始终指向当前链表的最后一个元素，其初始时指向头结点；p 始终指向每次申请的新结点，修改p->data 为当前读入的整数；修改tail->next 为p ，修改tail 为p ；最后修改tail->next 为NULL ，。 ②插入 找到插入点的前驱（即第i-1 个结点）的指针p ；s 指向新申请的结点；修改s->data 为参数e，修改s->next 为p->next ，修改p->next 为s 。 ③查找 ……利用p进行遍历，直到节点的数据和所给的数据相同，输出节点的位置 ④删除 ……利用p进行遍历，并总是将p的前一节点的指针赋给pre，一旦找到，则删除节点并 退出循环，没有到话，反馈相关信息 B、算法源码 /* *线性表及其应用 */ #include 《数据结构》实验报告 专业： 学号： 姓名： 实验二线性表 【实验目的】 1.熟悉VC环境，学习如何使用C语言实现线性表的两种存储结构。 2.通过编程、上机调试，进一步理解线性表的基本概念，东运用C语言实现线性表基本操作。 3.熟练掌握线性表的综合应用问题。 【实验内容】 1、一个线性表有n个元素（n-MAXSIZE.MAXSIZE指线性表的最大长度），且递增有。现有一元素x要插入到线性表的适当位置上，并保持线性表原有的顺序不变。设计程序实现。要求：采用顺序存储表示实现；采用链式存储表示方法实现：比较两种方法的优劣。 2.从单链表中删除指定的元素x，若x在单链表中不存在，给出提示信息。 要求： ①指定的值x由键盘输入； ②程序能处理空链表的情况。 3.设有头结点的单链表，编程对表中的任意值只保留一个结点，删除其余值相同的结点。 要求： ①该算法用函数（非主函数)实现； ②在主函数中调用创建链表的函数创建一个单链表，并调用该函数，验证算法的正确性。LinkedList Exchange（LinkedList HEAD,p) //HEAD是单链表头结点的指针，p是链表中的一个结点。本算法将p所指结点与其后 继结点交换。 （q=head->next；//q是工作指针，指向链表中当前待处理结点。 pre=head；//pre是前驱结点指针，指向q的前驱。 while（q'=null &&q1=p)(pre=q；q=q->next；]/未到p结点，后移指针。 if（p->next==null)printf(“p无后继结点\n”）；/p是链表中最后一个结点，无后继。 else/处理p和后继结点交换 （q=p->next；//暂存p的后继。 pre->next=q://p前驱结点的后继指向p的后继。 p->next=q->next；//p的后继指向原p后继的后继。 q->next=p：//原p后继的后继指针指向p。} }//算法结束。 4.已知非空单链表第一个结点由head指出，请写一算法，交换p所指结点与其下一个结点在链表中的位置。 要求： 哈尔滨工业大学计算机科学与技术学院 实验报告 课程名称：数据结构与算法 课程类型：必修 实验项目名称：线性表实验 实验题目：算术表达式求值 班级：0903201 学号：1090320110 姓名：王岳 一、实验目的 二、实验要求及实验环境 三、设计思想（本程序中的用到的所有数据类型的定义，主程序的流程图及各程序模块之间的调用关系） 1．逻辑设计 2．物理设计 四、测试结果 五、系统不足与经验体会 六、附录：源代码（带注释） #include else { this -> top--; return this -> ss[this -> top + 1]; } } void push(elementtype x) { if (this -> top == 511) printf("error:full!!!\n"); else { this -> top++; this -> ss[this -> top] = x; } } }; void change(int &i,int &j,double *a,char *input,stack 实验一线性表及其应用 一、实验目的 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 班级：：学号： 实验一线性表的基本操作 一、实验目的 1、掌握线性表的定义； 2、掌握线性表的基本操作，如建立、查找、插入和删除等。 二、实验容 定义一个包含学生信息（学号，，成绩）的顺序表和链表（二选一），使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，，成绩）； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记录； (7) 统计表中学生个数。 三、实验环境 Visual C++ 四、程序分析与实验结果 #include typedef int Status; // 定义函数返回值类型 typedef struct { char num[10]; // 学号 char name[20]; // double grade; // 成绩 }student; typedef student ElemType; typedef struct LNode { ElemType data; // 数据域 struct LNode *next; //指针域 }LNode,*LinkList; Status InitList(LinkList &L) // 构造空链表L { L=(struct LNode*)malloc(sizeof(struct LNode)); L->next=NULL; return OK; 实验报告 课程名称____数据结构上机实验__________ 实验项目______线性表的应用____________实验仪器________PC机___________________ 系别_____电子信息与通信学院___ 专业________ ___ 班级/学号______ __ 学生姓名______ ___________ 实验日期_______________________ 成绩_______________________ 指导教师_______________________ 实验一.线性表的应用 1.实验目的：掌握线性链表的存储、运算及应用。利用链 表实现一元多项式计算。 2.实验内容： 1)编写函数，实现用链表结构建立多项式； 2)编写函数，实现多项式的加法运算； 3)编写函数，实现多项式的显示； 4)测试：编写主函数，它定义并建立两个多项式，显示 两个多项式，然后将它们相加并显示结果。变换测试用的多项式，检查程序的执行结果。 选做内容：修改程序，选择实现以下功能： 5)多项式求值：编写一个函数，根据给定的x值计算并 返回多项式f(x)的值。测试该函数（从终端输入一个x的值，调用该函数并显示返回结果）。 6)多项式相减：编写一个函数，求两个多项式相减的多 项式。 7)多项式相乘：编写一个函数，求两个多项式的乘积多 项式。 3.算法说明： 1)多项式的建立、显示和相加算法见讲义。可修改显示 函数，使输出的多项式更符合表达规范。 2)多项式减法：同次项的系数相减（缺项的系数是0）。 例如a(x)=-5x2+2x+3，b(x)= -4x3+3x，则a(x)-b(x) =4x3-5x2-x+3。提示：a(x)-b(x) = a(x)+(-b(x))。 3)多项式乘法：两个多项式的相乘是“系数相乘，指数 相加”。算法思想是用一个多项式中的各项分别与另 一个多项式相乘，形成多个多项式，再将它们累加在 一起。例如，a(x)=-5x2+2x+3，b(x)=-4x3+3x，则 a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3) = (20x5-8x4-12x3) + (-15x3+6x2+9x) = 20x5-8x4-27x3+6x2+9x。 4.实验步骤： 根据实验报告的要求，我对文件夹里的C文件进行了丰 富和修改，步骤如下： 链表结构建立多项式： typedef struct polynode { float coef; //系数 int exp; //指数 struct polynode *next; //下一结点指针 } PNode; 编写函数，实现多项式的加法运算； PNode * PolyAdd (PNode *f1, PNode *f2) //实现加法功能。 数据结构实验报告 实验名称：实验1——线性表 学生姓名： 班级： 班内序号： 学号： 日期： 1．实验要求 1、实验目的：熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法 学习指针、模板类、异常处理的使用 掌握线性表的操作的实现方法 学习使用线性表解决实际问题的能力 2、实验内容： 题目1： 线性表的基本功能： 1、构造：使用头插法、尾插法两种方法 2、插入：要求建立的链表按照关键字从小到大有序 3、删除 4、查找 5、获取链表长度 6、销毁 7、其他：可自行定义 编写测试main()函数测试线性表的正确性。 2. 程序分析 存储结构 带头结点的单链表 关键算法分析 1.头插法 a、伪代码实现：在堆中建立新结点 将x写入到新结点的数据域 修改新结点的指针域 修改头结点的指针域,将新结点加入链表中 b、代码实现： Linklist::Linklist(int a[],int n) 堆中建立新结点 b.将a[i]写入到新结点的数据域 c.将新结点加入到链表中 d.修改修改尾指针 b、代码实现: Linklist::Linklist(int a[],int n,int m)取链表长度函数 a、伪代码实现：判断该链表是否为空链表，如果是，输出长度0 如果不是空链表，新建立一个temp指针，初始化整形数n为0 将temp指针指向头结点 判断temp指针指向的结点的next域是否为空，如果不是，n加一，否 则return n 使temp指针逐个后移，重复d操作，直到temp指针指向的结点的next 域为0，返回n b 、代码实现 void Linklist::Getlength()Linklist(); cout< 班级: 姓名: 学号: 实验一线性表的基本操作 一、实验目的 1、掌握线性表的定义; 2、掌握线性表的基本操作,如建立、查找、插入与删除等。 二、实验内容 定义一个包含学生信息(学号,姓名,成绩)的顺序表与链表(二选一),使其具有如下功能: (1) 根据指定学生个数,逐个输入学生信息; (2) 逐个显示学生表中所有学生的相关信息; (3) 根据姓名进行查找,返回此学生的学号与成绩; (4) 根据指定的位置可返回相应的学生信息(学号,姓名,成绩); (5) 给定一个学生信息,插入到表中指定的位置; (6) 删除指定位置的学生记录; (7) 统计表中学生个数。 三、实验环境 Visual C++ 四、程序分析与实验结果 #include { char num[10]; // 学号 char name[20]; // 姓名 double grade; // 成绩 }student; typedef student ElemType; typedef struct LNode { ElemType data; // 数据域 struct LNode *next; //指针域 }LNode,*LinkList; Status InitList(LinkList &L) // 构造空链表L { L=(struct LNode*)malloc(sizeof(struct LNode)); L->next=NULL; return OK; } Status GetElem(LinkList L,int i,ElemType &e) // 访问链表,找到i位置的数据域,返回给 e { LinkList p; p=L->next; 实验报告 实验一线性表 实验目的： 1.理解线性表的逻辑结构特性； 2.熟练掌握线性表的顺序存储结构的描述方法，以及在该存储结构下的基本操作；并能灵活运用； 3.熟练掌握线性表的链表存储结构的描述方法，以及在该存储结构下的基本操作；并能灵活运用； 4.掌握双向链表和循环链表的的描述方法，以及在该存储结构下的基本操作。 实验原理： 线性表顺序存储结构下的基本算法； 线性表链式存储结构下的基本算法； 实验内容： 2－21设计单循环链表，要求： （1）单循环链表抽象数据类型包括初始化操作、求数据元素个数操作、插入操作、删除操作、取消数据元素操作和判非空操作。 （2）设计一个测试主函数，实际运行验证所设计单循环链表的正确性。 2－22 .设计一个有序顺序表，要求： （1）有序顺序表的操作集合有如下操作：初始化、求数据元素个数、插入、删除和取数据元素。有序顺序表与顺序表的主要区别是：有序顺序表中的数据元素按数据元素值非递减有序。 （2）设计一个测试主函数，实际运行验证所设计有序顺序表的正确性。 （3）设计合并函数ListMerge（L1,L2,L3）,功能是把有序顺序表L1和L2中的数据元素合并到L3，要求L3中的数据元素依然保持有序。并设计一个主函数，验证该合并函数的正确性。 程序代码： 2－21（1）头文件LinList.h如下： typedef struct node { DataType data; struct node *next; }SLNode; /*（1）初始化ListInitiate(SLNode * * head)*/ void ListInitiate(SLNode * * head) { /*如果有内存空间，申请头结点空间并使头指针head指向头结点*/ if((*head=(SLNode *)malloc(sizeof(SLNode)))==NULL)exit(1); 学 《数据结构》课程 实验报告 实验名称：线性表基本操作的实现实验室(中心)： 学生信息： 专业班级： 指导教师： 实验完成时间： 2016 实验一线性表基本操作的实现 一、实验目的 1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。 2.掌握线性表的顺序存储结构的定义及C语言实现。 3.掌握线性表的链式存储结构——单链表的定义及C语言实现。 4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。 5.掌握线性表在链式存储结构——单链表中的各种基本操作。 二、实验内容及要求 1.顺序线性表的建立、插入、删除及合并。 2.链式线性表的建立、插入、删除及连接。 三、实验设备及软件 计算机、Microsoft Visual C++ 6.0软件 四、设计方案（算法设计） ㈠采用的数据结构 本程序顺序表的数据逻辑结构为线性结构，存储结构为顺序存储；链表的数据逻辑结构依然为线性结构，存储结构为链式结构。 ㈡设计的主要思路 1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度，顺序表的长度和元素由用户输入； 2.利用前面建立的顺序表，对顺序表进行插入、删除及合并操作； 3.建立一个带头结点的单链表，结点的值域为整型数据，链表的元素由用户输入； 4.对前面建立的链表进行插入、删除及连个链表的连接操作； ㈢算法描述 1、顺序表 void Init(sqlist &);//初始化顺序表 BOOL Inse(sqlist &,int,char); //在线性表中插入元素 BOOL del(sqlist&,int,char &); //在线性表中删除元素 int Loc(sqlist,char); //在线性表中定位元素 void print(sqlist); //输出顺序表 void combine( sqlist & , sqlist & , sqlist &);//两个线性表的合并 2、链表 void CreaL(LinkList &,int); //生成一个单链表 BOOL LInsert(LinkList &,int,char); //在单链表中插入一个元素 BOOL LDele(LinkList &,int,char &); //在单链表中删除一个元素 BOOL LFind_key(LinkList,char,int &); //按关键字查找一个元素 BOOL LFind_order(LinkList,char &,int); //按序号查找一个元素 void LPrint(LinkList); //显示单链表所有元素 void LUnion(LinkList &,LinkList &,LinkList &,int); //两个链表的连接 五、程序代码 1、顺序表 #include 南京工程学院实验报告 操作的函数程序清单，分别用顺序表和链表结构完成，并在首页上表明团队名称、成员及个人的工作（函数），未来的成绩评定时将包含这一部分的团队成绩及个人的工作成绩。 一、实验目的 1.熟悉上机环境，进一步掌握语言的结构特点。 2.掌握线性表的顺序存储结构的定义及实现。 3.掌握线性表的链式存储结构——单链表的定义及实现。 4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。 5.掌握线性表在链式存储结构——单链表中的各种基本操作。 二、实验内容 1.顺序线性表的建立、插入及删除。 2.链式线性表的建立、插入及删除。 三、实验步骤 1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。 2.利用前面的实验先建立一个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插入元素68。 3.建立一个带头结点的单链表，结点的值域为整型数据。要求将用户输入的数据按尾插入法来建立相应单链表。 四、程序主要语句及作用（main函数程序清单） 程序1的主要代码(附简要注释) #include "stdio.h" #include "malloc.h" #define SUCCESS 1 #define FAILURE 0 #define null 0 #define maxsize 100 typedef int datatype; typedef struct /*定义线性表（顺序结构）数据类型*/ { datatype data[maxsize]; int last; }sequenlist; int n; /*定义功能选择菜单函数*/ void print() { printf("----线性表（顺序结构）的基本操作----\n"); printf("----------开始----------\n"); } /*打印线性表（顺序结构）*/ 计算机系数据结构实验报告（1） 实验目的： 帮助学生掌握线性表的基本操作在顺序和链表这两种存储结构上的实现，尤以链表的操作和应用作为重点。 问题描述： 1、构造一个空的线性表L。 2、在线性表L的第i个元素之前插入新的元素e； 3、在线性表L中删除第i个元素，并用e返回其值。 实验要求： 1、分别利用顺序和链表存储结构实现线性表的存储，并设计出在不同的存储结构中线 性表的基本操作算法。 2、在实验过程中，对相同的操作在不同的存储结构下的时间复杂度和空间复杂度进行 分析。 算法分析： 由于两种存储结构都用来创建线性结构的数据表，可采用相同的输出模式和整体结构类似的算法，如下： 实验内容和过程： 顺序存储结构线性表程序清单： //顺序存储结构线性表的插入删除 #include int len; //当前元素个数 int listsize; //当前存储最大容量 }SqList; //构造一个空的线性表L int InitList(SqList &L) { =(ElemType *)malloc(LISTSIZE*sizeof(ElemType)); if (! exit(-2); //分配空间失败 =0; =LISTSIZE; } //在顺序线性表L中第i个位置之前插入新的元素e int ListInsert(SqList &L,int i,ElemType e) { if (i<1||i>+1) return -1; //i值不合法 if >= { ElemType *newelem=(ElemType *)realloc,+CREMENTSIZE)*sizeof(ElemType)); //存储空间已满，增加分配 if(!newelem) exit (-2); //分配失败 =newelem; +=CREMENTSIZE; } ElemType *q=&[i-1]) ; for (ElemType *p=&[]);p>=q;--p) *(p+1)=*p; //插入位置及其后的元素后移 *q=e; ++; return 1; } //在顺序线性表L中删除第i个元素，并用e返回其值 int ListDelete(SqList &L,int i,ElemType&e) { if (i<1||i> return -1; //i值不合法 数据结构实验一 线性表的实现 一、实验目的： 1.熟悉线性表的基本运算在两种存储结构（顺序结构和链式结构）上的实现； 2.以线性表的各种操作的实现为重点； 3.通过本次学习帮助学生加深C语言的使用，掌握算法分析方法并对已经设计 出的算法进行分析，给出相应的结果。 二、实验要求： 编写实验程序，上机运行本程序，保存程序的运行结果，结合程序进行分析并写出实验报告。 三、实验内容及分析： 1.顺序表的建立 建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。 程序如下： 头文件SqList.h的内容如下： #include 实验一线性表的操作算法 一、实验目的： 1了解线性表的逻辑结构和存储结构，以及定义在逻辑结构上的各种基本运算2分别以数组和链表为存储结构，实现线性表的插入，删除，查找，排序，合并等操作 二、实验内容： 用C/C++语言编写程序，分别以数组和链表为存储结构，完成以下功能： 1输入数据，创建一个线性表 2可在线性表的任意位置插入新结点 3可删除线性表的任意一个结点 4可在线性表中查找结点 5将线性表从小至大排序 6将两个线性表合并 三、详细设计： 顺序表 #include }SqList; SqList Lx; Status InitList_Sq(SqList &L) //分配空间 { L.elem=new ElemType[LIST_INIT_SIZE]; if(!L.elem)exit(OVERFLOW); L.length =0; L.listsize=LIST_INIT_SIZE; return OK; } Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase; if(i<1 || i>L.length+1) return ERROR; if(L.length>=L.listsize) { newbase=new ElemType[L.listsize+LISTINCREMENT]; if(!newbase) exit(OVERFLOW); L.elem=newbase; L.listsize+=LISTINCREMENT; } q=&(L.elem[i-1]); for (p=&(L.elem[L.length-1]);p>=q;--p) *(p+1)=*p; *q=e; ++L.length; return OK; } Status Listlength(SqList L) //长度 { int *p=L.elem; //判断线形表是否存在while(p) { return (L.length); } } Status GetElem(SqList L, int i,ElemType &e) //取元素 { if(i<1 || i>L.length) return ERROR; else { e=L.elem[i-1]; return e; } } void MergeList(SqList La,SqList Lb,SqList &Lc) //合并 { ElemType ai,bj; InitList_Sq(Lc); int i=1,j=1,k=0; int La_len,Lb_len; La_len=Listlength(La);数据结构实验报告全集
C语言数据结构线性表的基本操作实验报告
数据结构实验一题目一线性表实验报告
数据结构_实验1_线性表的基本操作
数据结构线性表实验报告
数据结构线性表实验报告
哈工大 数据结构 实验一 线性表的实验
《数据结构》实验一 线性表及其应用
数据结构实验一 实验报告
数据结构线性表的应用实验报告
数据结构实验一题目一线性表实验报告
数据结构实验一 实验报告
数据结构线性表实验报告
数据结构实验线性表基本操作
《数据结构》实验1实验报告
数据结构实验线性表及其应用
数据结构实验一 线性表的实现
中南大学数据结构实验报告1(线性表)