顺序表的建立及基本操作

合集下载

《数据结构》实验指导书

《数据结构》实验指导书
四、实验说明
1.单链表的类型定义
#include <stdio.h>
typedef int ElemType;//单链表结点类型
typedef struct LNode
{ElemType data;
struct LNode *next;
2.明确栈、队列均是特殊的线性表。
3.栈、队列的算法是后续实验的基础(广义表、树、图、查找、排序等)。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验四 串
一、预备知识
1.字符串的基本概念
2.字符串的模式匹配算法
二、实验目的
1.理解字符串的模式匹配算法(包括KMP算法)
typedef struct
{ElemType *base;
int front,rear;
} SqQueue;
4.单链队列的类型定义
typedef struct QNode
{QElemType data;
typedef struct list
{ElemType elem[MAXSIZE];//静态线性表
int length; //顺序表的实际长度
} SqList;//顺序表的类型名
五、注意问题
1.插入、删除时元素的移动原因、方向及先后顺序。
4.三元组表是线性表的一种应用,通过它可以更好地理解线性表的存储结构。同时矩阵又是图的重要的存储方式,所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验六 树和二叉树
一、预备知识
1.二叉树的二叉链表存储结构

C语言与数据结构实验指导

C语言与数据结构实验指导

C语⾔与数据结构实验指导Harbin Institute of TechnologyC语⾔与数据结构实验指导书刘梅索莹⽥⽂龙哈⼯⼤电⼦与信息⼯程学院电⼦⼯程系实验1 实验平台⼀、实验⽬的1.掌握Microsoft Visual C++ 6.0集成环境的使⽤⽅法。

2.掌握C程序在Microsoft Visual C++ 6.0开发环境中的编辑、编译、链接和运⾏全过程⼆、实验内容1)启动Microsoft Visual C++ 6.0开发环境双击桌⾯应⽤程序图标或“开始”菜单程序组中的Microsoft Visual C++ 6.0应⽤程序,启动VC++,如图所⽰图1.1 VC++初始界⾯2)建⽴C源程序⽂件⽅法1:单击⼯具栏的“新建⽂本⽂件”按钮,打开⽂本⽂件编辑界⾯如下图所⽰图1.2 ⽂本⽂件编辑界⾯⽅法2:执⾏“⽂件”->“新建”命令,如图1.3所⽰,在“⽂件”选项卡下选择C++ Source File ⽂件类型,然后输⼊C源程序⽂件名和保存⽂件,如图1.3所⽰,然后单击“确定”按钮,打开源程序⽂件编辑界⾯,如图1.4所⽰。

注意:输⼊C源程序⽂件名时必须带上扩展“.c”,否则默认创建的是扩展名为“.cpp”的C++⽂件。

3)编辑源⽂件⽅法1:在如图1.2所⽰的⽂本⽂件编辑界⾯中输⼊源程序代码,如图1.5所⽰。

⽅法2:在如图1.4所⽰的C源程序⽂件编辑界⾯中编辑源程序代码,如图1.6所⽰。

图1.3 新建⽂件图1.4 C源程序⽂件编辑界⾯图1.5 ⽂本⽂件编辑界⾯编辑源⽂件图1.6 C源程序编辑界⾯编辑源⽂件4)保存源⽂件源⽂件编辑结束后,执⾏“⽂件”->“保存”命令保存⽂件,⽂本⽂件编辑界⾯中编辑的源⽂件保存时必须在⽂件名后加上扩展名“.c”,否则保存的是扩展名为txt的⽂本⽂件,不能编译运⾏。

5)组件⽂件执⾏“组建”->“组建”命令或直接按F7功能键或单机⼯具栏Build按钮,可以对源⽂件进⾏编译、链接⽽不运⾏该程序。

顺序表的基本操作--实验报告

顺序表的基本操作--实验报告

实验报告附:源程序:#include<stdio.h>#define Maxsize 100#define error 0#define ok 1typedef struct{int elem[Maxsize];int last;}SeqList;int InsList(SeqList *L,int a,int i); int Locate(SeqList L,int e);int Del(SeqList *L,int i);void main(){int i,e,a;int list1,list2;SeqList L;st=0;for(i=0;i<100;i++){printf("请输入顺序表元素\n");scanf("%d",&L.elem[i]);if(L.elem[i]==-1)break;st++;}if(L.elem[st]==-1)st--;printf("要插入的元素,位置为\n"); scanf("%d,%d",&a,&i);list1=InsList(&L,a,i);if(list1){printf("插入后的顺序表为:\n");for(i=0;i<=st;i++)printf("%d",L.elem[i]);printf("\n");}elseprintf("插入失败!");printf("要查找的元素为\n");scanf("%d",&e);list2=Locate(L,e);if(!list2)printf("该元素不存在\n");elseprintf("该元素所在位置的序号为:%d\n",list2);/*删除元素*/printf("是否要删除该元素?<是请输入1 ,否请输入0 >\n");int m;scanf("%d",&m);if(m){Del(&L,list2);printf("删除后的顺序表为:\n");for(i=0;i<=st;i++)printf("%d",L.elem[i]);printf("\n");}else printf("未删除元素%d\n",e);}int InsList(SeqList *L,int a,int i)//i位置,下标i-1{int p;if(L->last>=Maxsize-1){printf("表已满,无法插入");return(error);}for(p=L->last;p>=i-1;p--)L->elem[p+1]=L->elem[p];L->elem[i-1]=a;L->last++;return(ok);}int Locate(SeqList L,int e){int i=0;while((i<=st)&&(L.elem[i]!=e)) i++;if (i<=st)return(i+1);else return(error);}int Del(SeqList *L,int i){int k;for(k=i;k<=L->last;k++)L->elem[k-1]=L->elem[k];L->last--;return ok;}。

