实现单链表的各种基本运算

合集下载

数据结构能力测试集训题目

数据结构能力测试集训题目

数据结构能力测试集训题目线性表1.实现顺序表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化顺序表L;(2)采用尾插法依次插入a,b,c,d,e;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出顺序表L;(10)删除顺序表L的第3个元素;(11)输出顺序表L;(12)释放顺序表L。

2.实现单链表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化单链表h;(2)采用尾插法依次插入a,b,c,d,e;(3)输出单链表h;(4)输出单链表h的长度;(5)判断单链表h是否为空;(6)输出单链表h的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出单链表h;(10)删除单链表h的第3个元素;(11)输出单链表h;(12)释放单链表h;3.实现双链表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化双链表h;(2)采用尾插法依次插入a,b,c,d,e;(3)输出双链表h;(4)输出双链表h的长度;(5)判断双链表h是否为空;(6)输出双链表h的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出双链表h;(10)删除双链表h的第3个元素;(11)输出双链表h;(12)释放双链表h;4.实现循环单链表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化循环单链表h;(2)采用尾插法依次插入a,b,c,d,e;(3)输出循环单链表h;(4)输出循环单链表h的长度;(5)判断循环单链表h是否为空;(6)输出循环单链表h的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出循环单链表h;(10)删除循环单链表h的第3个元素;(11)输出循环单链表h;(12)释放循环单链表h;5.实现循环单链表各种基本运算的算法,并基础上设计一个主程序完成如下功能:(1)初始化循环双链表h;(2)采用尾插法依次插入a,b,c,d,e;(3)输出循环双链表h;(4)输出循环双链表h的长度;(5)判断循环双链表h是否为空;(6)输出循环双链表h的第3个元素;(7)输出元素a的位置;(8)在第四个元素位置上插入f元素;(9)输出循环双链表h;(10)删除循环双链表h的第3个元素;(11)输出循环双链表h;(12)释放循环双链表h;6.求集合的并,交,差运算(用有序单链表表示)栈和队列7.实现顺序栈各种基本运算的算法,编写一个程序实现顺序栈的各种基本运算,并在此基础上设计一个主程序完成以下各种功能:(1)初始化栈s(2)判断栈s是否非空(3)依次进栈元素a,b,c,d,e(4)判断栈s是否非空(5)输出栈长度(6)输出从栈顶到栈底元素(7)输出出栈序列(8)判断栈s是否非空(9)释放栈8.实现链栈各种基本运算的算法,编写一个程序,实现链栈的各种基本算法,并在此基础上设计一个主程序完成如下功能:(1)初始化链栈s(2)判断链栈s是否非空(3)依次进栈元素a,b,c,d,e(4)判断链栈s是否非空(5)输出链栈长度(6)输出从栈顶到栈底元素(7)输出链栈序列(8)判断链栈s是否非空(9)释放链栈9.实现顺序队列各种基本运算的算法,编写一个程序,实现顺序循环队列各种基本运算,并在此基础上设计一个主程序完成如下功能:(1)初始化队列q(2)判断队列q是否非空(3)依次进队列元素a,b,c(4)出队一个元素,输出该元素(5)输出队列q的元素的个数(6)依次进队列元素d,e,f(7)输出队列q的元素的个数(8)输出出队序列(9)释放队列10.实现链队各种基本运算的算法,编写一个程序,实现链队的各种基本运算,在此基础上设计一个主程序完成如下功能:(1)初始化链队q(2)判断链队q是否非空(3)依次进链队元素a,b,c(4)出队一个元素,输出该元素(5)输出链队q的元素的个数(6)依次进链队元素d,e,f(7)输出链队q的元素的个数(8)输出出队序列(9)释放链队串11.实现顺序串各种基本运算的算法,编写一个程序实现顺序的基本运算的算法,比在此基础上设计一个主程序完成如下功能:(1)建立s=”abcdefghefghijklmn”和串s1=”xyz”(2)输出串s(3)输出串s的长度(4)在串s的第9个字符位置插入串s1而产生串s2(5)输出串s2(6)删除串s第2个字符开始的5个字符而产生的串s2(7)输出串s2(8)将串s第2个字符开始的5个字符替换成串s1而产生串s2(9)输出串s2(10)提取串s的第2个字符开始的10个字符而产生串s3(11)输出串s3(12)将串s1和串s2连接起来而产生的串s4(13)输出串s412.实现链串个各种基本运算的算法,编写一个程序实现链串的各种基本运算,并在此基础上设计一个主程序完成如下功能;(1)建立s=”abcdefghefghijklmn”和串s1=”xyz”(2)输出串s(3)输出串s的长度(4)在串s的第9个字符位置插入串s1而产生串s2(5)输出串s2(6)删除串s第2个字符开始的5个字符而产生的串s2(7)输出串s2(8)将串s第2个字符开始的5个字符替换成串s1而产生串s2(9)输出串s2(10)提取串s的第2个字符开始的10个字符而产生串s3(11)输出串s3(12)将串s1和串s2连接起来而产生的串s4(13)输出串s413.顺序串的各种模式匹配运算,编写一个程序实现顺序串的各种模式匹配运算,并在此基础上完成如下功能:(1)建立”abcabcdabcdeabcdefabcdefg”目标串s和”abcdeabcdefab”模式串t(2)采用简单匹配算法求t在s中的位置(3)由模式串t求出next值和nextval值(4)采用KMP算法求t在s中的位置(5)采用改进的KMP算法求t在s中的位置查找14.实现顺序查找的算法,编写一个程序输出在顺序表{3,6,2,10,1,8,5,7,4,9}中采用顺序方法查找关键字5的过程。

基于单链表实现集合的交集、并集、差集的运算

基于单链表实现集合的交集、并集、差集的运算

