双向链表实验报告
13软工转本1 钱剑滨实验报告
双向链表实验报告
信息工程系 13软工转本1 日期 2016年03月12日
姓名钱剑滨学号 13131116 电话
一、实验内容
编写关于双向链表操作的C语言程序，要求包含双向链表的创建（生成）、输出（遍历）、查找、任意位置插入、有顺序插入、删除、等。
二、实验步骤
1.分析操作所需思路，熟练运用单链表的各种特点。
2.编写程序，利用函数特性进行操作。
3.运行程序，纠正错误，对预测结果进行验证。
4.分析总结单链表的优缺点，并可以做到熟练掌握双向链表的各种
操作。
三、设计概要
1.本实验包含了7个函数：
a)主函数main()
b)创建链表函数Listcreate()
c)数据输出函数Listprint()
d)查找数据函数Listlocate()
e)无序插入函数Listinsert_discretion ()
f)有序插入函数Listinsert_order
g)删除数据函数Listdelete()
2.明确函数的功能；
a)Listcreate() 创建一个可控长度的斐波那契数列的双向链表。
b)Listprint() 将此链表中的数据全部输出。
c)Listlocate() 查找此链表中任意位置元素的值。
d)Listinsert_discretion ()向此链表的某个位置插入一组数据。
e)Listinsert_order() 向数列中插入一个数，使插入后的数列任
然有序
f)Listdelete() 将此链表的某个位置的一组数据删除。
四、程序设计
1.函数前包含的头文件名、结点类型定义、全局变量和函数声明
#include
#include
typedef struct number //定义结构体
{
struct number *prior；
int num;
struct number *next;
}number;
number *head; //定义全局变量头节点
int k = 0; //k记录元素个数，防止溢出
/*函数声明*/
void Listcreate(); //建立链表
void Listprint(); //全体输出
void Listlocate(); //查找
void Listinsert_discretion(); //任意位置插入
void Listinsert_order(); //有顺序插入
void Listdelete(); //删除
2.主函数main()
void main()
{
int select;
printf("1、输入斐波那契数列的个数\n");
printf("2、全部输出数列\n");
printf("3、查找定位数列的元素\n");
printf("4、添加数列元素\n");
printf("5、插入顺序数列元素\n");
printf("6、删除数列元素\n");
printf("-------------------------------------\n");
while (1)
{
printf("请选择序号\n");
scanf("%d", &select);
switch (select)
{
case 1: Listcreate(); break; //链表创建
case 2: Listprint(); break; //全链表输出
case 3: Listlocate(); break; //元素查找
case 4: Listinsert_discretion(); break; //任意位置插入
case 5: Listinsert_order(); break; //有顺序插入
case 6: Listdelete(); break; //删除
default: break;
}
}
}
3.创建链表函数Listcreate()
void Listcreate() //建立链表
{
head = (number *)malloc(sizeof (number)); //开辟一个大小为number的内存空间给头节点
head->next = NULL;
head->prior = NULL;
int a = 1,b = 1; //a、b为斐波那契数列的前两个元素
int i;
number *q;
number *p = head; //p始终指向最后一个节点
printf("输入元素的长度\n");
scanf("%d",&i);
/*给第一个元素赋值*/
q = (number *)malloc(sizeof (number)); //开辟一个大小为number的内存空间给后面节点
q->num = a;
q->next = NULL; //新开辟的节点指向NULL
p->next = q; //前一节点指向新开辟的节点
q->prior = p; //开辟的节点前驱指向p
p = p->next; //p指向新节点
i = i - 1;
k = k + 1;
/*给第二个元素赋值*/
q = (number *)malloc(sizeof (number));
q->num = b;
q->next = NULL;
p->next = q;
q->prior = p;
p = p->next;
i = i - 1;
k = k + 1;
/*给后续元素赋值*/
while (i--)
q = (number *)malloc(sizeof (number));
q->num = (a+b);
q->next = NULL;
p->next = q;
q->prior = p;
p = p->next;
a = a +
b + b; //
b = a - b; //将a+b的值付给b;b的值付给a
a = a - b; //
k = k + 1;
}
printf("链表建立成功\n");
}
4.数据输出函数Listprint()
void Listprint() //全体输出
{
number *p = head->next;
while (p != NULL)
{
printf("%d ", p->num);
p = p->next;
}
printf("\n");
}
5.查找数据函数Listlocate()
void Listlocate() //查找
{
int i;
number *p = head;
printf("输入您要查询的元素位置\n");
scanf("%d", &i);
if ((i > k) || (i <= 0))
{
printf("查询的位置不存在\n");
}
else
{
while (i--)
{
p = p->next;
}
printf("所查找数为%d\n", p->num);
}
}
6.无序插入函数Listinsert_discretion()
void Listinsert_discretion() //任意位置插入
{
int i;
number *q;
number *p = head;
printf("输入您要插入哪个元素的后面\n");
scanf("%d", &i);
if ((i > k) || (i < 0))
{
printf("插入的位置不存在\n");
}
else
{
while (i--)
{
p = p->next; //p最后指向要插入位置的前一个节点}
q = (number *)malloc(sizeof (number));
if (p->next == NULL) //插到末尾
{
q->next = NULL; //B的下一个元素指向空
p->next = q; //p的下一个元素指向B
q->prior = p; //B的前驱指向p
}
else
{
q->next = p->next; //B的下一个元素指向p的下一个（两个不能反）
p->next->prior = q; //p的下一个元素的前驱指向B
p->next = q; //p的下一个元素指向B
q->prior = p; //B的前驱指向p
}
printf("输入您要插入的数\n");
scanf("%d", &(q->num));
k = k + 1;
}
printf("插入成功\n");
}
7.有序插入函数Listinsert_order ()
void Listinsert_order() //有顺序插入
{
number *q;
number *p = head;
q = (number *)malloc(sizeof (number));
printf("输入您要插入哪个数\n");
scanf("%d", &q->num);
while (p->next)
{
if (p->next->num >= q->num) //插在第一个比数大或等于的的数前
{
q->next = p->next;
p->next->prior = q;
p->next = q;
q->prior = p;
k = k + 1;
break;
}
else
{
p = p->next;
}
}
if (p->next == NULL) //插到末尾
{
q->next = NULL;
p->next = q;
q->prior = p;
k = k + 1;
}
printf("插入成功\n");
}
8.删除数据函数Listdelete ()
void Listdelete() //删除
{
int i;
number *q;
number *p=head;
printf("输入您要删除哪个元素\n");
scanf("%d", &i);
if ((i > k) || (i <= 0))
{
printf("删除的位置不存在\n");
}
else
{
while (--i) //这里是先减再判断
{
p = p->next; //p指向被删除的元素的前一个元素
}
q = p->next; //q指向被删除的元素
if (q->next == NULL) //删除最后一个元素
{
p->next = NULL;
}
else
{
p->next = q->next; //p的下一个元素指向q的下一个，即跳过被删除元素
q->next->prior = p; //q的下一个元素的前驱指向p，也跳过被删除的元素
}
free(q); //清空删除元素
k = k - 1;
}
printf("删除成功\n");
}
五、程序源码
#include
#include
typedef struct number
{
struct number *prior;
int num;
struct number *next;
}number;
number *head; //定义全局变量头节点
int k = 0; //k记录元素个数，防止溢出
void Listcreate(); //建立链表
void Listprint(); //全体输出
void Listlocate(); //查找
void Listinsert_discretion(); //任意位置插入
void Listinsert_order(); //有顺序插入
void Listdelete(); //删除
void main()
{
int select;
printf("1、输入斐波那契数列的个数\n");
printf("2、全部输出数列\n");
printf("3、查找定位数列的元素\n");
printf("4、添加数列元素\n");
printf("5、插入顺序数列元素\n");
printf("6、删除数列元素\n");
printf("-------------------------------------\n");
while (1)
{
printf("请选择序号\n");
scanf("%d", &select);
switch (select)
{
case 1: Listcreate(); break;//链表创建
case 2: Listprint(); break;//全链表输出
case 3: Listlocate(); break; //元素查找
case 4: Listinsert_discretion(); break; //任意位置插入
case 5: Listinsert_order(); break; //有顺序插入
case 6: Listdelete(); break; //删除
default: break;
}
}
}
void Listcreate() //建立链表
{
head = (number *)malloc(sizeof (number)); //开辟一个大小为number 的内存空间给头节点
head->next = NULL;
head->prior = NULL;
int a = 1,b = 1; //a、b为斐波那契数列的前两个元素int i;
number *q;
number *p = head; //p始终指向最后一个节点
printf("输入元素的长度\n");
scanf("%d",&i);
q = (number *)malloc(sizeof (number)); //开辟一个大小为number的内存空间给后面节点
q->num = a;
q->next = NULL; //新开辟的节点指向NULL
p->next = q; //前一节点指向新开辟的节点
q->prior = p; //开辟的节点前驱指向p
p = p->next; //p指向新节点
i = i - 1;
k = k + 1;
q = (number *)malloc(sizeof (number));
q->num = b;
q->next = NULL;
p->next = q;
q->prior = p;
p = p->next;
i = i - 1;
k = k + 1;
while (i--)
{
q = (number *)malloc(sizeof (number));
q->num = (a+b);
q->next = NULL;
p->next = q;
q->prior = p;
p = p->next;
a = a +
b + b; //
b = a - b; //将a+b的值付给b;b的值付给a
a = a - b; //
k = k + 1;
}
printf("链表建立成功\n");
}
void Listprint() //全体输出
{
number *p = head->next;
while (p != NULL)
{
printf("%d ", p->num);
p = p->next;
}
printf("\n");
}
void Listlocate() //查找
{
int i;
number *p = head;
printf("输入您要查询的元素位置\n");
scanf("%d", &i);
if ((i > k) || (i <= 0))
{
printf("查询的位置不存在\n");
}
else
{
while (i--)
{
p = p->next;
}
printf("所查找数为%d\n", p->num);
}
}
void Listinsert_discretion() //任意位置插入
{
int i;
number *q;
number *p = head;
printf("输入您要插入哪个元素的后面\n");
scanf("%d", &i);
if ((i > k) || (i < 0))
{
printf("插入的位置不存在\n");
}
else
{
while (i--)
{
p = p->next; //p最后指向要插入位置的前一个节点}
q = (number *)malloc(sizeof (number));
if (p->next == NULL) //插到末尾
{
q->next = NULL; //B的下一个元素指向空
p->next = q; //p的下一个元素指向B
q->prior = p; //B的前驱指向p
}
else
{
q->next = p->next; //B的下一个元素指向p的下一个（两个不能反）
p->next->prior = q; //p的下一个元素的前驱指向B
p->next = q; //p的下一个元素指向B
q->prior = p; //B的前驱指向p
}
printf("输入您要插入的数\n");
scanf("%d", &(q->num));
k = k + 1;
}
printf("插入成功\n");
}
void Listinsert_order() //有顺序插入
{
number *q;
number *p = head;
q = (number *)malloc(sizeof (number));
printf("输入您要插入哪个数\n");
scanf("%d", &q->num);
while (p->next)
{
if (p->next->num >= q->num) //插在第一个比数大或等于的的数前{
q->next = p->next;
p->next->prior = q;
p->next = q;
q->prior = p;
k = k + 1;
break;
}
else
{
p = p->next;
}
}
if (p->next == NULL) //插到末尾
{
q->next = NULL;
p->next = q;
q->prior = p;
k = k + 1;
}
printf("插入成功\n");
}
void Listdelete() //删除
{
int i;
number *q;
number *p=head;
printf("输入您要删除哪个元素\n");
scanf("%d", &i);
if ((i > k) || (i <= 0))
{
printf("删除的位置不存在\n");
}
else
{
while (--i) //这里是先减再判断
{
p = p->next; //p指向被删除的元素的前一个元素}
q = p->next; //q指向被删除的元素
if (q->next == NULL) //删除最后一个元素
{
p->next = NULL;
}
else
{
p->next = q->next; //p的下一个元素指向q的下一个，即跳过被删除元素
q->next->prior = p; //q的下一个元素的前驱指向p，也跳过被删除的元素
}
free(q); //清空删除元素
k = k - 1;
}
printf("删除成功\n");
}
六、测试结果
1.最初运行程序时，有如下结果：
2.在输入1后，创建长度为10的斐波那契数列，结果如下：
3.在输入2后，显示数列，结果如下：
4.在输入3后，进行查询操作后，结果如下：
5.在输入4后，进行无序插入操作后，结果如下：
6.在输入5后，进行有序插入操作后，结果如下：
7.在输入6后，进行删除操作后，结果如下：
8.输入其他数字的结果：
七、总结反思
刚做这个题目的时候发现自己结构体和链表学的太浅了，以前学得只是也不能很好的运用。所以我又复习起了结构体和链表。一开始用单链表实现，想自己做，但没有头绪，心里有了惧怕，一直没做出来。看了书本上的几行代码后有了思路，思路也通了。经过代码的编写和调试，运行出来了，感觉很神奇，而且也找回了信心。
后来要求要用双向链表来实现。我知道关键的就那几行代码，弄清楚后，也很快调试出来。
在程序的细节上表现的不是很好，代码变量命名随意，代码书写不规范，在翻看了编码规范后，我改进了代码。时间浪费了，下次要按规定来。在用户界面上不友善，后来加了些printf语句使程序运行界面更加友善了。
城市链表实验报告
2014-2015学年第一学期实验报告 课程名称：算法与数据结构 实验名称：城市链表
一、实验目的 本次实验的主要目的在于熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉各种链表的操作为侧重点。同时，通过本次实验帮助学生复习高级语言的使用方法。 二、实验内容 （一）城市链表： 将若干城市的信息，存入一个带头结点的单链表。结点中的城市信息包括：城市名，城市的位置坐标。要求能够利用城市名和位置坐标进行有关查找、插入、删除、更新等操作。 (二) 约瑟夫环 m 的初值为20；密码：3，1，7，2，6，8，4（正确的结果应为6，1，4，7，2，3，5）。三、实验环境 VS2010 、win8.1 四、实验结果 （一）城市链表: （1）创建城市链表； （2）给定一个城市名，返回其位置坐标； （3）给定一个位置坐标P 和一个距离D，返回所有与P 的距离小于等于 D 的城市。 （4）在已有的城市链表中插入一个新的城市； （5）更新城市信息； （6）删除某个城市信息。 (二) 约瑟夫环 m 的初值为20；密码：3，1，7，2，6，8，4 输出6，1，4，7，2，3，5。 五、附录 城市链表： 5.1 问题分析 该实验要求对链表实现创建，遍历，插入，删除，查询等操作，故使用单链表。
5.2 设计方案 该程序大致分为以下几个模块： 1.创建城市链表模块，即在空链表中插入新元素。故创建城市链表中包涵插入模块。 2.返回位置坐标模块。 3.计算距离模块 4.插入模块。 5.更新城市信息模块 6.删除信息模块。 5.3 算法 5.3.1 根据中心城市坐标，返回在距离内的所有城市： void FindCityDistance(citylist *L){ //根据距离输出城市 ……//输入信息与距离 L=L->next; w hile(L != NULL){ if(((L->x-x1)*(L->x-x1)+(L->y-y1)*(L->y-y1 )<=dis*dis)&&(((L->x-x1)+(L->y-y1))!=0 )){ printf("城市名称%s\n",L->Name); printf("城市坐标%.2lf,%.2lf\n",L->x,L->y); } L=L->next; } } 该算法主要用到了勾股定理，考虑到不需要实际数值，只需要大小比较，所以只用 横坐标差的平方+纵坐标差的平方<= 距离的平方判定。
链表实验报告
C语言程序设计实验报告 实验一：链表的基本操作一·实验目的 1.掌握链表的建立方法 2.掌握链表中节点的查找与删除 3.掌握输出链表节点的方法 4.掌握链表节点排序的一种方法 5.掌握C语言创建菜单的方法 6.掌握结构化程序设计的方法 二·实验环境 1.硬件环境：当前所有电脑硬件环境均支持 2.软件环境：Visual C++6.0 三.函数功能 1. CreateList // 声明创建链表函数 2.TraverseList // 声明遍历链表函数 3. InsertList // 声明链表插入函数 4.DeleteTheList // 声明删除整个链表函数 5. FindList // 声明链表查询函数 四．程序流程图 五．程序代码 #include
r=head;//r指向头结点 printf("输入数字:\n"); for(i=n;i>0;i--)//for 循环用于生成第一个节点并读入数据{ scanf("%d",&x); p=(node *)malloc(sizeof(node)); p->data=x;//读入第一个节点的数据 r->next=p;//把第一个节点连在头结点的后面 r=p;//循环以便于生成第二个节点 } r->next=0;//生成链表后的断开符 return head;//返回头指针 } void output (linklist head)//输出链表 { linklist p; p=head->next; do { printf("%3d",p->data); p=p->next; } while(p); printf("\n") } Status insert ( linklist &l,int i, Elemtype e)//插入操作 { int j=0; linklist p=l,s; while(j
数据结构实验集合的并交差运算实验报告记录
数据结构实验集合的并交差运算实验报告记录
————————————————————————————————作者：————————————————————————————————日期：
实验报告 实验课程：数据结构 实验项目：实验一集合的并交差运算专业：计算机科学与技术 班级： 姓名： 学号： 指导教师：
目录一、问题定义及需求分析 （1）实验目的 （2）实验任务 （3）需求分析 二、概要设计： (1)抽象数据类型定义 (2)主程序流程 (3) 模块关系 三、详细设计 (1)数据类型及存储结构 (2)模块设计 四、调试分析 (1)调试分析 (2)算法时空分析 (3)经验体会 五、使用说明 (1)程序使用说明 六、测试结果 (1)运行测试结果截图 七、附录 (1)源代码
一、问题定义及需求分析 （1）实验目的 设计一个能演示集合的并、交、差运算程序。 （2）实验任务 1)采用顺序表或链表等数据结构。 2)集合的元素限定为数字和小写英文字母。 （3）需求分析： 输入形式为:外部输入字符串； 输入值限定范围为:数字和小写英文字母； 输出形式为：字符集； 程序功能:计算两个集合的交、并、差以及重新输入集合功能； 二、概要设计： (1)抽象数据类型定义： 线性表 (2)主程序流程： 调用主菜单函数初始化两个线性表作为集合给两个集合输入数据输出集合数据元素信息另初始化两个线性表创建选择功能菜单界面通过不同选项调用不同功能函数在每个功能函数里面加结束选择功能，实现循环调用功能菜单 计算完毕退出程序； （3）模块关系： 主菜单 差运算并运算交运算新建集合结束/返回 结束 三、详细设计 抽象数据类型定义： typedef struct{ ElemType *elem; int length; int listsize;
单链表实验报告
计算机与信息技术学院综合性、设计性实验报告 一、实验目的 (1)熟悉顺序表的创建、取值、查找、插入、删除等算法，模块化程序设计方法。 二、实验仪器或设备 (1)硬件设备：CPU为Pentium 4 以上的计算机，内存2G以上 (2)配置软件：Microsoft Windows 7 与VC++6.0 三、总体设计(设计原理、设计方案及流程等) 设计原理： 单链表属于线性表，线性表的存储结构的特点是：用一组任意存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。因此，对于某个元素来说，不仅需要存储其本身的信息，还需要存储一个指示其直接后继的信息。 设计方案： 采用模块化设计的方法，设计各个程序段，最终通过主函数实现各个程序段的功能。设计时，需要考虑用户输入非法数值，所以要在程序中写入说可以处理非法数值的代码。 设计流程： 1. 引入所需的头文件； 2. 定义状态值； 3. 写入顺序表的各种操作的代码； 写入主函数，分别调用各个函数。在调用函数时，采用if结构进行判断输 入值是否非法，从而执行相应的程序 四、实验步骤(包括主要步骤、代码分析等) #include
链表实现多项式相加实验报告
实验报告 课程名称：数据结构 题目：链表实现多项式相加 班级： 学号： 姓名： 完成时间：2012年10月17日
1、实验目的和要求 1）掌握链表的运用方法； 2）学习链表的初始化并建立一个新的链表； 3）知道如何实现链表的插入结点与删除结点操作； 4）了解链表的基本操作并灵活运用 2、实验内容 1）建立两个链表存储一元多项式； 2）实现两个一元多项式的相加； 3）输出两个多项式相加后得到的一元多项式。 3、算法基本思想 数降序存入两个链表中，将大小较大的链表作为相加后的链表寄存处。定义两个临时链表节点指针p,q,分别指向两个链表头结点。然后将另一个链表中从头结点开始依次与第一个链表比较，如果其指数比第一个小，则p向后移动一个单位，如相等，则将两节点的系数相加作为第一个链表当前节点的系数，如果为0，则将此节点栓掉。若果较大，则在p前插入q,q向后移动一个，直到两个链表做完为止。 4、算法描述 用链表实现多项式相加的程序如下： #include
void add_node(struct node*h1,struct node*h2); void print_node(struct node*h); struct node*init_node() { struct node*h=(struct node*)malloc(sizeof(struct node)),*p,*q; int exp; float coef=1.0; h->next=NULL; printf("请依次输入多项式的系数和指数(如:\"2 3\"；输入\"0 0\"时结束):\n"); p=(struct node*)malloc(sizeof(struct node)); q=(struct node*)malloc(sizeof(struct node)); for(;fabs(coef-0.0)>1.0e-6;) { scanf("%f %d",&coef,&exp); if(fabs(coef-0.0)>1.0e-6) { q->next=p; p->coef=coef; p->exp=exp; p->next=NULL; add_node(h,q); } } free(p); free(q); return(h); } void add_node(struct node*h1,struct node*h2) { struct node*y1=h1,*y2=h2; struct node*p,*q; y1=y1->next; y2=y2->next; for(;y1||y2;) if(y1) { if(y2) { if(y1->exp
链表实验报告
链表实验报告
————————————————————————————————作者: ————————————————————————————————日期：
《数据结构》实验报告二 系别:嵌入式系统工程系班级:嵌入式1１0０3班 学号:１1160400３１4姓名：孙立阔 日期：2012年４月９日指导教师:申华 一、上机实验的问题和要求： 单链表的查找、插入与删除。设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。具体实现要求: 1.从键盘输入1０个字符，产生不带表头的单链表，并输入结点值。 2.从键盘输入1个字符,在单链表中查找该结点的位置。若找到,则显示“找到了”；否则, 则显示“找不到”。 3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插 入在对应位置上，输出单链表所有结点值,观察输出结果。 4.从键盘输入１个整数,表示欲删除结点的位置，输出单链表所有结点值,观察输出结果。 5.将单链表中值重复的结点删除,使所得的结果表中个结点值均不相同,输出单链表所有结 点值,观察输出结果。 6.删除其中所有数据值为偶数的结点，输出单链表所有结点值,观察输出结果。 7.（★)将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素, 而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表Ａ和单链表B的所有结点值，观察输出结果。 二、程序设计的基本思想，原理和算法描述: (包括程序的结构,数据结构，输入/输出设计,符号名说明等） 创建一个空的单链表，实现对单链表的查找，插入,删除的功能。 三、源程序及注释： #dｅfiｎｅOK 1 #defｉne EＲＲOR 0 #ｄefiｎe INFEASIBLE －1 #defｉne OVEＲFＬOW －2 #deｆine TRUE 1
单链表的插入和删除实验报告
. 实验一、单链表的插入和删除 一、目的 了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 二、要求： 建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 三、程序源代码 #include"stdio.h" #include"string.h" #include"stdlib.h" #include"ctype.h" typedef struct node //定义结点 { char data[10]; //结点的数据域为字符串 struct node *next; //结点的指针域 }ListNode; typedef ListNode * LinkList; // 自定义LinkList单链表类型 LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表
ListNode *LocateNode(); //函数，按值查找结点 void DeleteList(); //函数，删除指定值的结点void printlist(); //函数，打印链表中的所有值 void DeleteAll(); //函数，删除所有结点，释放内存 //==========主函数============== void main() { char ch[10],num[10]; LinkList head; head=CreatListR1(); //用尾插入法建立单链表，返回头指针printlist(head); //遍历链表输出其值 printf(" Delete node (y/n):");//输入“y”或“n”去选择是否删除结点scanf("%s",num); if(strcmp(num,"y")==0 || strcmp(num,"Y")==0){ printf("Please input Delete_data:"); scanf("%s",ch); //输入要删除的字符串 DeleteList(head,ch); printlist(head); } DeleteAll(head); //删除所有结点，释放内存 } //==========用尾插入法建立带头结点的单链表
数据结构树的实现实验报告
数据结构设计性实验报告 课程名称_____ ____ 题目名称 学生学院 专业班级 学号 学生姓名 指导教师 2010 年 7 月 6 日
抽象数据类型：树的实现 一．需求分析 树形结构是一类重要的非线性数据结构，其中以树和二叉树最为常用，直观来看，树是以分支关系定义的内部结构。树的结构在客观世界广泛存在，如人类社会的族谱和各种社会组织机构都可以用树来形象表示。树在计算机领域中也得广泛应用，如在编译程序中，可用树来表示源程序的语法结构，又如在数据库系统中，树形结构也是信息的重要组织形式之一。 二．实验目的 对某个具体的抽象数据类型，运用课程所学的知识和方法，设计合理的数据结构，并在此基础上实现该抽象数据类型的全部基本操作。通过本设计性实验，检验所学知识和能力，发现学习中存在的问题。进而达到熟练地运用本课程中的基础知识及技术的目的。 三．实验环境 1、硬件：PC机 2、软件：Microsoft Visual C++ 6.0 四．设计说明 本程序采用树的二叉链表（孩子指针-兄弟指针-双亲指针）存储表示，以下是树的结构定义和基本操作： ADT Tree{ 数据对象D：D是具有相同特性的数据元素的集合。 数据关系R： 若D为空集，则称为空树； 若D仅含有一个数据元素，则R为空集，否则R={H}，H是如下二元关系： (1) 在D中存在唯一的称为根的数据元素root，它在关系H下无前驱； (2) 若D-{root}≠NULL，则存在D-{root}的一个划分D1,D2,D3, …,Dm(m>0)，对于任意j ≠k(1≤j,k≤m)有Dj∩Dk=NULL,且对任意的i(1≤i≤m)，唯一存在数据元素xi∈Di有
C语言链表实验报告
链表实验报告 一、实验名称 链表操作的实现--学生信息库的构建 二、实验目的 （1）理解单链表的存储结构及基本操作的定义 （2）掌握单链表存储基本操作 （3）学会设计实验数据验证程序 【实验仪器及环境】计算机 Window XP操作系统 三、实验内容 1、建立一个学生成绩信息（学号，姓名，成绩）的单链表，按学号排序 2、对链表进行插入、删除、遍历、修改操作。 3、对链表进行读取（读文件）、存储（写文件） 四、实验要求 （1）给出终结报告（包括设计过程，程序）-打印版 （2）对程序进行答辩
五、实验过程、详细内容 1、概念及过程中需要调用的函数 （1）链表的概念结点定义 结构的递归定义 struct stud_node{ int num; char name[20]; int score; struct stud_node *next; }; （2）链表的建立 1、手动输入 struct stud_node*Create_Stu_Doc() { struct stud_node *head,*p; int num,score; char name[20]; int size=sizeof(struct stud_node); 【链表建立流程图】
2、从文件中直接获取 先建立一个 (3)链表的遍历 （4 ）插入结点 （5）删除结点 （6）动态储存分配函数malloc （） void *malloc(unsigned size) ①在内存的动态存储区中分配一连续空间，其长度为size ②若申请成功，则返回一个指向所分配内存空间的起始地址的指针 ③若申请不成功，则返回NULL （值为0） ④返回值类型：(void *) ·通用指针的一个重要用途 ·将malloc 的返回值转换到特定指针类型，赋给一个指针 【链表建立流程图】 ptr ptr ptr->num ptr->score ptr=ptr->next head pt r s s->next = ptr->next ptr->next = s 先连后断 ptr2=ptr1->next ptr1->next=ptr2->next free （ptr2）
链表基本操作实验报告
实验2 链表基本操作实验 一、实验目的 1． 定义单链表的结点类型。 2． 熟悉对单链表的一些基本操作和具体的函数定义。 3． 通过单链表的定义掌握线性表的链式存储结构的特点。 二、实验内容与要求 该程序的功能是实现单链表的定义和主要操作。如：单链表建立、输出、插入、删除、查找等操作。该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。程序中的单链表（带头结点）结点为结构类型，结点值为整型。 要求： 同学们可参考指导书实验2程序、教材算法及其他资料编程实现单链表相关操作。必须包括单链表创建、输出、插入、删除操作，其他操作根据个人情况增减。 三、 算法分析与设计。 头结点 ......
2.单链表插入 s->data=x; s->next=p->next; p->next=s; 3.单链表的删除： p->next=p->next->next;
四、运行结果 1.单链表初始化 2.创建单链表 3.求链表长度 4.检查链表是否为空 5.遍历链表 6.从链表中查找元素 7.从链表中查找与给定元素值相同的元素在顺序表中的位置
8.向链表中插入元素 插入元素之后的链表 9.从链表中删除元素 删除位置为6的元素(是3) 10.清空单链表 五、实验体会 经过这次单链表基本操作实验，自己的编程能力有了进一步的提高，认识到自己以前在思考一个问题上思路不够开阔，不能灵活的表达出自己的想法，虽然在打完源代码之后出现了一些错误，但是经过认真查找、修改，最终将错误一一修正，主要是在写算法分析的时候出现了障碍，经过从网上查找资料，自己也对程序做了仔细的分析，对单链表创建、插入、删除算法画了详细的N-S流程图。
链表的基本操作-数据结构实验报告
大学数据结构实验报告 课程名称数据结构实验第（四）次实验实验名称链表的基本操作 学生姓名于歌专业班级学号 实验成绩指导老师（签名）日期2018年10月01日 一、实验目的 1. 学会定义单链表的结点类型，实现对单链表的一些基本操作和具体 的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。 2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。 二、实验要求 1．预习C语言中结构体的定义与基本操作方法。 2．对单链表的每个基本操作用单独的函数实现。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。 三、实验内容： 1．编写程序完成单链表的下列基本操作： （1）初始化单链表La （2）在La中插入一个新结点 （3）删除La中的某一个结点 （4）在La中查找某结点并返回其位置 （5）打印输出La中的结点元素值 （6）清空链表 （7）销毁链表 2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、 Lb合并成一个有序单链表Lc。 四、思考与提高： 1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？ 2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？五、实验设计 1．编写程序完成单链表的下列基本操作： （1）初始化单链表La LinkList InitList() {
int i,value,n; LinkList H=(LinkList)malloc(sizeof(LNode)); LinkList P=H; P->next=NULL; do{ printf("请输入链表的长度:"); scanf("%d",&n); if(n<=0) printf("输入有误请重新输入！\n"); }while(n<=0); printf("请输入各个元素:\n"); for(i=0; i
链表基本操作实验报告
实验2 链表基本操作实验 一、实验目的 1． 定义单链表的结点类型。 2． 熟悉对单链表的一些基本操作和具体的函数定义。 3． 通过单链表的定义掌握线性表的链式存储结构的特点。 二、实验容与要求 该程序的功能是实现单链表的定义和主要操作。如：单链表建立、输出、插入、删除、查找等操作。该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。程序中的单链表（带头结点）结点为结构类型，结点值为整型。 要求： 同学们可参考指导书实验2程序、教材算法及其他资料编程实现单链表相关操作。必须包括单链表创建、输出、插入、删除操作，其他操作根据个人情况增减。 三、 算法分析与设计。 头结点
2.单链表插入 s->data=x; s->next=p->next; p->next=s; 3.单链表的删除： p->next=p->next->next;
四、运行结果 1.单链表初始化 2.创建单链表 3.求链表长度 4.检查链表是否为空 5.遍历链表 6.从链表中查找元素 7.从链表中查找与给定元素值相同的元素在顺序表中的位置
8.向链表中插入元素 插入元素之后的链表 9.从链表中删除元素 删除位置为6的元素(是3) 10.清空单链表 五、实验体会 经过这次单链表基本操作实验，自己的编程能力有了进一步的提高，认识到自己以前在思考一个问题上思路不够开阔，不能灵活的表达出自己的想法，虽然在打完源代码之后出现了一些错误，但是经过认真查找、修改，最终将错误一一修正，主要是在写算法分析的时候出现了障碍，经过从网上查找资料，自己也对程序做了仔细的分析，对单链表创建、插入、删除算法画了详细的N-S流程图。
用单链表实现集合的操作
《数据结构》课设计报告 2012—2013学年第一学期 课程名称数据结构 设计题目用单链表实现集合的操作 专业班级 姓名 学号 指导教师 一．实验目的
掌握单链表的算法，插入、删除、遍历等。 二．实验内容 （1）对集合中的元素用有序单链表进行存储； （2）实现交、并、差等基本运算时，不能另外申请存储空间； （3）充分利用单链表的有序性，要求算法有较好的时间性能。 三．设计与编码 集合是由互不相同的元素构成的一个整体，在集合中，元素之间可以没有任何关系，所以，集合也可以作为线性表的处理。用单链表实现集合的操作，需要注意集合中元素的唯一性，即在单链表中不存在值相同的结点。 （1）判断A和B是否相等。两个集合相等的条件是不仅长度相同，而且各个对应的元素也相等。由于用单链表表示集合，所以只要同步搜啊秒两个单链表，若从头至尾每个对应的元素都相等，则表明两个集合相等。 （2）求集合A和B的交集。根据集合的运算规则，集合A∩B中包含所有既属于集合A又属于集合B的元素，因此，需要查找单链表A和B中的相同元素并保留在单链表A中。由于用有序单链表表示集合，因此判断某元素是否在B中不需要遍历表B，而是从上次搜索到的位置开始，若在搜索过程中，遇到一个其值比该元素大的结点，便可断定该元素不在单链表中，为此，需要用两个指针p、q分别指向当前被比较的两个结点，会出现以下三种情况： 1、若p->data>q->data，说明还未找到，需在表B中继续查找； 2、若p->data
单链表实验报告
单链表实验报告
————————————————————————————————作者：————————————————————————————————日期：
计算机与信息技术学院综合性、设计性实验报告 专业：网络工程年级／班级：大二 2016—2017学年第一学期 课程名称数据结构指导教师李四 学号姓名16０8３2４０XX 张三 项目名称单链表的基本操作实验类型综合性／设计性实验时间2017.10.3 实验地点216机房 一、实验目的 （１）熟悉顺序表的创建、取值、查找、插入、删除等算法，模块化程序设计方法。 二、实验仪器或设备 (1)硬件设备：CＰU为Pｅntium 4以上的计算机,内存２G以上 （２）配置软件:Microsｏft Windｏws 7与VC++6．０ 三、总体设计（设计原理、设计方案及流程等) 设计原理： 单链表属于线性表,线性表的存储结构的特点是：用一组任意存储单元存储线性表的数据元素,这组存储单元可以是连续的,也可以是不连续的。因此,对于某个元素来说，不仅需要存储其本身的信息,还需要存储一个指示其直接后继的信息。 设计方案: 采用模块化设计的方法，设计各个程序段,最终通过主函数实现各个程序段的功能。设计时，需要考虑用户输入非法数值,所以要在程序中写入说可以处理非法数值的代码。 设计流程: 1.引入所需的头文件; 2.定义状态值； 3.写入顺序表的各种操作的代码； 写入主函数,分别调用各个函数。在调用函数时，采用iｆ结构进行判断输入值是否非法,从而执行相应的程序 四、实验步骤（包括主要步骤、代码分析等） #inclｕdｅ<ｓtdio．h＞／/ EOF(=^Z或F6）,ＮUＬL #inclｕde＜ｓtdlｉb.ｈ＞ // sｒand（），raｎd（）,eｘｉt(n) #inｃlude＜ｍalloｃ.h> // mａlloc( )，alloc( ),ｒｅａllｏc（）等 ＃iｎcluｄe
基于单链表实现集合的并交差运算实验报告
基于单链表实现集合的并交差运算实验报告 一实验题目: 基于单链表实现集合的并交差运算二实验要求: 2.2: 编写一个程序，实现顺序表的各种基本运算 (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) 输出单链表 (12) 释放单链表 2.2: 编写一个程序，采用单链表表示集合( 集合中不存在重复的元素), 并将其按照递增的方式排序，构成有序单链表，并求这样的两个集合的并交和差。三实验内容: 3.1 线性表的抽象数据类型: 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
DestroyList(&L) 初始条件：线性表L 已存在操作结果：销毁线性表L ClearList(&L) 初始条件：线性表L 已存在操作结果：将L 置为空表 ListEmpty(L) 初始条件：线性表已存在操作结果：若L为空表，则返回 TRUE否则返回FALSE ListLength(L) 初始条件：线性表已存在 操作结果：返回L 中数据元素的个数GetElem(L,i) 初始条件: 线性表已存在，1<=i<=ListLength(L) 操作结果：用e返回L中第i个数据元素的值LocateElem(L,i,e) 初始条件：线性表已存在，用循环遍历整个线性表，如果中的元素相同； 操作结果：用此时的i+1 返回该元素在线性表的位序 ListInsert(&L,i,e) 初始条件：线性表存在，1<=i<=ListLength(L)+1; 操作结果：在L 中第i 个位置之前插入新的数据元素,e,L ListDelete(&L,i,&e) 初始条件: 线性表L 已存在且非空， 1<=i<=ListLength(L) 操作结果：删除L的第i个数据元素，并用e返回其值， 1 }ADT List 3.2 存储结构的定义; typedef char ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LinkList; 3.3 基本操作实现 /* 单链表的初始化*/ 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; e 与线性表的长度加1。L 的长度减
单链表的基本操作实验报告
湖南第一师范学院信息科学与工程系实验报告 课程名称：数据结构与算法成绩评定： 实验项目名称：单链表的基本操作指导教师： 学生姓名：沈丽桃学号： 10403080118 专业班级： 10教育技术 实验项目类型：验证实验地点：科B305 实验时间： 2011 年 10 月20 日一、实验目的与要求： 实验目的：实现线性链表的创建、查找、插入、删除与输出。 基本原理：单链表的基本操作 二、实验环境：（硬件环境、软件环境） 1.硬件环境：奔ⅣPC。 2.软件环境：Windows XP 操作系统，TC2.0或VC＋＋。 三、实验内容：（原理、操作步骤、程序代码等） #include
单链表操作实验报告
线性表 一、实验目的 1. 了解线性表的逻辑结构特征，以及这种特性在计算机内的两种存储结构。 2. 掌握线性表的顺序存储结构的定义及其C语言实现。 3. 掌握线性表的链式村粗结构——单链表的定义及其C语言实现。 4. 掌握线性表在顺序存储结构即顺序表中的各种基本操作。 5. 掌握线性表在链式存储结构——单链表中的各种基本操作。 二、实验要求 1. 认真阅读和掌握本实验的程序。 2. 上机运行本程序。 ) 3. 保存和打印出程序的运行结果，并结合程序进行分析。 4. 按照对顺序表和单链表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果 三、实验内容 请编写C程序，利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。具体地说，就是要根据键盘输入的数据建立一个单链表，并输出该单链表；然后根据屏幕菜单的选择，可以进行数据的插入或删除，并在插入或删除数据后，再输出单链表；然后在屏幕菜单中选择0，即可结束程序的运行。 四、解题思路 本实验要求分别写出在带头结点的单链表中第i（从1开始计数）个位置之后插入元素、创建带头结点的单链表中删除第i个位置的元素、顺序输出单链表的内容等的算法。 五、程序清单 #include<> #include<> #include<> typedef int ElemType; ~ typedef struct LNode { ElemType data; struct LNode *next; }LNode; LNode *L; LNode *creat_L(); void out_L(LNode *L); void insert_L(LNode *L,int i,ElemType e); ElemType delete_L(LNode *L,int i); int locat_L(LNode *L,ElemType e); $
线性表实验报告
一．实验名称 1.线性表基本操作； 2.处理约瑟夫环问题 二．试验目的： 1．熟悉C语言的上机环境，掌握C语言的基本结构。 2．定义单链表的结点类型。 3．熟悉对单链表的一些基本操作和具体的函数定义。 4．通过单链表的定义掌握线性表的链式存储结构的特点。 5．熟悉对单链表的一些其它操作。 三．实验内容 1.编制一个演示单链表初始化、建立、遍历、求长度、查询、插入、删除等操作的程序。 2.编制一个能求解除约瑟夫环问题答案的程序。 实验一线性表表的基本操作问题描述： 1. 实现单链表的定义和基本操作。该程序包括单链表结构类型以及对单链表操作 的具体的函数定义 程序中的单链表（带头结点）结点为结构类型，结点值为整型。 /* 定义DataType为int类型*/ typedef int DataType; /* 单链表的结点类型*/ typedef struct LNode {DataType data; struct LNode *next; }LNode,*LinkedList; LinkedList LinkedListInit() //初始化单链表 void LinkedListClear(LinkedList L) //清空单链表 int LinkedListEmpty(LinkedList L)//检查单链表是否为空 void LinkedListTraverse(LinkedList L)//遍历单链表 int LinkedListLength(LinkedList L)//求单链表的长度 /* 从单链表表中查找元素*/ LinkedList LinkedListGet(LinkedList L,int i) /* 从单链表表中查找与给定元素值相同的元素在链表中的位置*/ int LinkedListLocate(LinkedList L, DataType x) void LinkedListInsert(LinkedList L,int i,DataType x) //向单链表中插入元素 /* 从单链表中删除元素*/ void LinkedListDel(LinkedList L,DataType x)