线性表的存储结构定义及基本操作

线性表的存储结构定义及基本操作

一、实验目的:. 掌握线性表的逻辑特征. 掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算. 熟练掌握线性表的链式存储结构定义及基本操作. 理解循环链表和双链表的特点和基本运算. 加深对顺序存储数据结构的理解和链式存储数据结构的理解,逐步培养解决实际问题的编程能力二、实验内容:(一)基本实验内容(顺序表):建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:. 创建一个新的顺序表,实现动态空间分配的初始化;. 根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;. 根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);. 利用最少的空间实现顺序表元素的逆转;. 实现顺序表的各个元素的输出;. 彻底销毁顺序线性表,回收所分配的空间;. 对顺序线性表的所有元素删除,置为空表;. 返回其数据元素个数;. 按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;. 按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;. 判断顺序表中是否有元素存在,对判断结果进行返回;. 编写主程序,实现对各不同的算法调用。

2.实现要求:对顺序表的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,每个算法的实现要从时间复杂度和空间复杂度上进行评价;. “初始化算法”的操作结果:构造一个空的顺序线性表。

对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;. “位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;. “位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;. “逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;. “输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;. “销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;. “置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;. “求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;. “按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值. “按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;. “判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

C语言数据结构线性表的基本操作实验报告

C语言数据结构线性表的基本操作实验报告

实验一线性表的基本操作一、实验目的与基本要求1.掌握数据结构中的一些基本概念。

数据、数据项、数据元素、数据类型和数据结构,以及它们之间的关系。

2.了解数据的逻辑结构和数据的存储结构之间的区别与联系;数据的运算与数据的逻辑结构的关系。

3.掌握顺序表和链表的基本操作:插入、删除、查找以及表的合并等运算。

4.掌握运用C语言上机调试线性表的基本方法。

二、实验条件1.硬件:一台微机2.软件:操作系统和C语言系统三、实验方法确定存储结构后,上机调试实现线性表的基本运算。

四、实验内容1.建立顺序表,基本操作包括:初始化,建立一个顺序存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。

2.建立单链表,基本操作包括:初始化,建立一个链式存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。

3.假设有两个按数据元素值非递减有序排列的线性表A和B,均以顺序表作为存储结构。

编写算法将A表和B表归并成一个按元素值非递增有序(允许值相同)排列的线性表C。

(可以利用将B中元素插入A中,或新建C表)4.假设有两个按数据元素值非递减有序排列的线性表A和B,均以单链表作为存储结构。

编写算法将A表和B表归并成一个按元素值递减有序(即非递增有序,允许值相同)排列的线性表C。

五、附源程序及算法程序流程图1.源程序(1)源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素,并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素,并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}(2)源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素,并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行,首先出现的是菜单界面,选择菜单选项进行操作,如图所示。

顺序表的建立与基本操作实验报告

顺序表的建立与基本操作实验报告

顺序表的建立与基本操作实验报告
实验目的:
1、理解顺序表的概念和工作机制。

2、掌握顺序表的建立方法和基本操作。

实验仪器:
1、计算机
2、编程软件
实验原理:
顺序表是一种线性结构,它可以用一段地址连续的存储单元依次存储线性表中的数据元素。

其中,数据元素在存储区中的位置是按其逻辑次序依次存放的。

实验步骤:
1、定义顺序表结构体。

顺序表的结构体包含两个元素:顺序表存储的数据和顺序表存储的长度。

2、初始化顺序表。

初始化顺序表其实就是将顺序表长度设为0。

3、增加数据元素。

当往顺序表中增加元素时,需要先判断顺序表中是否还有剩余的可存储空间,如果没有,需要扩展顺序表空间。

4、删除数据元素。

删除顺序表中的元素时,需要先判断该元素是否在顺序表中存在,然后将该元素后面的元素依次往前移动一位。

5、查找数据元素。

查找顺序表中的元素时,需要先判断该元素是否在顺序表中存在,然后返回该元素在顺序表中的下标。

实验结果:
根据以上步骤和原理,我们创建了一个简单的顺序表程序。

通过该程序的运行,我们可以看到以下结果:
1、创建了一个长度为0的顺序表。

2、在顺序表中增加了8个整数数据。

3、删除了顺序表中下标为2的元素。

4、查找了顺序表中值为7的元素并返回其下标。

结论:
通过这次实验,我们掌握了顺序表的建立方法和基本操作。

顺序表在实际编程中十分常见,因此这次实验为我们今后的编程实践提供了有用的知识和工具。

建立一个顺序表,表中元素为学生,每个学生信息包含姓名、学号和成绩三部分,对该表实现输出、插入、删除、

建立一个顺序表,表中元素为学生,每个学生信息包含姓名、学号和成绩三部分,对该表实现输出、插入、删除、