基于单链表实现集合的交集、并集、差集的运算解题思路(单链表求交集、并集、差集的思想和顺序表求交集、并集、差集的思想基本相同)1.先通过CreateListR 函数将集合 a 和 b 中的元素添加到顺序表 ha 和 hb 中,添加过程使⽤的是顺序表原有的Initlist 函数(初始化表)和ListInsert 函数(向表中插⼊元素)。

2.因为原集合是⽆序的,所以我通过 sort 函数(选择排序),使得集合变得有序。

3.得到有序集合 ha 和 hb 后,便可以使⽤ Union 函数(类似归并的思想写出来的求并集的函数),求出 ha 和 hb 的并集。

4.⽽求交集的⽅法则是,通过将集合 a 中的元素⼀个⼀个取出,并通过函数LocateElem ,查看集合 hb 中是否存在该元素,如果存在则将元素放⼊ hc ,如果不存在,则舍去。

以此求得两集合的交集。

5.求两集合的差则可以反过来,同样通过将集合 a 中的元素⼀个⼀个取出,并通过函数LocateElem ,查看集合 hb 中是否存在该元素,如果不存在则将元素放⼊ hc ,如果存在,则舍去。

以此求得两集合的差集。

#include <iostream>#include <cstdio>#include <malloc.h>using namespace std;/* 定义单链表数据 */typedef char ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LinkList;/* 单链表的初始化 */void InitList(LinkList *&L){L = (LinkList *)malloc(sizeof(LinkList));L->next=NULL;}/* 向单链表中插⼊数据元素 */bool ListInsert(LinkList *&L,int x,char e){int j = 0;LinkList *p = L, *s;while(p!=NULL && j<x-1){p = p->next;j++;}if(p==NULL){return false;}else{s = (LinkList *)malloc(sizeof(LinkList));s->data = e;s->next = p->next;p->next = s;return true;}}/* 输出单链表 */void DispList(LinkList *L){LinkList *p = L->next;while(p!=NULL){printf("%c ",p->data);p = p->next;}printf("\n");}/* 求单链表的长度 */int ListLength(LinkList *L){LinkList *p = L->next;int i = 0;while(p!=NULL){p = p->next;}return i;}/* 查看单链表是否为空 */bool ListEmpty(LinkList *L){return L->next==NULL;}/* 求单链表中某个数据元素值 */bool GetElem(LinkList *L,int i, ElemType &e) {LinkList *p = L;int j = 0;while(p!=NULL && j < i){p=p->next;j++;}if(p==NULL){return false;}else{e = p->data;return true;}}/* 在单链表中查找元素 */int LocateElem(LinkList *L,ElemType e){LinkList *p = L;int i = 0;while(p!=NULL && p->data!=e){p = p->next;i++;}if(p==NULL){return0;}else{return i;}}/* 删除单链表中第 i 个元素*/bool ListDelete(LinkList *&L,int i,ElemType &e) {int j = 0;LinkList *p = L, *q;while(p!=NULL && j < i - 1){p = p->next;j++;}if(p==NULL)return false;else{q = p->next;if(q==NULL)return false;e = q->data;p->next = q->next;free(q);return true;}}/* 删除单链表 */void DestroyList(LinkList *&L){LinkList *p = L;LinkList *q = p->next;while(q!=NULL){p = q;q = p->next;}free(p);}void CreateListR(LinkList *&L,ElemType e[],int n) {InitList(L);int i;for(i = 0;i < n; ++i){if(!LocateElem(L,e[i]))ListInsert(L,i+1,e[i]);}}void InsterSect(LinkList *a,LinkList *b,LinkList *&c) {DestroyList(c);InitList(c);LinkList *p = a->next;int i = 0;while(p!=NULL){if(LocateElem(b,p->data))ListInsert(c,++i,p->data);p = p->next;}}void Subs(LinkList *a,LinkList *b,LinkList *&c){DestroyList(c);InitList(c);LinkList *p = a->next;int i = 0;while(p!=NULL){if(!LocateElem(b,p->data))ListInsert(c,++i,p->data);p = p->next;}}void Union(LinkList *a,LinkList *b,LinkList *&c){InitList(c);LinkList *p = a->next;LinkList *q = b->next;int k = 0;while(p!=NULL && q!=NULL){if(p->data < q->data){ListInsert(c,k+1,p->data);p = p->next;k++;}else if(p->data == q->data){ListInsert(c,k+1,p->data);p = p->next;q = q->next;k++;}else{ListInsert(c,k+1,q->data);q = q->next;k++;}}while(p!=NULL){ListInsert(c,k+1,p->data);p = p->next;k++;}while(q!=NULL){ListInsert(c,k+1,q->data);q = q->next;}///cout<<"hehe"<<endl;}void sort(LinkList *&L){LinkList *p , *pre, *q, *k;InitList(p);int i = 0;char c;while(!ListEmpty(L)){pre = L ->next;c = pre->data;while(pre!=NULL){if(c>=pre->data)c = pre->data;pre = pre->next;}ListInsert(p,++i,c);int tag = LocateElem(L,c);ListDelete(L,tag,c);}L = p;}int main( ){LinkList *ha, *hb, *hc;ElemType a[]={'c','a','e','h'};ElemType b[]={'f','h','b','g','d','a'};printf("集合的运算如下\n");CreateListR(ha,a,4);CreateListR(hb,b,6);printf("原集合 A: "); DispList(ha); printf("原集合 B: "); DispList(hb); sort(ha);sort(hb);printf("有序集合A:"); DispList(ha); printf("有序集合B:"); DispList(hb); Union(ha,hb,hc);printf("集合的并C:"); DispList(hc); InsterSect(ha,hb,hc);printf("集合的交C:"); DispList(hc); Subs(ha,hb,hc);printf("集合的差C:"); DispList(hc); DestroyList(ha);DestroyList(hb);DestroyList(hc);return0;}。

