实验1-2顺序表和链表基本操作_参考答案
数据结构实验答案
# include
# define maxnum 20
typedef int DataType ;
typedef struct
{ DataType data[maxnum] ;
int length ;
}SeqList ;
int MergeQL(SeqList la , SeqList lb , SeqList *lc)
实验一 线性表的顺序存储实验
一,实验目的
1,掌握用Visual C++6.0上机调试顺序表的基本方法
2,掌握顺序表的基本操作,插入,删除,查找,以及有序顺序表的合并等算法的实现
二,实验内容
1,顺序表基本操作的实现
[问题描述] 当我们要在顺序表的第i个位置上插入一个元素时,必须先将顺序表中第i个元素之后的所有元素依次后移一个位置,以便腾空一个位置,再把新元素插入到该位置.若是欲删除第i个元素时,也必须把第i个元素之后的所有元素前移一个位置.
ListNode *s,*r; /*工作指针*/
r=head; /*尾指针初值也指向头结点*/
while((ch=getchar())!='\n')
{
s=(ListNode *)malloc(sizeof(ListNode));
s->data=ch;
r->next=s;
r=s;
}
(*L)->next=NULL;
}
int List_Length(ListNode *L )
{
int n=0;ListNode *p=L->next;
while(p!=NULL)
实验1 顺序表基本操作
实验1 顺序表基本操作【实验目的】<1>熟悉C语言的上机环境,掌握C语言的基本结构<2>会定义线性表的顺序存储结构<3>熟悉对顺序表的一些基本操作<4>熟悉与线性表相关的函数的定义和使用【实验内容】[实验任务一]顺序表的基本操作1.顺序表的插入操作【操作步骤】<1>启动辅助教学软件<2>选择“C语言”<3>选择“顺序表”<4>选择“顺序表插入”<5>输入建立表的数据<6>输入插入数据元素<7>输入插入位置<8>选择单步执行2.顺序表的删除操作【操作步骤】<1>启动辅助教学软件<2>选择“C语言”<3>选择“顺序表”<4>选择“顺序表插入”<5>输入建立表的数据<6>输入删除位置<7>选择单步执行[实验任务二]编写C语言程序1. 编程实现顺序表的插入操作。
2.编程实现顺序表的删除操作。
实验2 链表的基本操作【实验目的】<1>学会定义单链表的结点类型<2>熟悉单链表的一些基本操作,依据这些操作函数定义<3>掌握线性表的链式存储结构的特点<4>掌握循环链表和双向链表的定义、构造方法等。
【实验内容】[实验任务一]验证单链表的基本操作<1>单链表的插入操作<2>单链表的删除操作[实验任务二]编写C语言程序<1>用C语言实现构造单链表<2>用C语言实现输出单链表实验3 二叉树的基本操作【实验目的】<1>熟悉二叉树的结点结构<2>熟悉二叉树的基本操作<3>学会利用递归方法编写二叉树的遍历算法【实验内容】[实验任务一]二叉树的遍历<1>先序遍历<2>中序遍历<3>后续遍历[实验任务二]编写算法<1>根据二叉树的任一遍历算法,编写求二叉树中结点个数的算法。
链表基本操作实验报告
实验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流程图。
六、C语言版原代码# include<stdio.h># include<stdlib.h>/* 定义ElemType 为int类型*/typedef int ElemType;# define TRUE 1# define FALSE 0# define NULL 0# define flag -1/*单链表的结点类型*/typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){LinkedList L;L=(LinkedList)malloc(sizeof(LNode));L->next=NULL;return L;}/*清空单链表*/void LinkedListClear(LinkedList L){L->next=NULL;printf("链表已经清空\n");}/*检查单链表是否为空*/int LinkedListEmpty(LinkedList L){if(L->next==NULL) return TRUE;else return FALSE;}/*遍历单链表*/void LinkedListTraverse(LinkedList L) {LinkedList p;p=L->next;if(p==NULL) printf("单链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data); p=p->next;}}printf("\n");}int LinkedListLength (LinkedList L){LinkedList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}LinkedList LinkedListGet(LinkedList L,int i) {LinkedList p;int j;p=L->next;j=1;while(p!=NULL&&j<i){p=p->next;j++;}if(j==i) return p;else return NULL;}int LinkedListLocate(LinkedList L,ElemType x) {LinkedList p;int j;p=L->next;j=1;while(p!=NULL&&p->data!=x){p=p->next;j++;}if(p) return j;else return 0;}void LinkedListInsert(LinkedList L,int i,ElemType x) {LinkedList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else{s=(LNode *)malloc(sizeof(LNode));s->data=x;s->next=p->next;p->next=s;printf("%d 已插入到链表中\n",x);}}void LinkedListDel(LinkedList L,int i) {LinkedList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d 个元素已从链表中删除\n",i);}}LinkedList LinkedListCreat(){LinkedList L=LinkedListInit(),p,r;ElemType x;r=L;printf("请依次输入链表中的元素,输入-1结束\n"); scanf("%d",&x);while(x!=flag){p=(LinkedList)malloc(sizeof(LNode));p->data=x;r->next=p;r=p;scanf("%d",&x);}r->next=NULL;return L;}int scan(){int d;printf("请选择要进行的操作\n");printf("-------------------------------------------------------\n"); printf("1.初始化 2.清空 3.求链表长度 4.检查链表是否为空\n"); printf("-------------------------------------------------------\n"); printf("5.遍历链表 6.从链表中查找元素\n");printf("-------------------------------------------------------\n"); printf("7.从链表中查找与给定元素值相同的元素在顺序表中的位置\n"); printf("-------------------------------------------------------\n"); printf("8.向链表中插入元素 9.从链表中删除元素 10创建线性表\n"); printf("-------------------------------------------------------\n"); printf("其他键退出。
实验二 链表的基本操作
实验二链表的基本操作链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表的基本操作包括插入、删除和查找节点,这些操作在实际编程中非常常见且重要。
我们来看链表的插入操作。
链表的插入操作可以将新节点插入到链表的任意位置,包括链表的头部、尾部或者中间位置。
插入操作的具体步骤如下:1. 创建一个新节点,并为新节点赋值。
2. 将新节点的指针指向原链表中要插入位置的前一个节点。
3. 将原链表中要插入位置的前一个节点的指针指向新节点。
4. 将新节点的指针指向原链表中要插入位置的后一个节点。
接下来是链表的删除操作。
链表的删除操作可以删除链表中的任意节点,包括链表的头部、尾部或者中间位置。
删除操作的具体步骤如下:1. 找到要删除的节点的前一个节点。
2. 将要删除的节点的前一个节点的指针指向要删除的节点的下一个节点。
3. 释放要删除的节点的内存空间。
最后是链表的查找操作。
链表的查找操作可以根据节点的值或者位置来查找节点。
查找操作的具体步骤如下:1. 遍历链表,依次比较节点的值或者位置,直到找到目标节点。
2. 返回目标节点的值或者位置。
除了基本的插入、删除和查找操作,链表还有一些其他的操作,如获取链表的长度、反转链表等。
获取链表的长度可以通过遍历链表并计数节点的数量来实现。
反转链表可以通过修改节点的指针的指向来实现,具体步骤如下:1. 遍历链表,依次修改每个节点的指针的指向,将指针指向上一个节点。
2. 最后将头节点的指针指向空。
链表的基本操作在实际编程中非常常见且重要。
它们可以用于实现各种功能和算法,如链表的排序、合并两个链表等。
在使用链表的过程中,我们需要注意链表为空或者操作位置无效的情况,以避免出现错误。
链表是一种常见的数据结构,具有灵活性和高效性。
了解链表的基本操作对于编程非常重要,它们可以帮助我们实现各种功能和算法。
通过学习和掌握链表的基本操作,我们可以更好地应用链表来解决实际问题。
第二章 顺序表、链表(答案)
A. 单链表
B. 静态链表
C.单循环链表 D. 顺序表
8. 在一个长度为 n(n>1)的单元链表上,设有头和尾两个指针,执行( B )操作与链表的长度有关.
A. 删除单链表中的第一个元素
B. 删除单链表中的最后一个元素
C. 在单链表第一个元素前插入一个新元素 D. 在单链表最后一个元素后插入一个新元素
6、向一个长度为 n 的向量的第 i 个元素(1≤i≤n+1)之前插入一个元素时,需向后移动 n-i+指向双向循环链表中的结点 X,则删除结点 X 需要执行的语句序列为
_______p->llink->rlink=p->rlink
________p->rlink->llink=p->llink______________________________________________________
11. 在 n 个结点的顺序表中,算法的时间复杂度是 O(1)的操作是:( A )
A. 访问第 i 个结点(1≤i≤n)和求第 i 个结点的直接前驱(2≤i≤n)
B. 在第 i 个结点后插入一个新结点(1≤i≤n)
C. 删除第 i 个结点(1≤i≤n)
D. 将 n 个结点从小到大排序
12. 向一个有 127 个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移动(
D.p->next->prior=p.
1、算法是指令的有限序列,其中每一条指令表示一个或多个操作,此外,一个算法还具有五个重要
特性,它们分别是 ___有穷性____ 、__确定性____ 、__可行性______ 、有零或多个输入和有一 或多个输出。
2、算法优劣的五个标准是正确性、可使用性、__可读性____、_健壮性_____、_高效性____。
数据结构实验一答案
线性表是典型的线性结构,实现ADT List,并在此基础上实现两个集合的交运算或并运算。
[实验目的]
(1)掌握线性表的两种存储结构,即顺序表和链表。
(2)掌握在顺序表和单链表上基本操作的实现。
(3)在掌握顺序表和单链表的基本操作上进行综合题的实现。
[实验内容及要求]
void print();
ListNode *getNode( double &item,ListNode *next);
void Union(List &LA,List &LB); //取并集
void intersection(List &LA,List &LB); //取交集
x=LB.Next();
}
cout<<"取并集后的集合:"<<endl;
list.print(); } void List::intersection(List &LA,List &LB)
{ //取交集
double x=LA.First();
while(x!=NULL)
while(1)
{ cout<<"Please input a number (input 999 to quit) :"<<endl;
cin>>a;
if(a==999) break;
list1.append(a);
}
public :
List(){ first=current=new ListNode;}
~List(){ MakeEmpty(); delete first;}
实验一 顺序表和单链表的基本操作的实现
实验一顺序表和单链表的基本操作的实现一、顺序表实验内容:1.编写函数,通过数组,建立一个顺序表。
2.编写函数,实现对该顺序表的遍历。
3.编写函数,在顺序表中进行顺序查找某一元素,查找成功则返回其存储位置i,否则返回错误信息。
4.编写函数,实现在顺序表的第i个位置上插入一个元素e的算法。
5.编写函数,实现删除顺序表中第i个元素的算法。
6.编写函数,实现输入一个元素data,把它插入到有序表中,使顺序表依然有序。
7.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法。
实验目的及要求:1.掌握顺序表的存储结构形式及其描述2.掌握顺序表的建立、查找、插入和删除操作。
实验程序:#include <stdio.h>#include <stdlib.h>#define M 100 //最大限void creat_list(int a[], int n); //建立顺序表void datafind_list(int a[],int d); //按值查找元素void find_list(int a[],int i); //按位查找元素void in(int a[], int i,int e); //插入接点void delet(int a[], int i); //删除接点void print_list(int a[] ); //打印顺序表int main(){int a[M];int data;int num;int place; int ch;printf("输入数据个数:");scanf("%d",&num);creat_list(a, num);print_list(a);while(1){printf("请选择操作:\n");printf("***************************************************************\n") ;printf("1.按值查找 2.按位查找 3.插入接点 4.删除接点 \n");printf("***************************************************************\n") ;scanf("%d",&ch);switch(ch){case 1:printf("Pleae enter the data you want to find:\n"); //按值查找scanf("%d",&data);datafind_list(a,data);break;case 2:printf("Pleae enter where you want to find:\n"); //按位查找scanf("%d",&place);printf("The place is :%d\n",place);find_list(a, place);break;case 3:printf("Pleae enter where you want to insert:\n"); //插入接点scanf("%d",&place);printf("input a data what you want to insert");scanf("%d",&data);in(a,place,data);print_list(a); break;case 4:printf("Pleae enter where you want to delet:\n"); //删除接点scanf("%d",&place);printf("The place is :%d\n",place);printf("Pleae enter where you want to delet:\n");scanf("%d",&place);printf("The place is :%d\n",place);delet(a, place);print_list(a);break;default: printf("输入错误,请重新选择");break;}}return 0;}void creat_list(int a[], int n) //建立顺序表{ int i;int j;int x;printf("输入数据:");scanf("%d",&a[1]);for (i = 2; i <= n; i++){ scanf("%d",&x);for (j = 1; j <= i - 1; j++){ if (x == a[j]){break;} }if (j > i - 1){a[i] = x;}elsei--;}a[0] = n;}void datafind_list(int a[],int d) //按值查找元素{ int i;int j=0;for(i=1;i<=a[0];i++){if(d==a[i])printf("the data is %d and its place is %d\n",d,i);else j++;}if (j==a[0]){printf("error\n");}}void find_list(int a[],int i) //按位查找{if (i < 1 || i > a[0] + 1){printf("error");}else printf("%5d",a[i]);}void in(int a[], int i,int e) //插入表中某个元素{ int j;if (i < 1 || i > a[0] + 1){printf("error");}else{ a[0] = a[0] + 1;for (j = a[0]; j >i; j--) //后移插入位置后的数{a[j] = a[j-1];}a[i]=e;}}void delet(int a[], int i) //删除表中某个元素{ int j;if (i < 1 || i > a[0] + 1){printf("error");exit(0);}for (j = i + 1; j <= a[0]; j++) //前移被删数的位置 {a[j - 1] = a[j];}a[0] = a[0] - 1;}void print_list(int a[] ) //打印顺序表{ int i;printf("\n");printf("顺序表是:");for (i = 1; i <= a[0]; i++){printf("%5d",a[i]);}printf("\n");}实验结果:实验分析:实验成功实现顺序表的基本操作!成功完成本实验,需要掌握顺序表的结构和理解顺序表结构的实验原理。
数据结构-实验2-链表的基本操作
实验2链表的基本操作一、需求分析1,初始化链表2,调用插入函数建立一个链表3,链表的插入和删除4,链表元素的查找4,将链表分为奇链表和偶链表5,链表的逆置二、概要设计1.基础题1)编写链表基本操作函数typedefstruct list{Int data;Struct list* next}LIST;LIST* InitList() //初始化LIST* InsertList(LIST * L,int item,int re) //向链表指定位置插入元素LIST* InsertOrderList(LIST *L,int item) //向有序链表指定位置插入元素void FindList(LIST*L, int item)//查找链表中的元素void display(LIST *L)//显示链表void divide(LIST* La, LIST *Lb)//拆分链表LIST * turn(LIST *L)//转置链表2)调用上述函数实现下列操作,操作步骤如下。
A.初始化链表B.调用插入函数建立一个链表C.在链表中寻找指定的元素D.在链表中删除指定值的元素E.遍历并输出链表注意每完成一个步骤,必须及时输出顺序表元素,便于观察操作结果2.提高题a)将一个首结点指针为a的单链表A分解成两个单链表A和B,其首结点指针分别为a,b,使得链表A中含有原链表A中序号为奇数的元素,而链表B中含有原链表A中序号为偶数的元素,且保持原来的相对顺序。
解题思路将单链表A中含有序号为偶数的元素删除,并在删除时把这些结点链接起来构成单链表B即可。
b)将链接存储线性表逆置,即最后一个结点变成第一个结点原来倒数第二个结点变成第二个结点,如此等等。
解题思路依次遍历源链表,将每个元素依次赋给一个新链表并将新链表从后到前连接。
3.主函数void main(){LIST *L1,*L2,*L3;int i;L1=InitList();printf("创建链表L1:\n");for(i=1;i<=5;i++){L1=InsertList(L1,i*2,i);}display(L1);for(i=1;i<=9;i+=4){printf("在L1的%d位置插入3:\n",i);L1=InsertList(L1,3,i);display(L1);}//有序表L2 = InitList();printf("\n有序表实验:\n");printf("创建链表L2:\n");for (i = 1; i <= 5; i++){L2 = InsertList(L2, i * 2, i); }display(L2);for (i = 1; i <= 13; i +=6 ){printf("插入%d:\n",i);L2 = InsertOrderList(L2,i);display(L2);}//删除元素实验printf("\n删除元素实验:\n"); printf("L2插入1:\n", i);L2 = InsertList(L2,1,1);display(L2);for (i = 1; i < 12; i += 5){printf("删除L2中%d\n",i);L2 = DeleteList(L2, i);display(L2);}//查找printf("\n查找元素实验:\n"); printf("查找L2中%d\n", 13); FindList(L2,13);printf("查找L2中%d\n", 6); FindList(L2, 6);//分解printf("\n分解实验:\n");printf("L2:\n");display(L2);L3 = InitList();printf("将L2偶序数拆分到L3\n"); divide(L2,L3);printf("L2:\n");display(L2);printf("L3:\n");display(L3);printf("\n逆序实验:\n");printf("L2:\n");display(L2);L2 = turn(L2);printf("转置L2:\n");display(L2);}三、详细分析插入实验,函数能够在链表前、中、后插入元素,并判断插入位置是否超过链表长度,若超过则接入链尾。
实验一顺序表与链表(数据结构)
实验一顺序表与链表
姓名:学号:实验日期:
教师评语:
一、实验目的
1、掌握线性表中元素的前驱、后继的概念。
2、掌握顺序表与链表的建立、插入元素、删除表中某元素的算法。
3、对线性表相应算法的时间复杂度进行分析。
4、理解顺序表、链表数据结构的特点(优缺点)。
二、实验内容和要求
1、试写一个算法,实现顺序表的就地逆置,即利用原表的存储空间将线性表(a1,a2,…,a n)逆置为(a n,a n-1,…,a1)。
2、假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合(即同一表中的元素值各个不相同),现要求另开辟空间构成一个线性表C,其元素为A和B中元素的交集,且表C中的元素也依值递增有序排列。
试用单链表编写求C的算法。
3、假设某个单向循环链表的长度大于1,且表中既无头结点也无头指针。
已知s 为指向链表中某个结点的指针,试编写算法在链表中删除指针s所指结点的前驱结点。
三、实验小结
1。
数据结构--实验报告 线性表的基本操作
一、实验目的二、实验内容和要求三、源代码1)顺序表的代码2)单链表的代码四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现。
4、掌握顺序表的存储结构形式及其描述和基本运算的实现。
5、熟练掌握动态链表结构及有关算法的设计二、实验内容题目一:顺序表的基本操作[问题描述]实现顺序表的建立、求长度,取元素、修改元素、插入、删除等顺序表的基本操作。
[基本要求](1)依次从键盘读入数据,建立带头结点的顺序表;(2)输出顺序表中的数据元素(3)求顺序表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法,将两个有序的顺序表合并成一个有序顺序表。
[测试数据] 由学生任意指定。
题目二:单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求](1)依次从键盘读入数据,建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法,将两个有序的单链表合并成一个有序单链表。
[测试数据]由学生任意指定。
三、源代码(一)顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}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);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++)L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q;if(i<1 || i>L.length) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p) *(p-1)=*p;--L.length;return OK;}Status Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度:";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度:"; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度:"; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下:"; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break; case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误,请重新选择"<<endl;break; }}}(二)单链表的基本操作#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在 e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点 if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点,并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) { //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个):"<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个):"<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);default : cout<<"输入有误,请重新输入"<<endl;break;}}}四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时,我有点惊讶,才学了不到一个月,就要写实验报告。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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、报告内容包括实验目的、实验内容、程序清单和实验结果等。
要求书写文字整齐简洁。
5、实验过程中要注意人身和设备安全,遇到事故或出现异常现象,应立即切断电源,保持现场并报告指导教师处理。
二、实验报告要求、实验考核方式、内容及成绩评定标准实验报告要求内容清晰完整,写出实验结果。
实验考核方式依据实验报告完成情况和实验上机情况综合考核。
根据实验报告和实验课出席情况给出实验成绩,满分10分。
三、实验教材及参考书《数据结构》严蔚敏清华大学出版社 2005实验一熟悉开发环境和抽象数据类型一.实验目的1.熟悉VC软件开发环境。
2.熟悉抽象数据类型的定义与应用。
二.实验内容1.在VC下编写程序,实现求出从键盘输入的两个数的最大值。
例如,从键盘输入a=4,b=5。
得出结果c = 52.在VC下编写程序,实现求出两个复数的和。
定义复数的数据类型,复数由实部和虚部构成。
复数的和是两个复数的实部和虚部分别求和得出。
其中的两个复数分别从键盘输入,例如,输入3, 4表示复数Z1:3+4i; 输入1, 2表示复数Z2:1+2i。
实验1-2顺序表和链表基本操作_参考答案
实验1、2:线性表的应用参考代码一、实验预备知识1.复习C中编写函数的相关内容。
2.复习如何用主函数将多个函数连在一起构成一个C完整程序。
二、实验目的1.掌握线性表的顺序和链式存储结构2.熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3.熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1.编写初始化并创建线性表和输出线性表的算法。
2.编写对线性表插入和删除运算算法,要判断位置的合法性和溢出问题。
3.编写有序表的插入和删除运算算法。
4.编写一个主函数,将上面函数连在一起,构成一个完整的程序。
5.将实验源程序调试并运行,写出输入、输出结果,并对结果进行分析。
四、实验内容顺序表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。
2.初始化并建立顺序表。
(开辟的存储空间大小为8)3.编写顺序表输出算法。
4.依次插入3、21、15、99四个数,分别插入在第1、8、4和12位置,每插入一次都要输出一次顺序表。
5.删除第1,第9和第12个位置上的元素,每删除一个元素都要输出一次顺序表。
6.编写一个排序算法,对线性表中元素从小到大排列。
7.向有序表分别插入20和50,插入后表仍然有序。
(修改开辟的存储空间大小为15)单链表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。
2.建立一个带表头结点的单链表(前插入法和尾插入法均可)。
3.编写单链表输出算法。
4.依次插入3、21、15、99四个数,分别插入在第1、8、4和12位置,每插入一次都要输出一次单链表。
5.删除第1,第9和第12个位置上的元素,每删除一个元素都要输出一次单链表。
6.编写一个排序算法,对链表中元素从小到大排列。
7.向有序链表分别插入20和50,插入后表仍然有序。
五、实验结果顺序表源程序:#include <iostream>using namespace std;const int MAXSIZE=8; //做有序表插入操作时,将8改为15typedef int DataType;typedef struct{DataType data[MAXSIZE];int length;}SeqList;void Init_SeqList(SeqList &L);//创建空顺序表算法void Show_SeqList(SeqList L);//顺序表输出算法void Create_SeqList(SeqList &L);//顺序表创建算法int Insert_SeqList(SeqList &L,DataType x,int i);//顺序表的插入算法int Delete_SeqList(SeqList &L,int i);//顺序表的删除算法int Locate_SeqList(SeqList L,DataType x);//顺序表的按值查找算法void Sort_SeqList(SeqList &L);//顺序表的排序算法int Insert_SeqList_sort(SeqList &L,DataType x);//有序表的插入算法void Merge(SeqList LA,SeqList LB,SeqList &LC);//两个有序顺序表的合并算法void menu(); //菜单算法void main(){ menu(); }void menu()//菜单算法{SeqList L;Init_SeqList(L);int m;while(1){cout<<"\n根据所做操作选择以下数字序号:"<<endl;cout<<"1:创建顺序表 2:执行插入操作 3:执行删除操作"<<endl;cout<<"4:执行输出操作 5:执行查找操作 6:执行排序操作"<<endl;cout<<"7:执行有序表的插入操作 8:执行有序表的合并操作 0:退出"<<endl;int n,i,x;cin>>n;switch (n){case 1:{Create_SeqList(L);break;}case 2:{cout<<"请输入插入位置:";cin>>i;cout<<endl<<"请输入插入元素值:";cin>>x;cout<<endl;m=Insert_SeqList(L,x,i);if (m==1)cout<<"插入操作成功!"<<endl;elseif (m==0)cout<<"插入位置不合法!"<<endl;elsecout<<"发生溢出!"<<endl;break;}case 3:{cout<<"请输入删除位置:";cin>>i;cout<<endl;m=Delete_SeqList(L,i);if (m==1)cout<<"删除操作成功!"<<endl;elseif (m==0)cout<<"删除位置不合法!"<<endl;elsecout<<"空表!"<<endl;break;}case 4:{Show_SeqList(L);break;}case 5:{cout<<"请输入所要查找的元素值:";cin>>x;cout<<endl;m=Locate_SeqList(L,x);if (m==0)cout<<"所查找元素不在顺序表中!"<<endl;elsecout<<"所查找元素是顺序表的第"<<m<<"个元素!"<<endl;break;}case 6:{Sort_SeqList(L);cout<<"排序操作完成!"<<endl;break;}case 7:{cout<<endl<<"请输入插入元素值:";cin>>x;cout<<endl;m=Insert_SeqList_sort(L,x);if (m==1)cout<<"插入操作成功!"<<endl;elsecout<<"发生溢出!"<<endl;break;}case 8:{SeqList L1,L2,L3;Init_SeqList(L1);Init_SeqList(L2);Init_SeqList(L3);cout<<"创建有序表1:"<<endl;Create_SeqList(L1);Sort_SeqList(L1);cout<<"创建有序表2:"<<endl;Create_SeqList(L2);Sort_SeqList(L2);cout<<"有序表1:"<<endl;Show_SeqList(L1);cout<<"有序表2:"<<endl;Show_SeqList(L2);Merge(L1,L2,L3);cout<<"合并后:"<<endl;Show_SeqList(L3);break;}case 0:return;}}}void Init_SeqList(SeqList &L)//创建空顺序表算法{=0;}void Show_SeqList(SeqList L)//顺序表输出算法{if==0)cout<<"空表!"<<endl;elsefor(int i=0;i<;i++)cout<<[i]<<" ";cout<<endl;}void Create_SeqList(SeqList &L)//顺序表创建算法{cout<<"请输入元素个数:";cin>>;cout<<"依次输入各个元素的值:"<<endl;for(int i=0;i<;i++)cin>>[i];}int Insert_SeqList(SeqList &L,DataType x,int i)//顺序表的插入算法{if(MAXSIZE<=return -1;if(i<1||i>+1)return 0;for(int j=;j>=i-1;j--)[j+1]=[j];[i-1]=x;++;return 1;}int Delete_SeqList(SeqList &L,int i)//顺序表的删除算法{if ==0)return -1;if(i<1||i>return 0;for(int j=i;j<;j++)[j-1]=[j];;return 1;}int Locate_SeqList(SeqList L,DataType x)//顺序表的按值查找算法{int i=0;while(i<&&[i]!=x)i++;if(i< )return i+1;elsereturn 0;}void Sort_SeqList(SeqList &L) //排序算法{int i,k,j;DataType temp;for(i=0;i<;i++){k=i;for(j=i+1;j<= -1;j++)if [j]< [k])k=j;if(i!=k){temp= [i];[i]= [k];[k]=temp;}}}int Insert_SeqList_sort(SeqList &L,DataType x)//有序表的插入算法{if(MAXSIZE<=return -1;int i=0;while(i<&&[i]<x)i++;for(int j=;j>=i;j--)[j+1]=[j];[i]=x;++;return 1;}void Merge(SeqList LA,SeqList LB,SeqList &LC)//两个有序顺序表的合并算法{int i,j,k;i=j=k=0;while(i<&&j<{if[i]<[j]){[k]=[i];i++;k++;}else{[k]=[j];j++;k++;}}while(i<{[k]=[i];i++;k++;}while(j<{[k]=[j];j++;k++;}=k;}输入输出结果:图1-1主菜单图1-2顺序表的创建和输出操作图1-3 顺序表的插入操作图1-4顺序表的删除操作图1-5顺序表的排序操作图1-6有序表的插入操作图1-7两个有序表的合并操作单链表的源程序:#include "iostream"using namespace std;typedef int DataType;typedef struct node{DataType data;struct node *next;}LNode,*LinkList;void Init_LinkList(LinkList &L);//创建空单链表void Create1LinkList(LinkList &L,int n);//前插入法创建单链表的算法void Create2LinkList(LinkList &L,int n);//后插入法创建单链表的算法void PrintLinkList(LinkList L);//单链表的输出算法int InsertLinkList(LinkList &L,int i,DataType x);//单链表的插入算法int DeleteLinkList(LinkList &L,int i);//单链表的删除算法void Select_Sort_LinkList(LinkList &L);//链表的排序算法(选择排序)void Insert2(LinkList L,DataType x);//有序表的插入void Merge(LinkList L1,LinkList L2,LinkList &L3);//两个有序表的合并算法void menu();//菜单函数int main(){menu();return 0;}void Init_LinkList(LinkList &L)//创建空单链表{L=new LNode;L->next=NULL;}void Create1LinkList(LinkList &L,int n)//前插入法创建单链表的算法{LNode *s;for(int i=1;i<=n;i++){s=new LNode;cout<<"请输入第"<<i<<"个元素的值:";cin>>s->data;s->next=L->next;L->next=s;}}void Create2LinkList(LinkList &L,int n)//后插入法创建单链表的算法{LNode *s,*r=L;for(int i=1;i<=n;i++){s=new LNode;cout<<"请输入第"<<i<<"个元素的值:";cin>>s->data;r->next=s;r=s;}r->next=NULL;}void PrintLinkList(LinkList L)//单链表的输出算法{if(L->next==NULL){cout<<"空表!"<<endl;return;}cout<<"当前单链表为:"<<endl;LNode *p=L->next;while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;}int InsertLinkList(LinkList &L,int i,DataType x)//单链表的插入算法{int j=0;LNode *p=L,*s;while(p&&j<i-1){p=p->next;j++;}if(!p||j>i-1)return 0;s=new LNode;s->data=x;s->next =p->next ;p->next =s;return 1;}int DeleteLinkList(LinkList &L,int i)//单链表的删除算法{if(L->next ==NULL)return -1;int j=0;LNode *p=L,*q;while((p->next !=NULL)&&(j<i-1)){p=p->next ;j++;}if((p->next==NULL)||(j>i-1))return 0;q=p->next ;p->next =q->next ;delete q;return 1;}void Select_Sort_LinkList(LinkList &L)//链表的排序算法(选择排序){if(L->next ==NULL){cout<<"空表,不需要排序!"<<endl;return;}LNode *p,*q,*s;DataType temp;if(L->next==NULL) return;for(p=L->next;p->next!=NULL;p=p->next){s=p;for(q=p->next;q!=NULL;q=q->next){if(q->data<s->data)s=q;}if(s!=p){temp=s->data; s->data=p->data; p->data=temp;}}cout<<"排序成功!"<<endl;}void Insert2(LinkList L,DataType x)//有序表的插入{LNode *p=L,*s;while(p->next!=NULL&&p->next->data<x)p=p->next;s=new LNode;s->data=x;s->next=p->next;p->next=s;cout<<"插入操作成功!"<<endl;}void Merge(LinkList L1,LinkList L2,LinkList &L3)//两个有序表的合并算法{LNode *p1,*p2,*p3,*s;p1=L1->next ;p2=L2->next ;L3=p3=new LNode;L3->next =NULL;while(p1&&p2){s=new LNode;if(p1->data <p2->data ){s->data =p1->data ;p1=p1->next ;}else{s->data =p2->data ;p2=p2->next ;}p3->next =s;p3=s;}if(p1)p3->next =p1;if(p2)p3->next =p2;}void menu()//菜单函数{LinkList L;Init_LinkList(L);int m;while(1){cout<<"\n根据所做操作选择以下数字序号:"<<endl;cout<<"1:前插入创建单链表 2:尾插入创建单链表 3:执行插入操作"<<endl;cout<<"4:执行删除操作 5:执行输出操作 6:执行排序操作"<<endl;cout<<"7:执行有序表的插入操作 8:执行有序表的合并操作 0:退出"<<endl;int n,i,x;cin>>n;switch (n){case 1:{cout<<"请输入结点个数:";cin>>i;Create1LinkList(L,i);PrintLinkList(L);break;}case 2:{cout<<"请输入结点个数:";cin>>i;Create2LinkList(L,i);PrintLinkList(L);break;}case 3:{cout<<"请输入插入位置:";cin>>i;cout<<endl<<"请输入插入元素值:";cin>>x;cout<<endl;if (InsertLinkList(L,i,x)==1)cout<<"插入操作成功!"<<endl;elsecout<<"插入位置不合法!"<<endl;break;}case 4:{cout<<"请输入删除位置:";cin>>i;cout<<endl;m=DeleteLinkList(L,i);if (m==1)cout<<"删除操作成功!"<<endl;elseif(m==-1)cout<<"空表!"<<endl;elsecout<<"删除位置不合法!"<<endl;break;}case 5:{PrintLinkList(L);break;}case 6:{Select_Sort_LinkList(L);break;}case 7:{cout<<endl<<"请输入插入元素值:";cin>>x;cout<<endl;Insert2(L,x);break;}case 8:{LinkList L1,L2,L3;Init_LinkList(L1);Init_LinkList(L2);Init_LinkList(L3);cout<<"创建有序表1:"<<endl;cout<<"请输入结点个数:";cin>>i;Create2LinkList(L1,i);Select_Sort_LinkList(L1);cout<<"创建有序表2:"<<endl;cout<<"请输入结点个数:";cin>>i;Create2LinkList(L2,i);Select_Sort_LinkList(L2);cout<<"有序表1:"<<endl;PrintLinkList(L1);cout<<"有序表2:"<<endl;PrintLinkList(L2);Merge(L1,L2,L3);cout<<"合并后:"<<endl;PrintLinkList(L3);break;}case 0:return;}}}输入输出结果:图2-1主菜单图2-2创建单链表(用头插入法)图2-3创建单链表(用尾插入法)图2-4单链表的插入操作图2-5单链表的插入操作(插入位置不合法情况)图2-6单链表的删除操作图2-7单链表的删除操作(删除位置不合法情况)图2-8单链表的排序操作图2-9有序表的插入操作图2-10两个有序表的合并操作建议:代码较长,为了方便阅读和调试,可写成多文件结构!。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
实验1:顺序表的基本操作实验2:单链表的基本操作实验3:查找实验4:排序实验1代码及结果:#include <iostream>using namespace std;template <class T>class sq_LList{private:int mm;int nn;T *v;public:sq_LList(){mm=0;nn=0;return;}sq_LList(int);void prt_sq_LList();int flag_sq_LList();void ins_sq_LList(int,T);void del_sq_LList(int);};//建立空顺序表template <class T>sq_LList<T>::sq_LList(int m){mm=m;v=new T[mm];nn=0;return;}//顺序输出顺序表中的元素与顺序表长度template <class T>void sq_LList<T>::prt_sq_LList(){int i;cout<<"nn="<<nn<<endl;for(i=0;i<nn;i++)cout<<v[i]<<endl; return;}//检测顺序表的状态template <class T>int sq_LList<T>::flag_sq_LList(){if(nn=mn)return(-1);if(nn=0)return(0);return (1);}//在表的指定元素前插入新元素template<class T>void sq_LList<T>::ins_sq_LList(int i,T b){int k;if(nn==mm){cout<<"overflow"<<endl;return;}if(i>nn)i=nn+1;if(i<1)i=1;for(k=nn;k>=i;k--)v[k]=v[k-1];v[i-1]=b;nn=nn+1;return ;}//在顺序表中删除指定元素template<class T>void sq_LList<T>::del_sq_LList(int i){int k;if(nn==0){cout<<"underflow!"<<endl;return;}for(k=i;k<nn;k++)v[k-1]=v[k];nn=nn-1;return ;}int main(){sq_LList<double>s1(100);cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();s1.ins_sq_LList(0,1.5);s1.ins_sq_LList(1,2.5);s1.ins_sq_LList(4,3.5);cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();s1.del_sq_LList(0);s1.del_sq_LList(2);cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();return 0;}运行及结果:实验2代码#include<iostream>#include<iomanip>using namespace std;struct node{float data;node *next;};node *create(){ //建立单链表node *head,*p,*s;head=new node;p=head;p->data=0;p->next=0; //表头创建完成float newnum=0;cin>>newnum;if(newnum<0){cout<<"未输入数据...\n";//输入负数则结束system("pause");}while(newnum>=0 ){ //??如何用字符型作为结束标志s=new node; //创建表中数据s->data=newnum;p->next=s;p=s;cin>>newnum;}p->next=NULL; //最后元素指针return(head); //返回空表头}//插入一个结点x,将成为第i个节点void insertnode(node *head,int i,float x){node *s,*p;int j;s=new node;s->data=x;p=head;j=1; //查找第i个结点,由p指向while(p!=NULL && j<i){j++;p=p->next;}s->next=p->next;p->next=s;}//删除结点xvoid deletenode(node *head,float x){node *p,*s;if(head->next==NULL)cout<<"这是空链表,不能执行删除操作\n"; else{s=head;p=head->next;while(p!=NULL && p->data!=x)if(p->data!=x){s=p;p=p->next;}if(p!=NULL){s->next=p->next;delete(p);}else cout<<"未找到!\n";}}//存取链表某节点Kvoid read(node*head,int k){while(head->next!=0&&k>0){head=head->next;k--;}cout<<"该处数据为"<<head->data<<".\n\n"; }int main( ) {node *linktable=0;int choice=1;cout<<"1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"请输入您的选择:";cin>>choice;while(1){switch (choice){case 0: exit(0);case 1:{cout<<"输入正数数据,并以负数作为结束标记\n";linktable=create();break;}case 2:{cout<<"链表长度为"<<length(linktable)<<",详细信息:\n";printlist(linktable);break;}case 3:{cout<<"要删除的数据为?\n";float del;cin>>del;deletenode(linktable,del);break;}case 4:{if(linktable->next==0)cout<<"链表为空,不能查找\n";else{cout<<"要查找数据为?";float search;cin>>search;find(linktable,search);} break;}case 5:{cout<<"存储数据为?";int des;float it;cin>>it;cout<<"想让该数据存储为第几个节点?";cin>>des;if((des>(length(linktable)+1)||des<1))cout<<"输入错误\n";elseinsertnode(linktable,des,it);break;}case 6:{cout<<"想读取第几个节点?";int c;cin>>c;if(c<1||c>length(linktable))cout<<"位置不合法\n";elseread(linktable,c);break;}default :cout<<"输入错误!\n";}system("pause");system("cls");cout<<"当前信息:\n";printlist(linktable);cout<<"\n1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"继续选择:\n";cin>>choice;}return 0;}实验三查找实验名称:实验3 查找实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序树和哈希表的构造和查找方法。
数据结构实验一(顺序表基本操作)题目和源程序
实验1:顺序表基本操作一、实验目的1.学会定义线性表的顺序存储类型,实现C程序的基本结构,对线性表的一些基本操作和具体的函数定义。
2.掌握顺序表的基本操作,实现顺序表的插入、删除、查找以及求并集等运算。
3.掌握对多函数程序的输入、编辑、调试和运行过程。
二、实验要求1.预习C语言中结构体的定义与基本操作方法。
2.对顺序表的每个基本操作用单独的函数实现。
3.编写完整程序完成下面的实验内容并上机运行。
4.整理并上交实验报告。
三、实验内容:1.编写程序实现顺序表的下列基本操作:(1)初始化顺序表La。
(2)将La置为空表。
(3)销毁La。
(4)在La中插入一个新的元素。
(5)删除La中的某一元素。
(6)在La中查找某元素,若找到,则返回它在La中第一次出现的位置,否则返回0。
(7)打印输出La中的元素值。
2.编写程序完成下面的操作:(1)构造两个顺序线性表La和Lb,其元素都按值非递减顺序排列。
(2)实现归并La和Lb得到新的顺序表Lc,Lc的元素也按值非递减顺序排列。
(3)假设两个顺序线性表La和Lb分别表示两个集合A和B,利用union_Sq操作实现A=A∪B。
四、思考与提高假设两个顺序线性表La和Lb分别表示两个集合A和B,如何实现A=A ∩B ?/*----------------------------------------* 01_顺序表.cpp -- 顺序表基本操作* 对顺序表的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds01.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"#include<iostream>#include<cstdlib>#include<iomanip>#include<ctime>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10using namespace std;typedef struct {double *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量}Sqlist;//构造一个空的线性表Sqlist InitList( Sqlist &L ){L.elem = (double *)malloc(LIST_INIT_SIZE * sizeof(double)) ;if( !L.elem ) exit( -2 ) ; //存储分配失败L.length = 0 ; //空表长度为0L.listsize = LIST_INIT_SIZE ; //初始存储容量return L ;}//给线性表随机赋值void Start( Sqlist &L, int a ){L.length = a ;for( int i = 0; i < a; i++ )L.elem[i] = rand( ) % 100 ;}//输出线性表的值void Output( Sqlist &L ){int m ;m = L.length ;for( int i = 0; i < m; i++ ){if( i % 10 == 0 )cout << endl ;cout << setw(5) << L.elem[i] ;}cout << endl ;}//使线性表按值非递减排列void Notdegression( Sqlist &L, int a ){int m, n ;n = a - 1 ;while( n ){for( int i = 0; i < (a-1); i++ ){if( L.elem[i] > L.elem[i+1] ){m = L.elem[i] ;L.elem[i] = L.elem[i+1] ;L.elem[i+1] = m ;}else continue ;}n-- ;a-- ;}}//归并La和Lb,得到元素也按非递减排列的Lcvoid Merger( Sqlist &La, Sqlist &Lb, Sqlist &Lc ){double *pa, *pb, *pc, *pa_last, *pb_last ;pa = La.elem ; //pa指向La的基地址pb = Lb.elem ; //pb指向Lb的基地址Lc.listsize = Lc.length = La.length + Lb.length ;pc = Lc.elem = (double *)malloc(Lc.listsize * sizeof(double)) ;if( !Lc.elem ) exit( -2 ) ; //存储分配失败pa_last = La.elem + La.length - 1 ; //La表尾元素的位置pb_last = Lb.elem + Lb.length - 1 ; //Lb表尾元素的位置while( pa <= pa_last && pb <= pb_last ) //归并La和Lb于Lc{if( *pa < *pb )*pc++ = *pa++ ;else*pc++ = *pb++ ;}while( pa <= pa_last )*pc++ = *pa++ ; //插入La的剩余元素while( pb <= pb_last )*pc++ = *pb++ ; //插入Lb的剩余元素}//实现A = A ∪Bvoid Union_sq( Sqlist &La, Sqlist &Lb ){double *pa, *pb, *pa_last, *pb_last, *p ;pa = La.elem ; //pa指向La的基地址pb = Lb.elem ; //pb指向Lb的基地址pb_last = Lb.elem + Lb.length - 1 ; //La表尾元素的位置pa_last = La.elem + La.length - 1 ; //Lb表尾元素的位置La.listsize += Lb.listsize ;while( pa < pa_last ) /*除去La中相等的元素,只留下相等元素中的一个*/{if( *pa == *(pa+1) ){p = pa ;for( ++p; p <= pa_last; p++ )*(p-1) = *p ; //被删除元素之后的元素左移La.length-- ;}pa++ ;}pa_last = La.elem + La.length - 1 ;while( pb <= pb_last ) //将Lb的元素插入到La中{while( *pa != *pb && pa <= pa_last )pa++ ; //判断*pb是否与La中的某一元素相等if( pa == (pa_last+1) ){*(pa++) = *pb++ ;La.length++ ; //La的当前长度增一}elsepb++ ;pa = La.elem ;pa_last = La.elem + La.length - 1 ;}}int main( ){Sqlist La; Sqlist Lb; Sqlist Lc ;int a, b ;cout << "请输入La的元素个数:" ;cin >> a ;cout << endl << "请输入Lb的元素个数:" ;cin >> b ;cout << endl ;srand(time(NULL)) ;La = InitList( La ) ; //构造线性表LaLb = InitList( Lb ) ; //构造线性表LbStart( La, a ) ;cout << "La随机生成的值:" << endl ;Output( La ) ;Start( Lb, b ) ;cout << "Lb随机生成的值:" << endl ;Output( Lb ) ;//cin.get();Notdegression( La, a ) ; //使La元素按非递减排列cout << "La的值按非递减顺序排列:" << endl ;Output( La ) ;Notdegression( Lb, b ) ; //使Lb元素按非递减排列cout << "Lb的值按非递减顺序排列:" << endl ;Output( Lb ) ;Merger( La, Lb, Lc ) ; //归并La和Lb于Lccout << "归并La和Lb于Lc,也为非递减排列:" << endl ;Output( Lc ) ;Union_sq( La, Lb ) ; //实现A = A ∪Bcout << "实现A = A ∪B:" << endl ;Output( La ) ;}。
数据结构实验1顺序表_链表
淮海工学院计算机科学系实验报告书课程名:《数据结构》题目:线性表数据结构试验班级:软件112学号:姓名:线性表实验报告要求1目的与要求:1)掌握线性表数据结构的基本概念和抽象数据类型描述;2)熟练掌握线性表数据结构的顺序和链式存储存表示;3)熟练掌握线性表顺序存储结构的基本操作算法实现;4)熟练掌握线性表的链式存储结构的基本操作算法实现;5)掌握线性表在实际问题中的应用和基本编程技巧;6)按照实验题目要求独立正确地完成实验内容(提交程序清单及相关实验数据与运行结果);7)按照报告格式和内容要求,认真书写实验报告,并在试验后的第三天提交电子(全班同学提交到学委,再统一打包提交给老师)和纸质(每班每次5份,学委安排,保证每个同学至少提交一次);8)积极开展实验组组内交流和辅导,严禁复制和剽窃他人实验成果,一旦发现严肃处理;9)上实验课前,要求每个同学基本写好程序,并存储在自己的U盘上,用于实验课堂操作时调试和运行。
凡不做准备,没有提前编写程序者,拒绝上机试验。
2实验内容或题目一、顺序表的基本操作实现实验要求:数据元素类型ElemType取整型int。
按照顺序存储结构实现如下算法:1)创建任意整数线性表(即线性表的元素值随机在键盘上输入)的顺序存储结构(即顺序表),长度限定在25之内;2)打印/显示(遍历)该线性表(依次打印/显示出表中元素值);3)在顺序表中查找第i个元素,并返回其值;4)在顺序表第i个元素之前插入一已知元素;5)在顺序表中删除第i个元素;6)求顺序表中所有元素值(整数)之和;二、链表(带头结点)基本操作实验要求:数据元素类型ElemType取字符型char。
按照动态单链表结构实现如下算法:1)按照头插法或尾插法创建一个带头结点的字符型单链表(链表的字符元素从键盘输入),长度限定在10之内;2)打印(遍历)该链表(依次打印出表中元素值,注意字符的输入顺序与链表的结点顺序);3)在链表中查找第i个元素,i合法返回元素值,否则,返回FALSE;4)在链表中查找与一已知字符相同的第一个结点,有则返回TRUE,否则,返回FALSE;5)在链表中第i个结点之前插入一个新结点;6)在线性表中删除第i个结点;7)计算链表的长度。
数据结构链表的基本操作(附答案)
{int coef;
int exp;
struct Polynode *next;
}Polynode,*Polylist;
Polylist PolyCreate()
{Polynode *head;
Polynode *rear, *s;
int c,e;
head=(Polynode*)malloc(sizeof(Polynode));
{
Polynode *p, *q, *pre, *temp;
int sum;
p=polya->next; /*令p和q分别指向polya和polyb多项式链表中的第一个结点*/
scanf("%d,%d",&c,&e);
}
rear->next=NULL;/*将表的最后一个结点的next置NULL,以示表结束*/
return head;}
Polylist PolyAdd(Polylist polya, Polylist polyb)
/*此函数用于将两个多项式相加,然后将和多项式存放在多项式polya中,并将多项式ployb删除*/
q=q->next; //___________________;
free(temp);
}
else
{
temp=p;
p=p->next;
free(temp);
/*若系数和为零,则删除结点p与q,并将指针指向下一个结点*/
temp=q;
q=q->next; //___________________________
else if(head->exp==0)
2数据结构实验2顺序表答案
sqlist *a,*b,c;
printf("\n*******建立顺序表a********\n");
a=init_sqlist();
creatsqlist(a);
printf("\n建立的顺序表a为:\n");
for(i=0;i<=a->last;i++)
printf(" %d",a->elem[i]);
{int i;
for(i=0;i<=a->last;i++)
printf(" %d",a->elem[i]);//顺序表的输出
printf("\n");
}
void main()/*顺序表的主函数*/
{
sqlist *a;
a=init_sqlist();//调用函数对顺序表的初始化
creatsqlist(a);//建立顺序表
printf("请输入%d个元素",L->last+1);
for(i=0;i<=L->last;i++)
scanf("%d",&(*L).elem[i]);
}
int DelList(SeqList *L,int i,elemtype *e)
/*在顺序表L中删除第i个数据元素,并用指针参数e返回其值。i的合法取值为1≤i≤st+1 */
L->last--;
return(1);
}
void main()
{int i,x,j;
SeqList *a;
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验1、2:线性表的应用参考代码一、实验预备知识1.复习C中编写函数的相关内容。
2.复习如何用主函数将多个函数连在一起构成一个C完整程序。
二、实验目的1.掌握线性表的顺序和链式存储结构2.熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3.熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1.编写初始化并创建线性表和输出线性表的算法。
2.编写对线性表插入和删除运算算法,要判断位置的合法性和溢出问题。
3.编写有序表的插入和删除运算算法。
4.编写一个主函数,将上面函数连在一起,构成一个完整的程序。
5.将实验源程序调试并运行,写出输入、输出结果,并对结果进行分析。
四、实验内容顺序表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。
2.初始化并建立顺序表。
(开辟的存储空间大小为8)3.编写顺序表输出算法。
4.依次插入3、21、15、99四个数,分别插入在第1、8、4和12位置,每插入一次都要输出一次顺序表。
5.删除第1,第9和第12个位置上的元素,每删除一个元素都要输出一次顺序表。
6.编写一个排序算法,对线性表中元素从小到大排列。
7.向有序表分别插入20和50,插入后表仍然有序。
(修改开辟的存储空间大小为15)单链表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。
2.建立一个带表头结点的单链表(前插入法和尾插入法均可)。
3.编写单链表输出算法。
4.依次插入3、21、15、99四个数,分别插入在第1、8、4和12位置,每插入一次都要输出一次单链表。
5.删除第1,第9和第12个位置上的元素,每删除一个元素都要输出一次单链表。
6.编写一个排序算法,对链表中元素从小到大排列。
7.向有序链表分别插入20和50,插入后表仍然有序。
五、实验结果顺序表源程序:#include <iostream>using namespace std;const int MAXSIZE=8; //做有序表插入操作时,将8改为15typedef int DataType;typedef struct{DataType data[MAXSIZE];int length;}SeqList;void Init_SeqList(SeqList &L);//创建空顺序表算法void Show_SeqList(SeqList L);//顺序表输出算法void Create_SeqList(SeqList &L);//顺序表创建算法int Insert_SeqList(SeqList &L,DataType x,int i);//顺序表的插入算法int Delete_SeqList(SeqList &L,int i);//顺序表的删除算法int Locate_SeqList(SeqList L,DataType x);//顺序表的按值查找算法void Sort_SeqList(SeqList &L);//顺序表的排序算法int Insert_SeqList_sort(SeqList &L,DataType x);//有序表的插入算法void Merge(SeqList LA,SeqList LB,SeqList &LC);//两个有序顺序表的合并算法void menu(); //菜单算法void main(){ menu(); }void menu()//菜单算法{SeqList L;Init_SeqList(L);int m;while(1){cout<<"\n根据所做操作选择以下数字序号:"<<endl;cout<<"1:创建顺序表 2:执行插入操作 3:执行删除操作"<<endl;cout<<"4:执行输出操作 5:执行查找操作 6:执行排序操作"<<endl;cout<<"7:执行有序表的插入操作 8:执行有序表的合并操作 0:退出"<<endl;int n,i,x;cin>>n;switch (n){case 1:{Create_SeqList(L);break;}case 2:{cout<<"请输入插入位置:";cin>>i;cout<<endl<<"请输入插入元素值:";cin>>x;cout<<endl;m=Insert_SeqList(L,x,i);if (m==1)cout<<"插入操作成功!"<<endl;elseif (m==0)cout<<"插入位置不合法!"<<endl;elsecout<<"发生溢出!"<<endl;break;}case 3:{cout<<"请输入删除位置:";cin>>i;cout<<endl;m=Delete_SeqList(L,i);if (m==1)cout<<"删除操作成功!"<<endl;elseif (m==0)cout<<"删除位置不合法!"<<endl;elsecout<<"空表!"<<endl;break;}case 4:{Show_SeqList(L);break;}case 5:{cout<<"请输入所要查找的元素值:";cin>>x;cout<<endl;m=Locate_SeqList(L,x);if (m==0)cout<<"所查找元素不在顺序表中!"<<endl;elsecout<<"所查找元素是顺序表的第"<<m<<"个元素!"<<endl;break;}case 6:{cout<<"排序操作完成!"<<endl;break;}case 7:{cout<<endl<<"请输入插入元素值:";cin>>x;cout<<endl;m=Insert_SeqList_sort(L,x);if (m==1)cout<<"插入操作成功!"<<endl;elsecout<<"发生溢出!"<<endl;break;}case 8:{SeqList L1,L2,L3;Init_SeqList(L1);Init_SeqList(L2);Init_SeqList(L3);cout<<"创建有序表1:"<<endl; Create_SeqList(L1);Sort_SeqList(L1);cout<<"创建有序表2:"<<endl;Create_SeqList(L2);cout<<"有序表1:"<<endl;Show_SeqList(L1);cout<<"有序表2:"<<endl;Show_SeqList(L2);Merge(L1,L2,L3);cout<<"合并后:"<<endl;Show_SeqList(L3);break;}case 0:return;}}}void Init_SeqList(SeqList &L)//创建空顺序表算法{=0;}void Show_SeqList(SeqList L)//顺序表输出算法{if==0)cout<<"空表!"<<endl;elsefor(int i=0;i<;i++)cout<<[i]<<" ";cout<<endl;}void Create_SeqList(SeqList &L)//顺序表创建算法{cout<<"请输入元素个数:";cin>>;cout<<"依次输入各个元素的值:"<<endl;for(int i=0;i<;i++)cin>>[i];}int Insert_SeqList(SeqList &L,DataType x,int i)//顺序表的插入算法{if(MAXSIZE<=return -1;if(i<1||i>+1)return 0;for(int j=;j>=i-1;j--)[j+1]=[j];[i-1]=x;++;return 1;}int Delete_SeqList(SeqList &L,int i)//顺序表的删除算法{if ==0)return -1;if(i<1||i>return 0;for(int j=i;j<;j++)[j-1]=[j];;return 1;}int Locate_SeqList(SeqList L,DataType x)//顺序表的按值查找算法{int i=0;while(i<&&[i]!=x)i++;if(i< )return i+1;elsereturn 0;}void Sort_SeqList(SeqList &L) //排序算法{int i,k,j;DataType temp;for(i=0;i<;i++){k=i;for(j=i+1;j<= -1;j++)if [j]< [k])k=j;if(i!=k){temp= [i];[i]= [k];[k]=temp;}}}int Insert_SeqList_sort(SeqList &L,DataType x)//有序表的插入算法{if(MAXSIZE<=return -1;int i=0;while(i<&&[i]<x)i++;for(int j=;j>=i;j--)[j+1]=[j];[i]=x;++;return 1;}void Merge(SeqList LA,SeqList LB,SeqList &LC)//两个有序顺序表的合并算法{int i,j,k;i=j=k=0;while(i<&&j<{if[i]<[j]){[k]=[i];i++;k++;}else{[k]=[j];j++;k++;}}while(i<{[k]=[i];i++;k++;}while(j<{[k]=[j];j++;k++;}=k;}输入输出结果:图1-1主菜单图1-2顺序表的创建和输出操作图1-3 顺序表的插入操作图1-4顺序表的删除操作图1-5顺序表的排序操作图1-6有序表的插入操作图1-7两个有序表的合并操作单链表的源程序:#include "iostream"using namespace std;typedef int DataType;typedef struct node{DataType data;struct node *next;}LNode,*LinkList;void Init_LinkList(LinkList &L);//创建空单链表void Create1LinkList(LinkList &L,int n);//前插入法创建单链表的算法void Create2LinkList(LinkList &L,int n);//后插入法创建单链表的算法void PrintLinkList(LinkList L);//单链表的输出算法int InsertLinkList(LinkList &L,int i,DataType x);//单链表的插入算法int DeleteLinkList(LinkList &L,int i);//单链表的删除算法void Select_Sort_LinkList(LinkList &L);//链表的排序算法(选择排序)void Insert2(LinkList L,DataType x);//有序表的插入void Merge(LinkList L1,LinkList L2,LinkList &L3);//两个有序表的合并算法void menu();//菜单函数int main(){menu();return 0;}void Init_LinkList(LinkList &L)//创建空单链表{L=new LNode;L->next=NULL;}void Create1LinkList(LinkList &L,int n)//前插入法创建单链表的算法{LNode *s;for(int i=1;i<=n;i++){s=new LNode;cout<<"请输入第"<<i<<"个元素的值:";cin>>s->data;s->next=L->next;L->next=s;}}void Create2LinkList(LinkList &L,int n)//后插入法创建单链表的算法{LNode *s,*r=L;for(int i=1;i<=n;i++){s=new LNode;cout<<"请输入第"<<i<<"个元素的值:";cin>>s->data;r->next=s;r=s;}r->next=NULL;}void PrintLinkList(LinkList L)//单链表的输出算法{if(L->next==NULL){cout<<"空表!"<<endl;return;}cout<<"当前单链表为:"<<endl;LNode *p=L->next;while(p){cout<<p->data<<" ";p=p->next;cout<<endl;}int InsertLinkList(LinkList &L,int i,DataType x)//单链表的插入算法{int j=0;LNode *p=L,*s;while(p&&j<i-1){p=p->next;j++;}if(!p||j>i-1)return 0;s=new LNode;s->data=x;s->next =p->next ;p->next =s;return 1;}int DeleteLinkList(LinkList &L,int i)//单链表的删除算法{if(L->next ==NULL)return -1;int j=0;LNode *p=L,*q;while((p->next !=NULL)&&(j<i-1))p=p->next ;j++;}if((p->next==NULL)||(j>i-1))return 0;q=p->next ;p->next =q->next ;delete q;return 1;}void Select_Sort_LinkList(LinkList &L)//链表的排序算法(选择排序){if(L->next ==NULL){cout<<"空表,不需要排序!"<<endl;return;}LNode *p,*q,*s;DataType temp;if(L->next==NULL) return;for(p=L->next;p->next!=NULL;p=p->next){s=p;for(q=p->next;q!=NULL;q=q->next){if(q->data<s->data)s=q;}if(s!=p){temp=s->data; s->data=p->data; p->data=temp;}}cout<<"排序成功!"<<endl;}void Insert2(LinkList L,DataType x)//有序表的插入{LNode *p=L,*s;while(p->next!=NULL&&p->next->data<x)p=p->next;s=new LNode;s->data=x;s->next=p->next;p->next=s;cout<<"插入操作成功!"<<endl;}void Merge(LinkList L1,LinkList L2,LinkList &L3)//两个有序表的合并算法{LNode *p1,*p2,*p3,*s;p1=L1->next ;p2=L2->next ;L3=p3=new LNode;L3->next =NULL;while(p1&&p2){s=new LNode;if(p1->data <p2->data ){s->data =p1->data ;p1=p1->next ;}else{s->data =p2->data ;p2=p2->next ;}p3->next =s;p3=s;}if(p1)p3->next =p1;if(p2)p3->next =p2;}void menu()//菜单函数{LinkList L;Init_LinkList(L);int m;while(1){cout<<"\n根据所做操作选择以下数字序号:"<<endl;cout<<"1:前插入创建单链表 2:尾插入创建单链表 3:执行插入操作"<<endl;cout<<"4:执行删除操作 5:执行输出操作 6:执行排序操作"<<endl;cout<<"7:执行有序表的插入操作 8:执行有序表的合并操作 0:退出"<<endl;int n,i,x;cin>>n;switch (n){case 1:{cout<<"请输入结点个数:";cin>>i;Create1LinkList(L,i);PrintLinkList(L);break;}case 2:{cout<<"请输入结点个数:";cin>>i;Create2LinkList(L,i);PrintLinkList(L);break;}case 3:{cout<<"请输入插入位置:";cin>>i;cout<<endl<<"请输入插入元素值:";cin>>x;cout<<endl;if (InsertLinkList(L,i,x)==1)cout<<"插入操作成功!"<<endl;elsecout<<"插入位置不合法!"<<endl;break;}case 4:{cout<<"请输入删除位置:";cin>>i;cout<<endl;m=DeleteLinkList(L,i);if (m==1)cout<<"删除操作成功!"<<endl;elseif(m==-1)cout<<"空表!"<<endl;elsecout<<"删除位置不合法!"<<endl;break;}case 5:{PrintLinkList(L);break;}case 6:{Select_Sort_LinkList(L);break;}case 7:{cout<<endl<<"请输入插入元素值:";cin>>x;cout<<endl;Insert2(L,x);break;}case 8:{LinkList L1,L2,L3;Init_LinkList(L1);Init_LinkList(L2);Init_LinkList(L3);cout<<"创建有序表1:"<<endl;cout<<"请输入结点个数:";cin>>i;Create2LinkList(L1,i);Select_Sort_LinkList(L1);cout<<"创建有序表2:"<<endl;cout<<"请输入结点个数:";cin>>i;Create2LinkList(L2,i);Select_Sort_LinkList(L2);cout<<"有序表1:"<<endl;PrintLinkList(L1);cout<<"有序表2:"<<endl;PrintLinkList(L2);Merge(L1,L2,L3);cout<<"合并后:"<<endl;PrintLinkList(L3);break;}case 0:return;}}}输入输出结果:图2-1主菜单图2-2创建单链表(用头插入法)图2-3创建单链表(用尾插入法)图2-4单链表的插入操作图2-5单链表的插入操作(插入位置不合法情况)图2-6单链表的删除操作图2-7单链表的删除操作(删除位置不合法情况)图2-8单链表的排序操作图2-9有序表的插入操作图2-10两个有序表的合并操作建议:代码较长,为了方便阅读和调试,可写成多文件结构!。