云南大学物理实验教学中心实验报告课程名称:计算机软件技术基础实验项目:实验二、线性表(顺序存储)及其应用学生姓名:学号:学院系级专业成绩指导教师:实验时间:年日时分至时分实验地点:实验类型:教学(演示□验证□综合█设计□)学生科研□课外开放□测试□其它□一、实验目的:掌握顺序表的建立及基本操作。

二、问题:建立一个顺序表,表中元素为学生,每个学生信息包含姓名、学号和成绩三部分,对该表实现:①输出、②插入、③删除、④查找功能,并计算出平均成绩和总成绩。

三、程序的编写与调试1、原程序:#include <iostream>using namespace std;typedef struct{ long double num; char name[10]; int score; } STUDENT; class sq_LList{ private:int mm;int nn;STUDENT *v;public:sq_LList(int);void prt_sq_LList();void ins_sq_LList(int, STUDENT);void del_sq_LList(int);void sea_num_sq_LList(int);voidvoid cal_sq_LList(int);};/*输出*/sq_LList ::sq_LList(int m){ mm=m;v=new STUDENT [mm];v[0].num=970156; strcpy(v[0].name,"张小明"); v[0].score=87; v[1].num=970157; strcpy(v[1].name,"李小青"); v[1].score=96;v[2].num=970158; strcpy(v[2].name,"刘华");v[2].score=85; v[3].num=970159; strcpy(v[3].name,"王伟");v[3].score=93; v[4].num=970160; strcpy(v[4].name,"李启明"); v[4].score=88;nn=5;}void sq_LList ::prt_sq_LList(){ int i;for(i=0; i<nn; i++){ cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}/*插入*/void sq_LList ::ins_sq_LList(int i, STUDENT b){ int k;if(nn==mm){cout<<"overflow"; 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;}/*删除*/void sq_LList ::del_sq_LList(int i){ int k;if(nn==0){cout<<"underflow"<<endl; return ;}if((i<1)||(i>nn)){cout<<"Not this element in the list!"<<endl; return ;}for(k=i; k<nn; k++)v[k-1]=v[k];nn=nn-1;}/*按学号查找*/void sq_LList ::sea_num_sq_LList(int i){ int k,t ;____t=0;for(i=0;i<nn;i++){ if(v[i].num==k){ t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0)cout<<"No this student in the list!"<<endl;}/*按姓名查找*/void sq_LList ::sea_name_sq_LList(int i, char y[]){ int t;____t=0;for(i=0;i<nn;i++){ if(strcmp(y,v[i].name)=0){t=t+1cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0) cout<<"No this student in the list!"<<endl }/*计算*/void sq_LList ::cal_sq_LList(int m){ int i;float sum,avr;{ sum=0;for(i=0;i<nn;i++){sum=sum+v[i].score;avr=sum/(i+1);}}cout<<"总分:"<<sum<<endl;cout<<"平均分:"<<avr<<endl;}int main(){ int mx; sq_LList s1(100);while (1){ cout<<"1.输出 2.插入 3.删除 4.查找 5.计算 0.退出\n";cout<<"输入0-5:";cin>>mx;switch(mx){ case 1: s1.prt_sq_LList(); break;case 2: int i; STUDENT b;cout<<"输入插入点位置和插入元素值:";cin>>i>>b.num>>>>b.score;s1.ins_sq_LList(i,b); s1.prt_sq_LList(); break; case 3: cout<<"请输入删除学生的位置:";cin>>i;s1.del_sq_LList(i);s1.prt_sq_LList(); break; case 4: int main(){ int mx;while (1){cout<<"1.按学号查找 2.按姓名查找 0.返"<<endl;cout<<"输入0-2:";cin>>mx;switch (mx){casecout<<"请输入要查找学生的学号:";s1.sea_num_sq_LList(i); break;casecout<<"请输入要查找学生的姓名:";s1.sea_name_sq_LList(); break;case 0: cout<<"返回"<<endl; return ;}}return 0;} break;case 5: s1.cal_sq_LList(); break;case 0: cout<<"程序结束"<<endl; return 0;}}return 0;2、正确程序:#include <iostream>using namespace std;typedef struct{ long double num; char name[10]; int score; } STUDENT; class sq_LList{ private:int mm;int nn;STUDENT *v;public:sq_LList(int);void prt_sq_LList();void ins_sq_LList(int, STUDENT);void del_sq_LList(int);void sea_num_sq_LList(int);void sea_name_sq_LList();void cal_sq_LList(int);/*输出*/sq_LList ::sq_LList(int m){ mm=m;v=new STUDENT [mm];v[0].num=970156; strcpy(v[0].name,"张小明"); v[0].score=87; v[1].num=970157; strcpy(v[1].name,"李小青"); v[1].score=96;v[2].num=970158; strcpy(v[2].name,"刘华");v[2].score=85; v[3].num=970159; strcpy(v[3].name,"王伟");v[3].score=93; v[4].num=970160; strcpy(v[4].name,"李启明"); v[4].score=88;nn=5;}void sq_LList ::prt_sq_LList(){ int i;for(i=0; i<nn; i++){ cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}/*插入*/void sq_LList ::ins_sq_LList(int i, STUDENT b){ int k;if(nn==mm){cout<<"overflow"; 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;}/*删除*/void sq_LList ::del_sq_LList(int i){ int k;if(nn==0){cout<<"underflow"<<endl; return ;}if((i<1)||(i>nn)){cout<<"Not this element in the list!"<<endl; return ;}for(k=i; k<nn; k++)v[k-1]=v[k];nn=nn-1;}/*按学号查找*/void sq_LList ::sea_num_sq_LList(int i){ int k,t ;cin>>k;t=0;for(i=0;i<nn;i++){ if(v[i].num==k){ t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0)cout<<"No this student in the list!"<<endl;}/*按姓名查找*/void sq_LList ::sea_name_sq_LList(){ char y[10]; int i,t;cin>>y;t=0;for(i=0;i<nn;i++){ if(strcmp(y,v[i].name)==0){t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0) cout<<"No this student in the list!"<<endl; }/*计算*/void sq_LList ::cal_sq_LList(int m){ int i;float sum,avr;{ sum=0;for(i=0;i<nn;i++){sum=sum+v[i].score;avr=sum/(i+1);}}cout<<"总分:"<<sum<<endl;cout<<"平均分:"<<avr<<endl;}int main(){ int mx; sq_LList s1(100);while (1){ cout<<"1.输出 2.插入 3.删除 4.查找 5.计算 0.退出\n";cout<<"输入0-5:";cin>>mx;switch(mx){ case 1: s1.prt_sq_LList(); break;case 2: int i; STUDENT b;cout<<"输入插入点位置和插入元素值:";cin>>i>>b.num>>>>b.score;s1.ins_sq_LList(i,b); s1.prt_sq_LList(); break; case 3: cout<<"请输入删除学生的位置:";cin>>i;s1.del_sq_LList(i);s1.prt_sq_LList(); break; case 4:{ int mx;while (1){cout<<"1.按学号查找 2.按姓名查找 0.返"<<endl;cout<<"输入0-2:";cin>>mx;switch (mx){case 1: cout<<"请输入要查找学生的学号:";s1.sea_num_sq_LList(i); break;case 2: cout<<"请输入要查找学生的姓名:";s1.sea_name_sq_LList(); break;case 0: cout<<"返回"<<endl; return 0;}}return 0;} break;case 5: s1.cal_sq_LList(i); break;case 0: cout<<"程序结束"<<endl; return 0;}}return 0;}四、实验总结通过此次试验,我对线性表(顺序存储)有了全面的认识,知道了什么是线性表,以及线性表有什么作用;并学会了如何根据要求建立一个实际的线性表,包括线性表的输出、插入、删除、查。