链表及其应用

链表及其应用
a1
头指针是指向链表中第一个结点(或为头结点或为首
元素结点)的指针。 单链表可由一个头指针唯一确定。
头结点是在链表的首元素结点之前附设的一个结点;
数据域内只放空表标志和表长等信息;
首元素结点是指链表中存储线性表第一个数据元素
a1的结点。
33
第3章 链表及其应用
讨论1. 在链表中设置头结点有什么好处?
我们可以用结构体来定义静态链表的节点数据类型: typedef struct{ Datatype data; int next; }node;
一个静态链表可以描述为: #define maxsize 100 node nodepool[maxsize];//存放链表的数组 int head; //放头指针的head 在静态链表中进行插入与删除操作不需要移动元素,
4
第3章 链表及其应用
3.1 链表的基本概念
3.1.1 什么是链表 ☞ 3.1.2 链表的逻辑结构
3.1.3 链表的存储结构 3.1.4 静态链表和动态链表 3.1.5 链表的基本运算
5
第3章 链表及其应用
♣ 链表的逻辑结构
☞ 同一链表中所有数据元素的数据类型必须相同。 ☞ 链表中相邻的元素ai-1、ai间存在序偶关系,即 对于非空的链表,ai-1是ai的唯一直接前驱,ai+1是 ai的唯一直接后继;而a1无前驱,an无后继 ☞ 链表属于线性逻辑结构。
结点3的地址:p->next;
28
第3章 链表及其应用
H
a1
p
p
a2
a3
a4
a5 ∧
再令p = p->next, 数据元素a3值:p ->data
结点4的地址:p->next;

实现单链表的各种基本运算

实现单链表的各种基本运算

实现单链表的各种基本运算一、实验目的了解单链表表的结构特点及有关概念,掌握单链表的各种基本操作算法思想及其实现。

二、实验内容编写一个程序,实现顺序表的各种基本运算:1、初始化单链表;2、单链表的插入;3、单链表的输出;4、求单链表的长度5、判断单链表是否为空;6、输出单链表的第i位置的元素;7、在单链表中查找一个给定元素在表中的位置;8、单链表的删除; 9、释放单链表三、算法思想与算法描述简图四、实验步骤与算法实现#include<stdio.h>#include<malloc.h>typedef char ElemType;typedef struct LNode//定义单链表{ ElemType data;struct LNode *next;}LinkList;void InitList(LinkList*&L){ L=(LinkList*)malloc(sizeof(LinkList));//创建头结点L->next=NULL;//头结点赋值为空}void DestroyList(LinkList*&L)//销毁单链表(释放单链表L占用的内存空间即逐一释放全部结点的空间){ LinkList*p=L,*q=p->next;while(q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList*L)//判线性表是否为空表ListEmpty(L){ return(L->next==NULL);}//若单链表L没有数据结点,则返回真,否则返回假。

int ListLength(LinkList*L)//求线性表的长度ListLength(L){ LinkList*p=L;int i=0;while(p->next!=NULL){i++;p=p->next;}return(i);//返回单链表L中数据结点的个数}void DispList(LinkList*L)//输出线性表DispList(L){LinkList*p=L->next;while (p!=NULL)//逐一扫描单链表L的每个数据结点,并显示各结点的data域值。

数据结构实验报告实现单链表各种基本运算的算法

数据结构实验报告实现单链表各种基本运算的算法

实验截图(1)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。

算法与数据结构实验报告

算法与数据结构实验报告

2015-2016学年第二学期《算法与数据结构》课程实验报告专业软件工程学生姓名成晓伟班级软件141学号1410075094实验学时16实验教师徐秀芳信息工程学院实验一单链表的基本操作一、实验目的1.熟悉C语言上机环境,进一步掌握C语言的基本结构及特点。

2.掌握线性表的各种物理存储表示和C语言实现。

3.掌握单链表的各种主要操作的C语言实现。

4.通过实验理解线性表中的单链表存储表示与实现。

二、主要仪器及耗材普通计算机三、实验内容与要求1、用C语言编写一个单链表基本操作测试程序。

(1)初始化单链表(2)创建单链表(3)求单链表长度(4)输出单链表中每一个结点元素(5)指定位置插入某个元素(6)查找第i个结点元素的值(7)查找值为e 的结点,并返回该结点指针(8)删除第i个结点(9)销毁单链表2、实验要求(1)程序中用户可以选择上述基本操作。

程序启动后,在屏幕上可以菜单形式显示不同功能,当按下不同数字后完成指定的功能,按其他键,则显示错误后重新选择。

(2)要求用线性表的顺序存储结构,带头结点的单链表存储结构分别实现。

(3)主函数实现对基本操作功能的调用。