数据结构实验一顺序表

数据结构实验一顺序表

数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算2、实验内容:建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:∙创建一个新的顺序表,实现动态空间分配的初始化;∙根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;∙根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);∙利用最少的空间实现顺序表元素的逆转;∙实现顺序表的各个元素的输出;∙彻底销毁顺序线性表,回收所分配的空间;∙对顺序线性表的所有元素删除,置为空表;∙返回其数据元素个数;∙按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;∙按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;∙判断顺序表中是否有元素存在,对判断结果进行返回;.编写主程序,实现对各不同的算法调用。

2.实现要求:∙“初始化算法”的操作结果:构造一个空的顺序线性表。

对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;∙“位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;∙“位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;∙“逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;∙“输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;∙“销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;∙“置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;∙“求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;∙“按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值∙“按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;∙“判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

顺序表的建立与基本算法

顺序表的建立与基本算法

顺序表的建立与基本算法
顺序表是数据结构中最基本、最常见的存储结构。

它是一组在一起的有组织地存储在内存中的相关数据项,以便快速访问和修改。

顺序表的建立与基本算法主要包括以下几点:
一、建立顺序表
1.定义存储空间大小:首先要确定存储空间大小,根据实际情况来确定。

2.申请内存空间:将需要的内存空间分配给顺序表,用于存放后面的数据元素。

3.初始化顺序表:将顺序表的长度初始化为0,表示此时顺序表是空表,然后给顺序表的数据元素赋初值,例如-1、0、NULL等。

4.插入数据元素:在指定位置插入数据元素到顺序表上。

5.释放内存空间:当顺序表使用完毕,需要释放顺序表所申请的内存空间,回收内存。

二、顺序表的基本算法
1.查找算法:在顺序表中查找特定的数据元素,通过遍历顺序表的方式来查找,可以通过比较元素的特征值来区分,查找的时间复杂度为O(n)。

2.插入算法:在顺序表中插入数据元素,需要先判断顺序表是否已满,如果未满则在指定位置插入数据元素,需要将插入位置后面的元素都后移一个位置,插入的时间复杂度为O(n)。

3.删除算法:在顺序表中删除数据元素,需要先判断顺序表是否为空,如果非空则在指定位置删除数据元素,需要将删除位置后面的元素都前移一个位置,删除的时间复杂度为O(n)。

4.更新算法:更新顺序表中的数据元素,需要先查找到特定的元素,然后根据需要更新数据元素,更新的时间复杂度也是O(n)。

总的来说,顺序表的建立与基本算法包括建立顺序表,查找算法,插入算法,删除算法,更新算法等几个方面,都要结合实际情况具体
操作,时间复杂度都是O(n)。

顺序表的基本操作实验报告

顺序表的基本操作实验报告

顺序表的基本操作实验报告一、实验目的。

本实验旨在通过对顺序表的基本操作进行实验,加深对顺序表的理解,掌握顺序表的基本操作方法,提高编程实践能力。

二、实验内容。

1. 初始化顺序表,包括建立空的顺序表和建立有元素的顺序表。

2. 插入元素,在指定位置插入元素。

3. 删除元素,删除指定位置的元素。

4. 查找元素,根据元素值查找元素所在位置。

5. 输出顺序表,将顺序表中的元素依次输出。

三、实验步骤。

1. 初始化顺序表。

(1)建立空的顺序表,首先定义一个顺序表的结构体,包括数据存储区和表长两个成员变量。

然后通过动态内存分配为顺序表分配存储空间,并初始化表长为0,即建立了一个空的顺序表。

(2)建立有元素的顺序表,定义一个包含初始元素的数组,然后将数组中的元素依次复制到顺序表的数据存储区中,并更新表长。

2. 插入元素。

在指定位置插入元素时,需要先判断插入位置是否合法,然后将插入位置后的元素依次后移,为插入元素腾出位置,并更新表长。

3. 删除元素。

删除指定位置的元素时,同样需要先判断删除位置是否合法,然后将删除位置后的元素依次前移,覆盖被删除的元素,并更新表长。

4. 查找元素。

根据元素值查找元素所在位置时,需要遍历顺序表中的元素,逐个比较元素值,找到匹配的元素位置后返回位置信息。

5. 输出顺序表。

将顺序表中的元素依次输出时,可以通过循环遍历顺序表中的元素,并逐个输出。

四、实验结果与分析。

经过实验操作,成功实现了顺序表的初始化、插入、删除、查找和输出等基本操作。

通过对顺序表的操作,加深了对顺序表结构和操作方法的理解,掌握了顺序表的基本操作技巧。

在实际编程中,顺序表的基本操作是非常常见的,对于处理线性表数据具有重要意义。

五、实验总结。

通过本次实验,深入理解了顺序表的基本操作方法,掌握了顺序表的初始化、插入、删除、查找和输出等操作技巧。

在今后的学习和工作中,将能更加熟练地运用顺序表的基本操作,提高编程实践能力,为实际问题的解决提供更加有效的数据结构支持。

《数据结构》实验指导书(Java语言版).

《数据结构》实验指导书(Java语言版).

《数据结构》课程实验指导《数据结构》实验教学大纲课程代码:0806523006 开课学期:3 开课专业:信息管理与信息系统总学时/实验学时:64/16 总学分/实验学分:3.5/0.5一、课程简介数据结构是计算机各专业的重要技术基础课。

在计算机科学中,数据结构不仅是一般程序设计的基础,而且是编译原理、操作系统、数据库系统及其它系统程序和大型应用程序开发的重要基础。

数据结构课程主要讨论各种主要数据结构的特点、计算机内的表示方法、处理数据的算法以及对算法性能的分析。

通过对本课程的系统学习使学生掌握各种数据结构的特点、存储表示、运算的原理和方法,学会从问题入手,分析研究计算机加工的数据结构的特性,以便为应用所涉及的数据选择适当的逻辑结构、存储机构及其相应的操作算法,并初步掌握时间和空间分析技术。

另一方面,本课程的学习过程也是进行复杂程序设计的训练过程,通过对本课程算法设计和上机实践的训练,还应培养学生的数据抽象能力和程序设计的能力。

二、实验的地位、作用和目的数据结构是一门实践性较强的基础课程,本课程实验主要是着眼于原理和应用的结合,通过实验,一方面能使学生学会把书上学到的知识用于解决实际问题,加强培养学生如何根据计算机所处理对象的特点来组织数据存储和编写性能好的操作算法的能力,为以后相关课程的学习和大型软件的开发打下扎实的基础。

另一方面使书上的知识变活,起到深化理解和灵活掌握教学内容的目的。

三、实验方式与基本要求实验方式是上机编写完成实验项目指定功能的程序,并调试、运行,最终得出正确结果。

具体实验要求如下:1.问题分析充分地分析和理解问题本身,弄清要求,包括功能要求、性能要求、设计要求和约束,以及基本数据特性、数据间联系等等。

2.数据结构设计针对要解决的问题,考虑各种可能的数据结构,并且力求从中选出最佳方案(必须连同算法实现一起考虑),确定主要的数据结构和全程变量。

对引入的每种数据结构和全程变量要详细说明其功用、初值和操作的特点。

数据结构上机实验题