3、主要代码(1)初始化单链表LinkList *InitList(){ //创建一个空链表,初始化线性表LinkList *L;L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;return L;}(2)创建单链表//头插法void CreateListF(LinkList *L){LinkList *s;int i=1,a=0;while(1){printf("输入第%d个元素(0表示终止)",i++);scanf("%d",&a);if(a==0)break;s=(LinkList *)malloc(sizeof(LinkList));s->data=a;s->next=L->next;L->next=s;}}(3)求链表长度int ListLength(LinkList *L){ //求链表长度int n=0;LinkList *p=L;while(p->next!=NULL){p=p->next;n++;}return(n);}(4)在指定位置插入元素int InsertList(LinkList *L,int i,ElemType e){LinkList *p=L,*s;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找出要插入的位置的前一个位置if(p==NULL){return 0;}else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;p->next=s;return 1;}}(5)输出链表void DispList(LinkList *L){ //输出链表LinkList *p=L->next;while(p!=NULL){printf("%d",p->data);p=p->next;}printf("\n");}(6)查找链表中指定元素int GetElem(LinkList *L,int i){ //查找链表中指定元素LinkList *p=L;int j=0;while(j<i&&p!=NULL){j++;p=p->next;}if(p==NULL){return 0;}else{return p->data;}}(7)查找值是e的结点并返回该指针LinkList *LocateElem(LinkList *L,ElemType e){ //查找值是e的结点并返回该指针int i=1;LinkList *p=L;while(p!=NULL)if(p->data==e) return p;}if(p==NULL){return NULL;}}(8)删除元素int ListDelete(LinkList *L,int i,ElemType *e){ //删除元素LinkList *p=L,*q;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找到要删除元素地址的前一个地址if(p==NULL){ return 0;} //不能删除else{q=p->next;*e=q->data;p->next=q->next;free(q); //删除成功return 1;}}(9)销毁链表void DestroyList(LinkList *L){//销毁链表LinkList *pre=L,*p=L->next;while(p!=NULL){free(pre);pre=p;p=pre->next;}free(pre);}main函数:int main(){LinkList *L;ElemType e;int i;L=InitList();CreateListF(L);DispList(L);printf("输入要查找的元素位置:\n");scanf("%d",&i);e=GetElem(L,i);printf("%d\n",e);printf("单链表长度为:%d\n",ListLength(L));printf("输入要删除元素的位置:");scanf("%d",&i);if (i>ListLength(L)){printf("超出范围重新输入");scanf("%d",&i);}if(ListDelete(L,i,&e)==0){printf("未找到元素\n");}else DispList(L);printf("输入插入元素的位置和值:");scanf("%d%d",&i,&e);InsertList(L,i,e);DispList(L);return 0;}4、测试数据及测试结果输入:23 56 12 28 45输出:四、注意事项1、存储结构定义和基本操作尽可能用头文件实现。

数据结构-单链表实验报告

数据结构-单链表实验报告

单链表实验报告一、实验目的1、帮助读者复习C++语言程序设计中的知识。

2、熟悉线性表的逻辑结构。

3、熟悉线性表的基本运算在两种存储结构上的实现,其中以熟悉链表的操作为侧重点。

二、实验内容[问题描述]实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。

[基本要求](1)依次从键盘读入数据,建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。

三、算法设计(1)建立带表头结点的单链表;首先输入结束标志,然后建立循环逐个输入数据,直到输入结束标志。

(2)输出单链表中所有结点的数据域值;首先获得表头结点地址,然后建立循环逐个输出数据,直到地址为空。

(3)输入x,y在第一个数据域值为x的结点之后插入结点y,若无结点x,则在表尾插入结点y;建立两个结构体指针,一个指向当前结点,另一个指向当前结点的上一结点,建立循环扫描链表。

当当前结点指针域不为空且数据域等于x的时候,申请结点并给此结点数据域赋值为y,然后插入当前结点后面,退出函数;当当前结点指针域为空的时候,申请结点并给此结点数据域赋值为y,插入当前结点后面,退出函数。

(4)输入k,删除单链表中所有的结点k,并输出被删除结点的个数。

建立三个结构体指针,一个指向当前结点,另一个指向当前结点的上一结点,最后一个备用;建立整形变量l=0;建立循环扫描链表。

当当前结点指针域为空的时候,如果当前结点数据域等于k,删除此结点,l++,跳出循环,结束操作;如果当前结点数据域不等于k,跳出循环,结束操作。

当当前结点指针域不为空的时候,如果当前结点数据域等于k,删除此结点,l++,继续循环操作;如果当前结点数据域不等于k,指针向后继续扫描。

循环结束后函数返回变量l的值,l便是删除的结点的个数。

四、实验结果1、新建一个链表:2、输出链表的数据:(4)插入数据:在数据为3后面插入一个数据100:(5)删除数据:删除刚刚插入的数据100:五、总结实验之前由于准备不够充分,所以堂上实验时只完成了建立单链表和数据的输出,而后面两个实验要求也是用来很多时间长完成的。

做表格时如何做到计算公式的循环运用-

做表格时如何做到计算公式的循环运用-

竭诚为您提供优质文档/双击可除做表格时如何做到计算公式的循环运用?篇一:实现循环单链表表各种基本运算的算法篇二:excel循环引用产生的原因及解决方法excel循环引用产生的原因及解决方法我们打开excel文件时,如果遇到有“microsoftofficeexcel不能计算公式。

公式中的单元格引用指向的是公式的结果,从而造成循环引用。

”的提示,这时这个文件中,就包含了循环引用了。

循环引用:如果公式引用自己所在的单元格,不论是直接的还是间接的,都称为循环引用。

循环引用有一个特别的应用例子。

而且只要打开的工作簿中有一个包含循环引用,excel都将无法自动计算所有打开的工作簿。

这时只能取消循环引用,或利用先前的迭代计算结果计算循环引用中的每个单元格引用。

下面的图就是直接与间接造成循环引用的实例:上面的图中,e3的单元格的公式为=sum("e:e"),这样的公式直接引用了公式所在的单元格,而造成循环引用,而a4的公式为=c1,c1的公式为=c6,最后c6的公式为=a4,这样(做表格时如何做到计算公式的循环运用)的情况就造成了间接的循环引用了。

知道了循环引用的成因之后,解决的方法一就是去除与更正错误的公式,像e3的公式经常是因为选择数据区域时有误造成的,修改成正确的区域就可以了。

那怎么快速定位错误的公式所在的单元格呢?在写公式的时候,当设定的公式造成循环引用时,就会出现如左边部份的蓝色箭头,这样我们就比较容易找出出错的位置。

但如果是保存后再打开时,excel不会生成类似的标志,除非你选择了公式所在的单元格,在利用循环引用工具栏里的命令生成。

不过好在我们可以在状态栏(右下角)里看到出错出现公式的位图,如图会显示——循环:e3,这样我们就可以跟据这个提示,一个个修改过来,至到没有提示为至!到此,循环引用的原因与解决方法就说完了,遇到类似问题的你,就不会再困惑了吧!篇三:在woRd中表示循环小数中循环节的方法在woRd中表示循环小数中循环节的方法:方法:。

单链表实验报告总结

单链表实验报告总结

单链表实验报告总结‎单链表实验报告总结‎‎篇一:‎单链表实验报告‎实验一线性表基本操‎作的编程实现 --线‎性表在链表存储下的主‎要操作实现班级:T‎523-1 姓名:王‎娟学号:33 完成‎日期:201X.0‎ 4.04 地点‎:5502 学时:2‎学时一‎、需求分析【实验目‎的】通过本次实验,‎对课堂上线性表的知识‎进行巩固,进一步熟悉‎线性表的链接存储及‎相应的基本操作;并熟‎练掌握VC++‎6.0操作平台,学‎会调试程序,以及编写‎电子实验报告【实验‎要求】编写线性表的‎基本操作,有构造线性‎表,线性表的遍历,插‎入,删除,查找,求‎表长等基本功能,在此‎基础上能够加入DS下‎的图形界面以及学会文‎件的操作等功能,为以‎后的学习打下基础。

‎【实验任务】‎(1).线性表基本操‎作的编程实现,掌握线‎性表的建立、遍历、插‎入、删除等基本操作的‎编程实现,也可以进一‎步编程实现查找、逆序‎、排序等操作,存储结‎构可以在顺序结构或链‎表结构中任选,可以完‎成部分主要功能,也可‎以用菜单进行管理完成‎大部分功能。

还鼓励学‎生利用基本操作进行一‎些更实际的应用型程序‎设计。

(2)‎.用菜单管理,把线性‎表的顺序存储和链表存‎储的数据插入、删除运‎算进行程序实现。

建‎议实现键盘数据输入实‎现改实验的通用性。

为‎了体现功能的正常性,‎至少要编制遍历数据的‎函数.(3)‎.注意事项:开发语言‎使用C++,尽量使用‎面向对象的思想和实现‎方法,可以改编成应用‎软件. 【实验类型】‎验证型实验‎二、概要设计需要实‎现线性表的以下功能:‎1、创建单链‎表2、删除链‎表中的某个结点‎3、输出单链表(遍‎历)4、释放‎结点所占空间‎5、查找第i个结点‎6、插入一个结‎点7、求链表‎的长度二、详‎细设计(1)‎.数据结构线性表的‎线性结构觉决定了它的‎性质:数据元‎素之间是一种线性关系‎,数据元素一个接一‎个的排列,除了最后一‎个数据,其他的数据面‎临的下一个数据有且仅‎有一个。

实验二 链表操作实现

实验二 链表操作实现

实验二链表操作实现实验日期:2017 年 3 月16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现;2. 以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3. 掌握线性表的链式存储结构的定义和基本操作的实现;4. 通过本实验加深对C语言的使用(特别是函数的参数调用、指针类型的应用)。

实验内容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。

(1)链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;(2)带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp,其代码如下所示,理解LinkList类型和基本运算函数后回答下列问题。

#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题:(1)由单链表结点类型定义可知,该链表结点类型名为 LinkNode ,结点的指针类型为 LinkList ,向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new 中的语句是: p=(LinkList)malloc(sizeof(LinkNode)); 。

数据结构实验题目

数据结构实验题目

实验题目一一、单链表基本运算【问题描述】设计并实现线性表的单链表存储和运算。

【基本要求】实现单链表的插入、删除和遍历运算,每种操作用一个函数实现。

插入操作:将一个新元素插入表中指定序号的位置。

删除操作:将指定序号的元素从表中删除。

遍历操作:从表头按次序输入所有元素的值,若是空表,则输出信息“empty list!”。

【实现提示】程序运行时,首先在main函数中创建空的、带头结点的单链表。

然后多次调用实现插入操作的函数(每次都将元素在序号1位置上插入),将元素依次插入表中,最后调用实现遍历操作的函数输出所有元素。

之后再多次调用实现删除操作的函数将表还原为空表(每次都删除第1个元素,每删除一个元素后,将表中剩余元素都输出一次)。

【测试数据】输入数据:1 2 3 4 5 0(为0时结束,0不存入链表)第一次输出:5 4 3 2 1第二次输出:4 3 2 1第三次输出:3 2 1第四次输出:2 1第五次输出:1第六次输出:empty list!二、约瑟夫环问题【问题描述】编号为1,2,...,n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。

现在给定一个随机数m>0,从编号为1的人开始,按顺时针方向1开始顺序报数,报到m时停止。

报m的人出圈,同时留下他的密码作为新的m值,从他在顺时针方向上的下一个人开始,重新从1开始报数,如此下去,直至所有的人全部出列为止。

【基本要求】利用单向循环链表存储结构模拟此过程,按照出列的顺序印出各人的编号。

【测试数据】M的初始值为20;n等于7,7个人的密码依次为:3,1,7,2,4,8,4。

输出为:6,1,4,7,2,3,5【实现提示】程序运行时,首先要求用户指定初始报数上限值,然后读取各人的密码。

可设n≤30。

此题所用的循环链表中不需要“头结点”,请注意空表和非空表的界限。

【选作内容】用顺序存储结构实现该题目。

三、一元多项式相加、减运算器【问题描述】设计一个一元稀疏多项式简单计算器。

《数据结构》实验3链表

《数据结构》实验3链表
二、源代码以及输入数据输出结果为:
三、源代码以及实验结果为
四、源代码以及实验结果为
五、源代码以及实验结果为
六、源代码以及实验结果为
七、附加题以及实验体会:
{
NODE *s; /*定义指向结点类型的指针*/
s=(NODE *)malloc(sizeof(NODE));
/*生成新结点*/
3
4
5
return 1;
}
/*删除P所指向的结点的后继结点*/
void DelLinkList(NODE *p)
{ NODE *q;
if(p->next!=0)
{ q=p->next; /* q指向p的后继结点*/
ch=getchar();
while(ch!='$')
{ p=(NODE *)malloc(sizeof(NODE));
p->data=ch;
1
2
ch=getchar();
}
return (head);
}
/*在链表的P指定结点之后插入值为x的结点*/
int InsLinkList(NODE *p, char x)
四、设有两个单链表A、B,其中元素递增有序,编写算法将A、B归并成一个按元素值递减(允许有相同值)有序的链表C,要求用A、B中的原结点形成,不能重新申请结点。
五、已知单链表表示的线性表中含有两类的数据元素(字母字符,数字字符)。试设计算法,按结点的值将单链表拆分成两个循环链表,分别只含有数字或字母。要求:利用原表中的结点空间作为这两个表的结点空间,头结点可另开辟空间。
附加题:如果换成循环单链表该如何实现?
即题目变成:已知单循环链表表示的线性表中含有两类的数据元素(字母字符,数字字符)。试设计算法,按结点的值将单链表拆分成两个循环链表,分别只含有数字或字母。

单链表的基本运算

单链表的基本运算
{ Node *s; char c; int flag=1; while(flag) /* flag 初值为 1,当输入“$”时,置 flag 为 0,
建表结束*/ { c=getchar(); if(c!=’$’) { s=(Node*)malloc(sizeof(Node)); /*建立新结点 s*/ s->data=c; s->next=L->next; /*将 s 结点插入表头*/ L->next=s; } else flag=0;
3. 结果判断 如找到第 i 个结点,则返回结点 p;
如表查完未找到,则返回空。
【算法描述】
Node * Get (LinkList L, int i) / * 在带头结点的单链表 L 中查找第 i 个结点,若找到(1≤i≤n),则返回 该结点的存储位置; 否则返回 NULL * / { int j;
【算法描述】
int ListLength(LinkList L)
/*求带头结点的单链表 L 的长度*/
{ Node *p;
p=L->next;
j=0; /*用来存放单链表的长度*/
while(p!=NULL)
{
p=p->next;
j ++;
}
return j; /*j 为求得的单链表长度*/
} /* ListLength */
H

s r
(a)初始化的空表
C1 ∧
(b)申请新结点并赋值
s 指向新申请的结点空间;
s->data:=C1
H
c1 ∧
r
(c)插入第一个结点
s
① r->next=s;
c1 H

实验二:单链表基本运算实现

实验二:单链表基本运算实现
typedef struct node
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");

一元多项式的单链表表示及其运算

一元多项式的单链表表示及其运算

一元多项式的单链表表示及其运算
一元多项式的单链表表示是将多项式的每一项以节点的形式存储在链表中,链表的每个节点包含两个数据域,一个表示系数,一个表示指数。

链表中的节点按照指数从大到小的顺序排列,这样可以方便进行多项式的运算。

例如,多项式2x^3 + 3x^2 + 4x + 5可以表示为如下的单链表:
5 -> 4 -> 3 -> 2 -> NULL
其中,每个节点的第一个数据域表示系数,第二个数据域表示指数。

针对这个单链表表示的多项式,可以进行多项式的加法、减法、乘法等运算。

多项式的加法运算可以通过遍历两个链表,按照指数的大小逐个比较,并将相同指数的项系数相加,将不同指数的项加入到结果链表中。

多项式的减法运算可以通过将减数链表中的每个项的系数取相反数,然后调用加法运算。

多项式的乘法运算可以通过遍历两个链表,计算每一项的系数和指数的乘积,将结果项按照指数从大到小的顺序加入到结果链表中。

除了基本的加法、减法和乘法运算外,还可以对多项式进行求导、求积分等运算。

数据结构单链表实验报告记录

数据结构单链表实验报告记录

数据结构单链表实验报告记录————————————————————————————————作者:————————————————————————————————日期:一、设计人员相关信息1.设计者姓名、学号和班号:12地信李晓婧120122429832.设计日期:2014.3.上机环境:VC++6.0二、程序设计相关信息1.实验题目:编写一个程序,实现单链表的各种基本运算(假设单链表的元素类型为char),并在此基础上设计一个程序,完成如下功能:(1)初始化单链表;(2)采用尾插法依次插入元素a,b,c,d,e;(3)输出单链表(4)输出单链表长度(5)判断单链表是否为空(6)输出单链表第3个元素(7)输出元素a的位置(8)在第4个元素位置上插入元素f(9)输出单链表(10)删除第三个元素(11)输出单链表(12)释放单链表2.实验项目组成:(1)插入和删除节点操作(2)建立单链表尾插法建表(3)线性表基本运算在单链表中的实现初始化线性表销毁线性表判断线性表是否为空表求线性表的长度3.实验项目的程序结构(程序中的函数调用关系图):MainLinkListInitListCreateListRDispListListLengthListEmptyGetElemLocateElemListInsertListDeleteDestroyList4.实验项目包含的各个文件中的函数的功能描述:●尾插法建表CreateListR:将新节点插到当前链表的表尾上,为此必须增加一个尾指针r,使其始终指向当前链表的尾节点。

●初始化线性表InitList:该运算建立一个空的单链表,即创建一个头节点;●销毁线性表DestroyList:释放单链表占用的内存空间,即逐一释放全部节点的空间;●判断线性表是否为空表ListEmpty:若单链表没有数据节点,则返回真,否则返回假;●求线性表的长度ListLength:返回单链表中数据节点的个数;●输出线性表DispList:逐一扫描单链表的每个数据节点,并显示各节点的data域值;●求线性表中某个数据元素值GetElem:在单链表中从头开始找到第i个节点,若存在第i个数据节点,则将其data域值赋给变量e;●按元素值查找LocateElem:在单链表中从头开始找第一个值域与e相等的节点,若存在这样的节点,则返回逻辑序号,否则返回0;●插入数据元素ListInsert:先在单链表中找到第i-1个节点*p,若存在这样的节点,将值为e的节点*s插入到*p节点的后面;●删除数据元素ListDelete:先在单链表中找到第i-1个节点*p,若存在这样的节点,且也存在后继节点*q;删除*q节点,返回TRUE;否则返回FALSE表示参数i错误。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。

(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。

(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。

数据结构实验报告之链表顺序表的操作

数据结构实验报告之链表顺序表的操作

数据结构实验报告之链表顺序表的操作1、编写程序实现顺序表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(1)初始化顺序表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出顺序表L;(9)删除L的第2个元素,之后输出顺序表L;(10)销毁顺序表L。

2、编写程序实现单链表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(1)初始化单链表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出单链表L;(9)删除L的第2个元素,之后输出单链表L;(10)销毁单链表L。

1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满,增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。

数据结构线性表实验报告

数据结构线性表实验报告

一、实验目的和要求(1)理解线性表的逻辑结构特性。

(2)深入掌握线性表的两种存储方法,即顺序表和链表。

体会这两种存储结构之间的差异。

(3)重点掌握顺序表和链表上各种基本运算的实现。

(4)综合运用线性表解决一些复杂的实际问题。

二、实验内容实验2.1 编写一个程序algo2-1.cpp,实现顺序表的各种基本运算(假设顺序表的元素类型为char),并在此基础上设计一个程序exp2-1.cpp,完成如下功能:(1)初始化顺序表L;(2)采用尾插法依次插入元素a,b,c,d,e;(3)输出顺序表L;(4)输出顺序表L长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第三个元素;(7)输出元素a的位置;(8)在第4个元素位置上插入元素f;(9)输出顺序表L;(10)删除L的第3个元素;(11)输出顺序表L;(12)释放顺序表L。

实验2.2 编写一个程序algo2-2.cpp,实现单链表的各种基本运算(假设单链表的元素类型为char),并在此基础上设计一个程序exp2-2.cpp,完成如下功能:(1)初始化单链表h;(2)采用尾插法依次插入元素a,b,c,d,e;(3)输出单链表h;(4)输出单链表h长度;(5)判断单链表h是否为空;(6)输出单链表h的第三个元素;(7)输出元素a的位置;(8)在第4个元素位置上插入元素f;(9)输出单链表h;(10)删除L的第3个元素;(11)输出单链表h;、(12)释放单链表h。

释放顺序表L。

实验2.3 编写一个程序algo2-3.cpp,实现双链表的各种基本运算(假设双链表的元素类型为char),并在此基础上设计一个程序exp2-3.cpp,完成如下功能:(1)初始化双链表h;(2)采用尾插法依次插入元素a,b,c,d,e;(3)输出双链表h;(4)输出双链表h长度;(5)判断双链表h是否为空;(6)输出双链表h的第三个元素;(7)输出元素a的位置;(8)在第4个元素位置上插入元素f;(9)输出双链表h;(10)删除L的第3个元素;(11)输出双链表h;、(12)释放双链表h。

数据结构--线性表的基本运算及多项式的算术运算

数据结构--线性表的基本运算及多项式的算术运算

数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算,多项式的加法和乘法算术运算。

要求:能够正确演示线性表的查找、插入、删除运算。

实现多项式的加法和乘法运算操作。

二、实验环境(实验设备)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种运算,具体说明见注释。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实现单链表的各种基本运算一、实验目的了解单链表表的结构特点及有关概念,掌握单链表的各种基本操作算法思想及其实现。

二、实验内容编写一个程序,实现顺序表的各种基本运算:1、初始化单链表;2、单链表的插入;3、单链表的输出;4、求单链表的长度5、判断单链表是否为空;6、输出单链表的第i位置的元素;7、在单链表中查找一个给定元素在表中的位置;8、单链表的删除; 9、释放单链表三、算法思想与算法描述简图主函数main void InitList(LinkList*&L) 初始化单链表Lvoid DestroyList(LinkList*&L)//释放单链表Lint ListEmpty(LinkList*L)//判断单链表L是否为空集int Listlength(LinkList*L)//返回单链表L的元素个数void DispList(LinkListt*L)//输出单链表Lint GetElem(LinkList*L,int i,char e)/*ElemType e)获取单链表L中的第i个元素*/int LocateEmpty(LinkList*L,char e)/*ElemType e)在单链表L中查找元素e*/int ListInsert(LinkList*&L,int i,char e)/*ElemType e)在单链表中第i个位置上插入元素e*/int ListDelete(LinkList*&L,int i,char &e)/*ElemTypee)在单链表L中删除第i个元素*/四、实验步骤与算法实现#include<stdio.h>#include<malloc.h>typedef char ElemType;typedef struct LNode//定义单链表{ ElemType data;struct LNode *next;}LinkList;void InitList(LinkList*&L){ L=(LinkList*)malloc(sizeof(LinkList));//创建头结点L->next=NULL;//头结点赋值为空}void DestroyList(LinkList*&L)//销毁单链表(释放单链表L占用的内存空间即逐一释放全部结点的空间){ LinkList*p=L,*q=p->next;while(q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList*L)//判线性表是否为空表ListEmpty(L){ return(L->next==NULL);}//若单链表L没有数据结点,则返回真,否则返回假。

int ListLength(LinkList*L)//求线性表的长度ListLength(L){ LinkList*p=L;int i=0;while(p->next!=NULL){i++;p=p->next;}return(i);//返回单链表L中数据结点的个数}void DispList(LinkList*L)//输出线性表DispList(L){LinkList*p=L->next;while (p!=NULL)//逐一扫描单链表L的每个数据结点,并显示各结点的data域值。

{printf("%c",p->data);p=p->next;}printf("\n");}int GetELem(LinkList*L,int i,ElemType&e)//求线性表L中指定位置的某个数据元素GetElem(L,i,&e){int j=0;LinkList*p=L;while(j<i&&p!=NULL)//在单链表L中从头开始找到第 i个结点,若存在第i 个数据结点,则将其data域值赋给变量e。

{j++;p=p->next;}if(p==NULL)return 0;//不存在第i个数据结点else{e=p->data;//存在第i个数据结点return 1;}}int LocateElem(LinkList*L,ElemType e)//按元素值查找LocateElem(L,e) {LinkList *p=L->next;int n=1;while (p!=NULL&&p->data!=e)//在单链表L中从头开始找第1个值域与e相等的结点,若存在这样的结点,则返回位置,否则返回0。

{p=p->next;n++;}if(p=NULL)return (0);elsereturn (n);}int ListInsert(LinkList*&L,int i,ElemType e)//插入数据元素ListInsert(&L,i,e){int j=0;LinkList*p=L,*s;while(j<i-1&&p!=NULL)//先在单链表L中找到第i-1个结点*p,若存在这样的结点,将值为e的结点*s插入到其后。

{j++;p=p->next;}if(p==NULL)return 0;//未找到位序为i-1的结点else{s=(LinkList*)malloc(sizeof(LinkList));s->data=e;s->next=p->next;//将*s插入到*p之后p->next=s;return 1;}}int ListDelete(LinkList*&L,int i,ElemType &e)//删除数据元素ListDelete(&L,i,&e){int j=0;LinkList*p=L,*q;while(j<i-1&&p!=NULL)//查找第i-1个结点{j++;p=p->next;}if(p==NULL)//未找到位序为i-1的结点return 0;else//找到位序为i-1的结点*p{q=p->next;//q指向要删除的结点if(q==NULL)return 0;//若不存在第i个结点,返回0e=q->data;p->next=q->next;//从单链表中删除*q结点free(q);//释放*q结点return 1;}}void main(){LinkList *h;ElemType e;printf("(1)初始化单链表h\n");InitList(h);printf("(2)依次采用尾插入abcd,efgh,jilk,nnnn,kkkk元素\n");ListInsert(h,1,'abcd');ListInsert(h,2,'efgh');ListInsert(h,3,'jilk');ListInsert(h,4,'nnnn');ListInsert(h,5,'kkkk');printf("(3)输出单链表h:");DispList(h);printf("(4)单链表h长度=%d\n",ListLength(h));printf("(5)单链表h为%s\n",(ListEmpty(h)?"空":"非空")); GetELem(h,3,e);printf("(6)单链表h的第三个元素=%c\n",e);printf("(7)元素a的位置=%d\n",LocateElem(h,'a'));printf("(8)在第四个元素的位置上插入9元素\n"); ListInsert(h,4,'9');printf("(9)输出单链表h:");DispList(h);printf("(10)删除h的第三个元素\n");ListDelete(h,3,e);printf("(11)输出单链表h:");DispList(h);printf("(12)释放单链表h\n");DestroyList(h);}五、实验测试及结果六、思考题1、单链表有带头结点和不带头结点两种形式,则相应的操作实现有何区别?答:在带头节点的单链表中,头指针(head)只有一个域,即链指针,它指向头结点,头结点有两个域,一个是数据域,值为0(NULL),还有一个域,链指针,这个链指针指向单链表的第一个数据元素。

而在不带头结点的单链表中,头指针也只有一个链指针,但它指向单链表的第一个数据元素。

2、单向循环链表、双向链表、双向循环链表基本操作的实现。

答:(1)单向循环链表循环链表的基本运算实现算法与非循环链表的算法基本相同,只是对表尾的判断作了改变。

因此单向循环链表与单链表基本上操作相同,只不过表尾的条件将发生变化。

(2)双向链表基本操作实现双链表中有两个指针域,一个指向其直接后继结点,另一个指向其直接前驱结点。

建立双链表有头插法和尾插法。

【1】头插法:Void CreateListF(DLinkList *&L,ElemType a[],int n)//由含有n个元素的数组a创建带头结点的双链表L{DLinkList *s;int i;L=(DLinkList *)malloc(sizeof(DLinkList));L->prior=L->next=NULL;for(i=0;i<n;i++){s=(DLinkList *)malloc(sizeof(DLinkList));s->data=a[i];s->next=L->next;if(L->next!=NULL)L->next=L->prior=s;L->next=s;s->prior=L;}}【2】尾插法Void CreateListF(DLinkList *&L,ElemType a[],int n)//由含有n个元素的数组a创建带头结点的双链表L{DLinkList *s,*r;int I;L=(DLinkList *)malloc(sizeof(DLinkList));L->prior=L->next=NULL;r=L;//r始终指向尾结点,开始时指向头结点for(i=0;i<n;i++){s=(DLinkList *)malloc(sizeof(DLinkList));s->data=a[i];r->next=s;s->prior=r;r=s;}r->next=NULL;}在双链表中,大部分基本操作运算与单链表相同,除插入与删除有所区别。

相关文档
最新文档