数据结构上机实验题
p=(linklist *)malloc(sizeof(linklist));该语句的功能是申请分配一个类型为linklist的结点的地址空间,并将首地址存入指针变量p中。当结点不需要时可以用标准函数free(p)释放结点存储空间,这时p为空值(NULL)。
思考与提高:
1.如果按由表尾至表头的次序输入数据元素,应如何建立顺序表。
{
Datatypestack[MAXNUM];
int top;
}SqStack;
/*初始化顺序栈函数*/
void InitStack(SqStack *p)
{q=(SqStack*)malloc(sizeof(SqStack) /*申请空间*/}
/*入栈函数*/
void Push(SqStack *p,Datatypex)
实现提示:
1.由于C语言的数组类型也有随机存取的特点,一维数组的机内表示就是顺序结构。因此,可用C语言的一维数组实现线性表的顺序存储。
在此,我们利用C语言的结构体类型定义顺序表:
#define MAXSIZE 1024
typedef int elemtype; /*线性表中存放整型元素*/
typedef struct
实验一线性表
实验目的:
1.熟悉C语言的上机环境,进一步掌握C语言的结构特点。
2.掌握线性表的顺序存储结构的定义及C语言实现。
3.掌握线性表的链式存储结构——单链表的定义及C语言实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
实验内容:
printf("输入源点v1 : ");
scanf("%d",&v1); /*输入源点V1 */

顺序表的基本操作【c语言】【创建、插入、删除、输出】

顺序表的基本操作【c语言】【创建、插入、删除、输出】

顺序表的基本操作【c语⾔】【创建、插⼊、删除、输出】作为数据结构初学者,上课时对⼀些知识点掌握得不是很透彻,所以利⽤课余时间通过微博平台总结所学知识,加深对知识的见解,记录学习历程便于后需要时参考。

1 #include<stdio.h>2 #include<malloc.h>3#define OK 14#define ERROR 05#define LIST_INIT_SIZE 1006#define LISTINCREMENT 107#define ElemType int顺序表的基本操作之结构体的创建:1 typedef struct2 {3int *elem;//存储空间基址,也就是该数据得到的内存分配的起始地址4int length;//当前长度5int listsize;//当前分配的存储容量6 } SqList;构造⼀个空的线性表:int InitList_Sq(SqList &L) //&此符号不是c语⾔⾥的取地址符号,⽽是C++⾥的引⽤符号,⽤法为为主函数⾥的T,取⼀个别名,这样⼦对L操作即相当于对T操作{// 该线性表预定义⼤⼩为LIST_INIT_SIZEL.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//ElemType即为intif(!L.elem) return0;//malloc返回值为void*,void* 类型可以强制转换为任何其它类型的指针,在这⾥L.elem为⾮零。

L.length=0;L.listsize=LIST_INIT_SIZE;//LIST_INIT_SIZE=100return OK;}在顺序线性表L中第i个位置之前插⼊新的元素e:1int ListInsert_Sq(SqList &L,int i,int e)2 {3int *newbase;//声明整型指针变量4int *q,*p;5if(i<1||i>L.length+1) return ERROR;//判断i值是否合法,1<i<L.length+16if(L.length>=L.listsize)//判断当前长度是否⼤于当前的存储容量,如果⼤于,则增加LISTINCREMENT长度,即107 {8 newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));9if(!newbase) return0;10 L.elem=newbase;11 L.listsize+=LISTINCREMENT;12 }13 q=&(L.elem[i-1]);//把插⼊位置的地址赋值给q14for(p=&(L.elem[L.length-1]); p>=q; p--)15 *(p+1)=*p;//把i后⾯的元素都向后移⼀位16 *q=e;//在i位置插⼊e17 ++L.length;//长度增加18return OK;19 }在顺序线性表L中删除第i个位置的元素,并⽤e返回其值:int ListDelete_Sq(SqList &L,int i, int &e){// i的合法值为1≤i≤L.lengthint *p;int *q;if(i<1||i>L.length) return ERROR;p=&(L.elem[i-1]);//把i位置的地址赋值给pe=*p;//把i位置的值赋值给eq=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;//i后⾯的元素向前移⼀位,直接覆盖i位置的值--L.length;//长度减少return OK;}顺序表基本操作之输出:int Load_Sq(SqList &L){// 输出顺序表中的所有元素int i;if(L.length==0) printf("The List is empty!");else{printf("The List is: ");for( i=0; i<L.length; i++) printf("%d ",L.elem[i]); // 请填空}printf("\n");return OK;}下⾯是主函数:1int main()2 {3 SqList T;4int a, i;5 ElemType e, x;6if(InitList_Sq(T)) // 判断顺序表是否创建成功7 {8 printf("A Sequence List Has Created.\n");9 }10while(1)11 {12 printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");13 scanf("%d",&a);14switch(a)15 {16case1:17 scanf("%d%d",&i,&x);18if(!ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法19else printf("The Element %d is Successfully Inserted!\n", x);20break;21case2:22 scanf("%d",&i);23if(!ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法24else printf("The Element %d is Successfully Deleted!\n", e);25break;26case3:27 Load_Sq(T);28break;29case0:30return1;31 }32 }33 }。

数据结构c++顺序表、单链表的基本操作,查找、排序代码

数据结构c++顺序表、单链表的基本操作,查找、排序代码

} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
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; } 运行及结果:

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

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

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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、实验前要预习:实验前必须认真预习相关的知识,做好充分准备。

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.顺序表的基本操作实践。

(1)建⽴4个元素的顺序表list[]={2,3,4,5},实现顺序表建⽴的基本操作。

(2)在list[]={2,3,4,5}的元素4和5之间插⼊⼀个元素9,实现顺序表插⼊的基本操作。

(3)在list[]={2,3,4,9,5}中删除指定位置(i=3)上的元素4,实现顺序表的删除的基本操作。

#include <stdio.h>#include <stdlib.h>#include <iostream>#define MAXSIZE 10using namespace std;typedef int ElemType;typedef struct {ElemType a[MAXSIZE];int length;} S;void CreatList(S &L) {scanf("%d", &L.length);for(int i = 1; i <= L.length; i ++) scanf("%d",&L.a[i]);} //创建列表void PutList(S L) {for(int i = 1; i <= L.length; i ++) {printf("%d ",L.a[i]);}printf("\n");} //输出列表void InserElem(S &L, int i, ElemType x) { j iif(i < 1 || i > L.length) return; 2 3 4 5 9for(int j = L.length+1; j > i; j --) { j-1jL.a[j] = L.a[j-1]; 2 3 4 9 5}L.a[i] = x;L.length++;} //插⼊void DeleElem(S &L, int i) {for(int j = i; j < L.length; j ++) {L.a[j] = L.a[j+1]; j j+1} 2 3 4 9 5L.length--;}//删除int main() {S L;CreatList(L);InserElem(L,4,9);PutList(L);DeleElem(L,3);PutList(L);return0;}结果E:\c++>b42345234952395。

c++有序顺序表的建立与基本操作

c++有序顺序表的建立与基本操作

c++有序顺序表的建立与基本操作【C++有序顺序表的建立与基本操作】一、引言在C++编程中,有序顺序表是非常常见的数据结构之一。

它可以帮助我们存储和操作一组有序的数据,是程序中非常实用的工具。

本文将从有序顺序表的概念入手,逐步深入探讨其建立和基本操作,帮助读者更好地理解和运用这一数据结构。

二、有序顺序表的概念有序顺序表是一种线性表,其中元素按照一定的顺序排列。

在C++中,我们通常使用数组来实现有序顺序表。

通过数组,我们可以轻松地存储一组有序的数据,并且可以方便地进行各种基本操作,如插入、删除、查找等。

三、有序顺序表的建立1. 定义结构体或类我们需要定义一个结构体或类,用于表示有序顺序表。

结构体或类中应包含元素存储的数组,以及记录当前元素个数和表长的变量。

2. 初始化在建立有序顺序表时,我们需要对其进行初始化。

可以通过动态内存分配来分配数组空间,并对其他变量进行初始化。

需要注意的是,数组的大小应该根据实际需要进行调整,以防止空间浪费。

3. 插入元素在有序顺序表中插入元素是一个常见的操作。

当插入元素时,我们需要保持顺序表的有序性。

可以通过比较元素大小的方式,找到合适的位置并将元素插入其中。

四、有序顺序表的基本操作1. 插入操作有序顺序表的插入操作是比较常见的操作之一。

当我们需要向顺序表中插入新元素时,我们首先需要找到合适的位置,然后将其插入其中。

2. 删除操作删除操作是有序顺序表中另一个重要的操作。

当我们需要删除某个元素时,我们可以通过查找元素的方式找到需要删除的元素,然后将其后的元素向前移动,从而达到删除的目的。

3. 查找操作有序顺序表中的查找操作也是常见的操作之一。

当我们需要查找某个元素时,可以通过顺序查找或二分查找的方式进行查找,以获取所需的元素。

五、个人观点和理解有序顺序表是C++编程中非常常见的数据结构之一。

它能够帮助我们高效地存储和操作数据,是程序中的重要工具。

在实际应用中,我们需要灵活地运用有序顺序表的建立和基本操作,以解决实际问题。

《数据结构》实验指导书(C语言版)(浦江学院)

《数据结构》实验指导书(C语言版)(浦江学院)

实验1: 顺序表的操作实验一、实验名称和性质二、实验目的1.掌握线性表的顺序存储结构的表示和实现方法。

2.掌握顺序表基本操作的算法实现。

3.了解顺序表的应用。

三、实验内容1.建立顺序表。

2.在顺序表上实现插入、删除和查找操作(验证性内容)。

3.删除有序顺序表中的重复元素(设计性内容)。

四、实验的软硬件环境要求硬件环境要求:PC机(单机)使用的软件名称、版本号:Windows环境下的VC++6.0五、知识准备前期要求熟练掌握了C语言的编程规则、方法和顺序表的基本操作算法。

六、验证性实验1.实验要求编程实现如下功能:(1)根据输入顺序表的长度n和各个数据元素值建立一个顺序表,并输出顺序表中各元素值,观察输入的内容与输出的内容是否一致。

(2)在顺序表的第i个元素之前插入一个值为x的元素,并输出插入后的顺序表中各元素值。

(3)删除顺序表中第i个元素,并输出删除后的顺序表中各元素值。

(4)在顺序表中查找值为e的数据元素,如果查找成功,则显示“查找成功”和该元素在顺序表中的位置,否则显示“查找失败”。

2. 实验相关原理线性表的顺序存储结构称为顺序表,顺序表的存储结构描述为:#define MAXLEN 30 /*线性表的最大长度*/typedef struct{Elemtype elem[MAXLEN]; /*顺序表中存放元素的数组,其中elemtype为抽象数据类型,在程序具体实现时可以用任意类型代替*/int length; /*顺序表的长度,即元素个数*/}Sqlist; /*顺序表的类型*/【核心算法提示】(1)顺序表插入操作的基本步骤:要在顺序表中的第i个数据元素之前插入一个数据元素x,首先要判断插入位置i是否合法,假设线性表的表长为n,则i的合法值范围:1≤i ≤n+1,若是合法位置,就再判断顺序表是否满,如果满,则增加空间或结束操作,如果不满,则将第i个数据元素及其之后的所有数据元素都后移一个位置,此时第i个位置已经腾空,再将待插入的数据元素x插入到该位置上,最后将线性表的表长增加1。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
L.length--; //表长-1
cout << "删除数字之后的顺序表为:" << endl; //提示
ShowList(L); //输出新表
return OK;
}
void UpRankList(SqList &L) //升序排列顺序表
{
int i, j, temp;
for (j = 0; j<L.length - 1; j++) //进行 表长-1 趟冒泡
L.length++; //表长+1
cout << "插入新数字之后的顺序表为:" << endl; //提示
ShowList(L); //输出新表
return OK;
}
int DeleteElem(SqList &L) //删除某个元素
{
int x;
cout << "请问您要删除第__个元素?"; //提示
<< "A.显示出该顺序表" << endl
<< "B.找出该组数中的最大值" << endl
<< "C.在该顺序表中插入新数据" << endl
<< "D.删除某个数据" << endl
<< "E.将该顺序表按生序排列" << endl; //提示
char choice;
do //主菜单
{
cin >> choice;
default:;
}
} while ((choice = 'A') && (choice = 'B') && (choice = 'C') && (choice = 'D') && (choice = 'E'));
system("pause");
return 0;
}
四、实验结果(程序的执行结果)
五、实验讨论(可选)
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef struct { //定义顺序表结构
int data[MAXSIZE]; //存储空间的基地址;
int length; //当前表长
}SqList;
int InitList(SqList &L) //初始化顺序表
{
L.length = 0; //当前长度为0
return OK;
}
void ShowList(SqList &L) //显示顺序表
{
cout << "您构建的顺序表为:" << endl; //提示
int i;
for (i = 0; i < L.length; i++)
{
cout << L.data[i] << " ";
{
for (i = 0; i < L.length - 1 - j; i++) //每趟冒泡比较两个数字,共比较 表长-趟数 次
{
if (L.data[i] > L.data[i + 1]) //将两者较大者移到后边
{
temp = L.data[i];
L.data[i] = L.data[i + 1];
} //依次输出顺序表
cout << endl;
}
void FindMax(SqList &L) //找最大值
{
cout << "该组数据的最大值为:" << end];
int i;
for (i = 0; i < L.length; i++) //依次比较两个数的大小,取大者赋给m
cin >> L.length; //输入表长
cout << "请输入要输入的数字,并用空格隔开:" << endl;
int i;
for (i = 0; i < L.length; i++)
{
cin >> L.data[i];
} //依次输入顺序表各个元素
cout << "请输入下列选项前的字母对该数组进行相应操作。" << endl
{
if (m < L.data[i])
{
m = L.data[i];
}
}
cout << m << endl; //输出最大值
}
int InsertList(SqList &L) //插入新数字
{
int x, e;
cout << "请问您要在第__个数字前插入新数字?"; //提示
cin >> x; //输入要插入的位置
山东师范大学
实验报告
课程:数据结构班级:2016级通信2班
实验序号:1姓名:韩明达
学号:2***********
实验日期:9.17题目:顺序表的建立和运算
一、实验目的和要求
(1)熟悉C语言的上机环境,进一步掌握C语言的结构特点。
(2)掌握线性表的顺序存储结构的定义及基本运算
二、实验环境
Windows10,Visual Studio 2017
L.data[i + 1] = temp;
}
}
}
cout << "该数组按升序排列后为:" << endl; //提示
ShowList(L); //输出新表
}
int main()
{
SqList L; //定义顺序表L
InitList(L); //初始化L
cout << "请输入要输入的数字的个数:" << " ";
switch (choice)
{
case 'A': ShowList(L); break;
case 'B': FindMax(L); break;
case 'C': InsertList(L); break;
case 'D': DeleteElem(L); break;
case 'E': UpRankList(L); break;
三、实验内容及实施
实验内容
1、建立一个顺序表,输入n个元素并输出;
2、查找线性表中的最大元素并输出;
3、在线性表的第i个元素前插入一个正整数x;
4、删除线性表中的第j个元素;
5、将线性表中的元素按升序排列;
【程序流程图】
【程序】
#include<stdio.h>
#include<iostream>
using namespace std;
cout << "您要插入的数字为:" << endl;
cin >> e; //输入要插入的数字
for (int j = L.length - 1; j >= x - 1; j--)
L.data[j + 1] = L.data[j]; //从要插入的位置起,后面数据依次向后移动
L.data[x - 1] = e; //插入新数字
cin >> x; //输入要删除第几个数字
if (x<1 || x>L.length)
{
cout << "该值错!" << endl;
return ERROR;
} //错误提示
for (int j = x - 1; j < L.length - 1; j++)
L.data[j] = L.data[j + 1]; //从该位置起,以后数字依次向前移动
if (x<1 || x>L.length)
{
cout << "该值错!" << endl;
return ERROR;
} //位置错误提示
if (L.length == MAXSIZE)
{
cout << "该顺序表空间已满,不能再添加数值!" << endl;
return OVERFLOW;
} //存储空间已满提示
相关文档
最新文档