数据结构-线性表输入,输出,插入,删除,查找

合集下载

数据结构第1讲---线性表

数据结构第1讲---线性表
type p=^integer; var p1:p; p1
34F2 地址 被释放,变 量P与地址 34F2没有关 系
p1^
200 34F2
34F2
new(p1) ——向计算机申请内存地址 p1^:=200 ——给p1指向的单元赋值 dispose(p1) ——释放存储单元
链式结构——什么是指针
Type p=^integer; arr=array[1..4] of char; arrp = ^arr; Var p1:p; p2:arrp;
线性结构 数据的逻辑结构 数 据 结 构 树形结构 图形结构 数据的存储结构 顺序存储
链式存储
数据结构的基本运算 :查找、插入、删除等
三、线性结构——线性表
1、线性表的概念
线性表是由n(n≥0)个具有相同特性数据元素(结点)
a1,a2,…,an组成的有限序列。
线性表的长度:所含元素的个数,用n表示,n>=0。
在我们生活中有哪些属于线性表的例子,列举几个。 1、英文字母表(A,B,…,Z)是线性表, 表中每个字母是一个数据元素(结点)
2、学生成绩表中,每个学生及其成绩是一
个数据元素,其中数据元素由学号、姓名、
各科成绩及平均成绩等数据项组成。
4、线性表的顺序存储
顺序存储是线性表的一种最 简单的存储结构,存储方式是: 在内存中为线性表开辟一块连 续的存储空间。用数组来存放 每一个节点。
[例4-2] 法雷序列
[问题描述]对任意给定的一个自然数n(n<=100),将 分母小于等于n的不可约的真分数按上升次序排序,并 且在第一个分数前加0/1,而在最后一个分数后加1/1, 这个序列称为n级的法雷序列。 当n=8时序列为:0/1, 1/8, 1/7, 1/6,1/5, 1/4,2/7,1/3,3/8, 2/5,3/7,1/2,4/7,3/5,5/8,2/3,5/7,3/4, 4/5,5/6,6/7,7/8, 1/1 。 编程求出n级的法雷序列,每行输出10个分数。

数据结构实验-实验指导书

数据结构实验-实验指导书

实验一线性表操作一、实验目的1熟悉并掌握线性表的逻辑结构、物理结构。

2熟悉并掌握顺序表的存储结构、基本操作和具体的函数定义。

3熟悉VC++程序的基本结构,掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用。

4熟悉VC++操作环境的使用以及多文件的输入、编辑、调试和运行的全过程。

二、实验要求1实验之前认真准备,编写好源程序。

2实验中认真调试程序,对运行结果进行分析,注意程序的正确性和健壮性的验证。

3不断积累程序的调试方法。

三、实验内容基本题:1对元素类型为整型的顺序存储的线性表进行插入、删除和查找操作。

加强、提高题:2、编写一个求解Josephus问题的函数。

用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人。

然后使用n = 9, s = 1, m = 5,以及n = 9, s = 1, m = 0,或者n = 9, s = 1, m = 10作为输入数据,检查你的程序的正确性和健壮性。

最后分析所完成算法的时间复杂度。

定义JosephusCircle类,其中含完成初始化、报数出圈成员函数、输出显示等方法。

(可以选做其中之一)加强题:(1)采用数组作为求解过程中使用的数据结构。

提高题:(2)采用循环链表作为求解过程中使用的数据结构。

运行时允许指定任意n、s、m数值,直至输入n = 0退出程序。

实验二栈、队列、递归应用一、实验目的1熟悉栈、队列这种特殊线性结构的特性2熟练掌握栈、队列在顺序存储结构和链表存储结构下的基本操作。

二、实验要求1实验之前认真准备,编写好源程序。

2实验中认真调试程序,对运行结果进行分析,注意程序的正确性和健壮性的验证。

3不断积累程序的调试方法。

三、实验内容基本题(必做):1分别就栈的顺序存储结构和链式存储结构实现栈的各种基本操作。

2、假设以带头结点的循环链表表示队列,并且只设一个指针指向对尾结点,不设头指针,试设计相应的置队空、入队和出队的程序。

加强题:3设线性表A中有n个字符,试设计程序判断字符串是否中心对称,例如xyzyx和xyzzyx都是中心对称的字符串。

数据结构主要研究内容

数据结构主要研究内容

数据结构主要研究内容数据结构是计算机科学中的一门基础课程,主要研究各种数据组织方式和数据操作算法。

它是计算机科学和技术领域的基础,对于编写高效的程序和解决实际问题具有重要的意义。

本文将介绍数据结构的主要研究内容,包括线性表、栈、队列、树、图等。

一、线性表线性表是数据结构中最基本的一种形式,它将一组数据元素按照线性顺序排列。

线性表的常见实现方式有顺序表和链表。

顺序表使用数组等连续的存储空间存储数据,而链表使用链式存储结构,通过节点之间的指针链接起来。

线性表的常见操作包括插入、删除、查找等。

二、栈栈是一种特殊的线性表,它的插入和删除操作只能在同一端进行,即“先入后出”。

栈的常见操作包括入栈和出栈。

入栈将元素放入栈顶,出栈将栈顶元素取出。

栈的应用非常广泛,例如函数调用栈、表达式求值等。

三、队列队列也是一种特殊的线性表,它的插入操作只能在队尾进行,删除操作只能在队首进行,即“先入先出”。

队列的应用场景包括多线程任务调度、模拟系统等。

队列的常见操作包括入队和出队。

四、树树是一种非线性的数据结构,由节点和节点之间的连接组成。

树的每个节点可以有零个或多个子节点。

树的应用非常广泛,包括文件系统、数据库索引等。

树的常见类型有二叉树、平衡树、红黑树等,每种类型都有相应的操作和算法。

五、图图是一种复杂的非线性数据结构,由节点和节点之间的边组成。

图的节点称为顶点,边表示两个顶点之间的关系。

图的应用包括社交网络分析、路径规划等。

图的常见操作包括遍历、最短路径算法等。

六、其他数据结构除了上述介绍的主要数据结构外,还有许多其他重要的数据结构,比如堆、散列表、图的邻接矩阵等。

每种数据结构都有自己的特点和应用场景,能够帮助解决各种不同类型的问题。

综上所述,数据结构主要研究包括线性表、栈、队列、树、图等各种数据组织方式和操作算法。

这些数据结构是计算机科学和技术领域中的基础,对于编写高效的程序和解决实际问题具有重要的意义。

熟练掌握各种数据结构的特点和应用能够帮助我们更好地进行程序设计和算法分析。

(完整版)数据结构线性表的主要程序代码

(完整版)数据结构线性表的主要程序代码

数据结构顺序表的主要代码(LIZHULIN)1./***有头结点的单链表的初始化、建立(表头插入、表尾插入)、求长度、插入、删除、输出***//***********单链表的初始化、建立、输出*****************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = NULL;}/*************建立一个带头结点的单链表,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p,*q; int i;Initlist(L); /*单链表初始化*/q=L;printf("input the value\n");for(i = n;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));scanf("%d",&p->data); /*输入元素值*/q->next = p;p->next = NULL;q=p;/*插入到表尾*/}} /* Create_L *//*************建立一个带头结点的单链表,在表头插入**************Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化/*需要注意第一个数据插入时的情况/*Insert the Firset nodep = (LinkList*)malloc(sizeof(struct Lnode));printf("input the value\n");scanf("%d",&p->data); /*输入元素值L->next = p;p->next = NULL;/*将第二个及后面的数据插入for(i = n-1;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));printf("input a value\n");scanf("%d",&p->data); /*输入元素值p->next = L->next;L->next = p;/*插入到表头}} /* Create_L *//*************************求单链表的长度***********************/int Length_LinkList(LinkList *L){LinkList *p;int i=0;p=L->next;while(p!=NULL){i++;p=p->next;}return i;}/*Length_LinkList*//*************************在第i个结点前插入数据x *********************/ Insert_LinkList(LinkList *L, int i, int x){LinkList *p,*s;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i,则无意义*//*插入元素x */s=(LinkList *)malloc(sizeof(struct Lnode));s->data=x;s->next=p->next;p->next=s;}/*********************删除第i个元素,并用y将其值返回************************/ int Delete_LinkList(LinkList *L, int i){LinkList *p,*q;int y;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i,则无意义*/q=p->next;y=q->data;p->next=q->next;free(q) ;return y;} /*Delete_LinkList*//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p!=NULL){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int len;int n=0;int x=15;int y;int i=4;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =NULL;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);Insert_LinkList(L, i, x);/* y=Delete_LinkList(L,i);printf("the delete elment is y=%d\n",y);len=Length_LinkList(L);printf("the length of L is %d",len);*/display(L);getch();}2./***无头结点的单链表建立、插入、求长度、插入、删除、输出*****/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;while(p!=NULL){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}3./*********顺序表的建立、查找、插入运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/*******Creat SqList********/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input SqList.data\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Position Error");return;}elsereturn L->data[i-1];}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *L;/*printf("input the length of SqList\n");scanf("%d",&len);*/Create_SqList(L);Display_SqList(L);getch();}4./*********顺序表的归并运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/************ Creat SqList*************/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input the data of SqList\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Getelem Position Error");return;}return L->data[i-1];}/************ Insert Operation *********/void ListInsert(SqList *L,int i, int x){SqList *q, *p;if(i<1 || i>L->length){printf("the insert position error");return ;}q = &(L->data[i-1]); /*q为插入位置*/for(p=&(L->data[L->length-1]); p>=q; --p)*(p+1) = *p;L->data[i-1] = x;++L->length;}/********* LA and LB Merged LC ***************/ void MergeList(SqList *LA,SqList *LB,SqList *LC) {int La_len,Lb_len,ai,bj;int i,j;int k;i=j=1;InitList(LC);La_len = ListLength(LA);Lb_len = ListLength(LB);LC->length = La_len+Lb_len;/*for(k=0;k<LC->length;k++)LC->data[k] = 0; */k=0;while((i<=La_len)&&(j<=Lb_len)){ai= GetElem(LA, i);bj= GetElem(LB, j);if(ai<bj){++k;ListInsert(LC,k,ai);++i;}elseif(ai==bj){++k;ListInsert(LC,k,ai);++k;ListInsert(LC,k,bj);++i;++j;}else{++k;ListInsert(LC,k,bj);++j;}}while(i<=La_len){/*Append the residual node into LA */ai= GetElem(LA, i);++i;++k;ListInsert(LC,k,ai);}while(j<=Lb_len){/*Append the residual node into LA */bj= GetElem(LB, j);++j;++k;ListInsert(LC,k,bj);}LC->length = La_len+Lb_len;}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *LA , *LB, *LC;Create_SqList(LA);Create_SqList(LB);MergeList(LA,LB,LC);Display_SqList(LC);getch();}5./**** 用带头结点的循环单链表解决约瑟夫问题***********/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = L;}/*************建立一个带头结点的循环单链表,数据值为1,2,3,...n,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化p=L;for(i = n;i>0;--i){q = (LinkList*)malloc(sizeof(struct Lnode));q->data = i; /*输入元素值p->next =qq->next = L;/*插入到表尾}} /* Create_L *//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p->next!=L){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int n;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =L;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);display(L);getch();}6./******** 无头结点的循环单链表的建立**************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}p->next = L;/*尾结点指向第一个结点*/}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;printf("%d ",p->data);p=p->next;while(p->next !=L){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/ main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}。

数据结构大纲知识点

数据结构大纲知识点

数据结构大纲知识点一、绪论。

1. 数据结构的基本概念。

- 数据、数据元素、数据项。

- 数据结构的定义(逻辑结构、存储结构、数据的运算)- 数据结构的三要素之间的关系。

2. 算法的基本概念。

- 算法的定义、特性(有穷性、确定性、可行性、输入、输出)- 算法的评价指标(时间复杂度、空间复杂度的计算方法)二、线性表。

1. 线性表的定义和基本操作。

- 线性表的逻辑结构特点(线性关系)- 线性表的基本操作(如初始化、插入、删除、查找等操作的定义)2. 顺序存储结构。

- 顺序表的定义(用数组实现线性表)- 顺序表的基本操作实现(插入、删除操作的时间复杂度分析)- 顺序表的优缺点。

3. 链式存储结构。

- 单链表的定义(结点结构,头指针、头结点的概念)- 单链表的基本操作实现(建立单链表、插入、删除、查找等操作的代码实现及时间复杂度分析)- 循环链表(与单链表的区别,操作特点)- 双向链表(结点结构,基本操作的实现及特点)三、栈和队列。

1. 栈。

- 栈的定义(后进先出的线性表)- 栈的基本操作(入栈、出栈、取栈顶元素等操作的定义)- 顺序栈的实现(存储结构,基本操作的代码实现)- 链栈的实现(与单链表的联系,基本操作的实现)- 栈的应用(表达式求值、函数调用栈等)2. 队列。

- 队列的定义(先进先出的线性表)- 队列的基本操作(入队、出队、取队头元素等操作的定义)- 顺序队列(存在的问题,如假溢出)- 循环队列的实现(存储结构,基本操作的代码实现,队空和队满的判断条件)- 链队列的实现(结点结构,基本操作的实现)- 队列的应用(如操作系统中的进程调度等)四、串。

1. 串的定义和基本操作。

- 串的概念(字符序列)- 串的基本操作(如连接、求子串、比较等操作的定义)2. 串的存储结构。

- 顺序存储结构(定长顺序存储和堆分配存储)- 链式存储结构(块链存储结构)3. 串的模式匹配算法。

- 简单的模式匹配算法(Brute - Force算法)的实现及时间复杂度分析。

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

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

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

数据结构课程设计----线性开型寻址散列查找、插入、删除

数据结构课程设计----线性开型寻址散列查找、插入、删除

山东大学软件学院数据结构课程设计报告设计题目:线性开型寻址散列查找、插入、删除学号—姓名___________年级___________专业______班级__________学期11-12学年第二学期日期:2012年月曰一、需求描述1.1散列表的研究意义:一般的线性表、树中,记录在结构中的相对位置是随机的即和记录的关键字之间不存在确定的关系,在结构中查找记录时需进行一系列和关键字的比较。

这一类查找方法建立在“比较”的基础上,查找的效率与比较次数密切相关。

理想的情况是能直接找到需要的记录,因此必须在记录的存储位置和它的关键字之间建立一个确定的对应关系f,使每个关键字和结构中一个唯一的存储位置相对应。

因而查找时,只需根据这个对应关系f找到给定值K的像f(K)。

若结构中存在关键字和K相等的记录,则必定在f(K)的存储位置上,由此不需要进行比较便可直接取得所查记录。

在此,称这个对应关系f为哈希函数,按这个思想建立的表为散列表(哈希表)。

1.2散列表的定义散列(Hash ):根据记录的关键字的值来确定其存储地址。

建立散列表,要在记录的存储地址和它的关键字之间建立一个确定的对应关系。

散列函数(Hash function ):在记录的关键字和记录的存储地址之间建立的一种对应关系。

散列函数是一种映像,是从关键字空间到存储地址空间的映像,可表示为Add (ai)=H(keyi)其中:ai是表中的一个记录,add(ai) 是ai的存储地址,keyi是ai的关键字。

冲突(collisio n) :不同的关键字经过散列函数计算后得到相同的地址,也就是说key1工key2,但是H(key1)=H(key2) 的现象叫做冲突。

具有相同函数值的几个关键字就称为该散列函数的同义词。

一般情况下,冲突只能减少,并不可避免。

当冲突发生时,就要设定一种处理冲突的办法。

散列表(Hash table ):应用散列函数和处理冲突的办法将一组关键字映像到一个有限的地址集上,并以关键字在地址集上的像作为记录在地址中的存储地址。

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
2.上机输入、调试实验程序;
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法,1为插入,2为删除,3为查询!4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);

数据结构实验报告-线性表

数据结构实验报告-线性表

1 线性表1. 实验题目与环境1.1实验题目及要求(1)顺序表的操作利用顺序存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。

(2)单链表的操作利用链式存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。

(3)线性表的应用约瑟夫环问题。

有n个人围坐一圈,现从某个人开始报数,数到M的人出列,接着从出列的下一个人开始重新报数,数到M的人又出列,如此下去,直到所有人都出列为止。

要求依次输出出列人的编码。

2.问题分析(1)顺序表的操作利用一位数组来描述顺序表,即将所有元素一词储存在数组的连续单元中,要在表头或中间插入一个新元素时,需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。

同理,删除开头或中间的元素时,则将其后的所有元素向前移动一个位置以填补空位。

查找元素时,则需要利用循环语句,一一判断直到找出所要查找的元素(或元素的位置),输出相关内容即可(2)单链表的操作利用若干个结点建立一个链表,每个节点有两个域,即存放元素的数据域和存放指向下一个结点的指针域。

设定一个头指针。

在带头结点的单链表中的第i个元素之前插入一新元素,需要计数找到第i-1个结点并由一指针p指向它,再造一个由一指针s指向的结点,数据为x,并使x的指针域指向第i个结点,最后修改第i-1个结点的指针域,指向x结点。

删除第i个元素时,需要计数寻找到第i个结点,并使指针p指向其前驱结点,然后删除第i个结点并释放被删除结点的空间。

查找第i个元素,需从第一个结点开始计数找到第i个结点,然后输出该结点的数据元素。

(3)线性表的应用程序运行之后,首先要求用户指定初始报数的上限值,可以n<=30,此题中循环链表可不设头结点,而且必须注意空表和"非空表"的界限。

实验一线性表操作实验报告

实验一线性表操作实验报告

实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。

2.掌握线性表的基本操作,包括插入、删除、查找等。

3.通过实验,提高动手能力和解决问题的能力。

二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。

线性表具有以下特点:1.元素之间一对一的顺序关系。

2.除第一个元素外,每个元素都有一个直接前驱。

3.除最后一个元素外,每个元素都有一个直接后继。

常见的线性表有数组、链表等。

本实验主要针对链表进行操作。

三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。

节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。

2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。

3.删除节点:删除链表中的一个指定节点。

4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。

5.遍历链表:从头节点开始,依次访问每个节点的数据。

四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。

2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。

插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。

3.删除节点结果:我们成功地删除了链表中的一个指定节点。

删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。

4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。

查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。

5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。

遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。

通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。

数据结构实验指导书

数据结构实验指导书

实验一线性表的基本操作一、实验目的线性表是最简单的一种线性结构,它有两种存储方法:顺序存储和链式存储。

实验目的如下:1、会定义线性表的顺序存储结构和链式存储结构。

2、熟悉顺序表和链表的一些基本操作和应用。

3、加深对线性表的理解,逐步培养解决实际问题的编程能力。

二、实验环境运行C或VC++的微机。

三、实验内容1.基本操作:●初始化线性表●向线性表指定位置插入元素●删除指定元素值的线性表记录●删除指定位置的线性表记录●查找线性表中的元素●输出线性表元素2.提高题目(1)已知线性表LA的数据元素(n个,n为偶数),现要求将LA 拆开成两个新的线性表LB,LC。

要求LB中的数据元素为LA中的奇数位序的数据元素(a1, a3, …, a n-1),LC中的数据元素为LA中的偶数位序的数据元素(a2, a4, …, a n)。

2. 已知线性表LA的数据元素(n个),现要求将LA的数据元素复制到另一个线性表LB中。

3. 设有一个线性表采用顺序存储结构,表中的数据元素值为正整数(n个)。

设在O(n) 时间内,将线性表分成两为两部分,其中左半部分每个元素都小于原表的第一个元素,而右半部分则相反。

4. 将一个头结点指针为a的单链表A分解成两个单链表A和B,其头结点指针分别为a和b,使得A链表中含有原链表中序号为奇数的元素,而B链表中含有原链表A中序号为偶数的元素,且保持原来的相对顺序。

5. 约瑟夫问题:设编号为1,2,…,n的n(n>0)个人按顺时针方向围坐一圈,每人持有一正整数密码。

开始时任选一个正整数作为报数上限值m,从第一个人开始顺时针方向自1起顺序报数,报到m 时停止报数,报m的人出列,将他的密码作为新的m值,从他在顺时针方向上的下一个人起重新从1报数。

如此下去,直到所有人全部出列为止。

令n最大值取30。

要求设计一个程序模拟此过程,求出出列编号序列(采用循环单链表结构)。

四、实验报告所有的基础操作和5到题目都需要课堂检查,直接打分。

数据结构实验一 顺序表的实现

数据结构实验一    顺序表的实现

cout <<v.elem[i] <<' '; cout <<endl; }
} default: flag=0; cout <<"程序结束,按任意键退出!" <<endl; } } } //初始化线性表 void initial(seqlist &v) { int i; cout <<"请输入初始线性表长度:n="; cin >>st; cout <<"请输入各元素/字符[中间用空格隔开](例如:a b c d): "; for(i=0;i<st;i++) cin >>&v.elem[i]; } //插入一个元素,成功返回True,失败返回False bool insert (seqlist &v,int loc,char ch) { int i; if((loc<1)||(loc>st+1)) { cout <<"插入位置不合理!" <<endl; //位置错误 return false; } else if(st>=Max) { cout <<"超出线性表最大容量!" <<endl; //溢满 return false; } else { for(i=st-1;i>=loc-1;i--) v.elem[i+1]=v.elem[i]; //插入位置后的元素后移 v.elem[loc-1]=ch; //插入元素 st++; //表长度加1
四、程序的调试及运行结果
五、程序代码

【数据结构】线性表的基本操作

【数据结构】线性表的基本操作

【数据结构】线性表的基本操作【数据结构】线性表的基本操作【一、概述】线性表是一种常见的数据结构,它是由一组具有相同特性的数据元素组成的有序序列。

线性表的基本操作包括插入、删除、查找和修改等操作,本文将对这些操作进行详细介绍。

【二、插入操作】插入操作是向线性表中某个位置插入一个新元素的操作。

插入操作包括头部插入、尾部插入和中间插入三种情况。

首先需要确定插入的位置,然后将插入位置后的元素依次向后移动一位,最后在插入位置处放入新元素。

1.头部插入:将新元素插入线性表的头部位置。

2.尾部插入:将新元素插入线性表的尾部位置。

3.中间插入:将新元素插入线性表的任意中间位置。

【三、删除操作】删除操作是从线性表中删除某个元素的操作。

删除操作包括删除头部元素、删除尾部元素和删除中间元素三种情况。

首先需要确定删除的位置,然后将删除位置后的元素依次向前移动一位,最后删除最后一个元素位置上的元素。

1.删除头部元素:删除线性表的头部元素。

2.删除尾部元素:删除线性表的尾部元素。

3.删除中间元素:删除线性表的任意中间位置的元素。

【四、查找操作】查找操作是在线性表中搜索某个元素的操作。

查找操作包括按值查找和按位置查找两种情况。

1.按值查找:根据给定的元素值,在线性表中搜索并返回该元素的位置。

2.按位置查找:根据给定的位置,返回该位置上的元素值。

【五、修改操作】修改操作是修改线性表中某个元素的值的操作。

需要先找到要修改的元素位置,然后将其值修改为新的值。

【附件】本文档涉及附件略。

【法律名词及注释】本文档所涉及的法律名词及注释略。

归纳总结线性表的基本操作

归纳总结线性表的基本操作

归纳总结线性表的基本操作线性表是计算机科学中常用的数据结构,它是由一组具有相同特性的数据元素组成的有序序列。

线性表的基本操作包括插入、删除、查找和修改等操作。

在本文中,我将对线性表的基本操作进行归纳总结,以帮助读者更好地理解和使用线性表。

一、插入操作插入操作是指向线性表中插入一个新的元素。

常见的插入方式包括在指定位置插入元素和在表尾插入元素。

1. 在指定位置插入元素要在线性表的指定位置插入一个元素,需要将插入位置之后的元素依次向后移动一位,然后将欲插入的元素放入空出来的位置。

具体的步骤如下:(1)判断插入位置的合法性,如果位置无效则报错;(2)将插入位置之后的元素依次向后移动一位;(3)将欲插入的元素放入插入位置。

2. 在表尾插入元素要在线性表的表尾插入一个元素,只需要将元素直接放入表尾即可。

二、删除操作删除操作是指从线性表中删除一个元素。

常见的删除方式包括删除指定位置的元素和删除指定元素的操作。

1. 删除指定位置的元素要删除线性表中的某一个元素,需要将该元素之后的元素依次向前移动,然后将最后一个位置置空。

具体步骤如下:(1)判断删除位置的合法性,如果位置无效则报错;(2)将删除位置之后的元素依次向前移动一位;(3)将最后一个位置置空。

2. 删除指定元素要删除线性表中某一个指定的元素,需要遍历整个线性表,找到该元素的位置,然后按照删除指定位置的元素的操作进行删除。

三、查找操作查找操作是指在线性表中寻找某一个元素。

常见的查找方式包括按位置查找和按值查找。

1. 按位置查找要按位置查找线性表中的某一个元素,只需要通过给定的位置,直接访问该位置上的元素即可。

2. 按值查找要按值查找线性表中的某一个元素,需要遍历整个线性表,逐个比较每个元素的值,直到找到目标元素或者遍历结束。

四、修改操作修改操作是指修改线性表中某一个元素的值。

常见的修改方式是通过给定的位置,直接修改该位置上的元素的值。

综上所述,线性表的基本操作包括插入、删除、查找和修改等操作。

数据结构(第二章 线性表)

数据结构(第二章 线性表)

2.2 线性表的顺序存储和实现
顺序表-顺序表定义

由上可知,数据的存储逻辑位置由数组的下标决定。 所以相邻的元素之间地址的计算公式为(假设每个数 据元素占有d个存储单元): LOC(ai)=LOC(ai-1)+d 对线性表的所有数据元素,假设已知第一个数据元 素a0的地址为LOC(a0) ,每个结点占有d个存储 单元, 则第i个数据元素ai的地址为: LOC(ai)=LOC(a0)+i*d 线性表的第一个数据元素的位置通常称做起始位置 或基地址。 在使用一维数组时,数组的下标起始位置根据给定 的问题确定,或者根据实际的高级语言的规定确定。
2.1 线性表抽象数据类型
线性表的分类
顺序存储结构 (元素连续存储、 随机存取结构) 线性表 ADT 链式存储结构 (元素分散存储) 继承 顺序表类 排序顺序表类 继承 单链表类 循环单链表 双链表 继承 排序循环双链表类 排序单链表类

单链表
双链表

循环双链表类
线性表的存储结构
2.2 线性表的顺序存储和实现
线性表的基本操作 求长度:求线性表的数据元素个数。 访问:对线性表中指定位置的数据元素进行存取、替 换等操作。 插入:在线性表指定位置上,插入一个新的数据元素, 插入后仍为一个线性表。 删除:删除线性表指定位置的数据元素,同时保证更 改后的线性表仍然具有线性表的连续性。 复制:重新复制一个线性表。 合并:将两个或两个以上的线性表合并起来,形成一 个新的线性表。 查找:在线性表中查找满足某种条件的数据元素。 排序:对线性表中的数据元素按关键字值,以递增或 递减的次序进行排列。 遍历:按次序访问线性表中的所有数据元素,并且每 个数据元素恰好访问一次。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

创建一个线性表实现输入,输出,插入,删除,定位。

(注意:不论在调用哪个函数前,都要先使L.elem=a,就是使指针elem回到数组a的首地址。


#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10 //线性表存储空间的分配增量
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int ElemType; //接下来ElemType代表的就是int
typedef int Status; //Status也代表int
int i,*p,*q; //p,q都是指针类型
ElemType e;
typedef struct
{
ElemType *elem; //定义成指针类型//存储空间基址
int length; //当前长度
int listsize; //当前分配的存储容量(以sizeof(ElemType)为单位) }SqList;
//***********************构建空的线性表*************************// Status InitList_Sq(SqList &L) //构建一个空的线性表L
{
L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem) exit(OVERFLOW); //存储分配失败
L.length=0; //空表长度为0
L.listsize=LIST_INIT_SIZE; //初始存储容量
return OK;
}
//**************************线性表输入函数*********************//
void input(SqList &L) //输入函数
{
scanf("%d",L.elem); //要先输入一个,不然一开始就是0,无法进行循环while(*L.elem) // 加*是因为elem是指针,加之后才代表值{
L.elem++; //输入后指针后移
L.length++; //表长加1
scanf("%d",L.elem); //循环中也要再输入
}
}
//**************************线性表打印函数********************//
void print(SqList &L) //输出函数
{
int n;
for(n=0;n<L.length;n++)
{
printf("%d\t",*L.elem);
L.elem++; //输出后指针后移
}
}
//***********线性表插入函数(在第i个位置插入一个数据e)*************// Status ListInsert_Sq(SqList &L,int i,ElemType e)//插入函数
{
//在顺序线性表L中第i个位置之前插入新的元素e
//i的合法值为1<=i<=ListLength.Sq(L)+1
Status *newbase;指针类型。

因为elem是指针类型
if(i<1||i>L.length+1) return ERROR; //i值不合法
if(L.length>=L.listsize) //当前存储空间已满,增加分配{
newbase=(ElemType *)realloc(L.elem,
(L.listsize+LISTINCREMENT)*sizeof(ElemType));
//分配存储空间
if(!newbase) exit(OVERFLOW); //存储分配失败,跳回操作系统
L.elem=newbase; //新基址
L.listsize+=LISTINCREMENT; //增加存储容量}
q=&(L.elem[i-1]); //q为插入位置
for(p=&(L.elem[L.length-1]);p>=q;--p)
*(p+1)=*p; //插入位置及之后的元素右移*q=e; //插入e
++L.length; //表长增加1
return OK;
}
//*********线性表删除函数(删除第i个位置,并用e返回删除的数据)********// Status ListDelete_Sq(SqList &L,int i,ElemType &e)//删除函数引用调用
{
//在顺序线性表L中删除第i个元素,并用e返回其值
//i的合法值为1<=i<=ListLength.Sq(L)
if((i<1)||(i>L.length))
return ERROR; //i值不合法p=&(L.elem[i-1]); //p为被删除元素的位置e=*p; //被删除元素的值赋给e q=L.elem+L.length-1; //表尾元素的位置
for(++p;p<=q;++p)
*(p-1)=*p; //在被删除元素位置后面的元素左移--L.length; //表长减1
return OK;
}
//****线性表查找(定位)函数(找到第1个与e相等的值,返回其位置i)********// int LocateElem_Sq(SqList L,ElemType e,
Status(*compare)(ElemType,ElemType))//定位函数
{
//在顺序线性表L中查找第1个值与e满足compare()的元素的位序
//若找到,则返回其在L中的位序,否则返回0
i=1; //i的初值为第1个元素的位序p=L.elem; //p的初值为第1个元素的存储位置while(i<=L.length&&!(*compare)(*p++,e)) ++i; //将表L中的元素依次与e进行比较
if(i<=L.length) return i;
else return 0;
}
//**************************比较函数*******************************// Status Compare(ElemType m,ElemType e) //比较的是实数,不用定义成指针{
if(m==e)
return OK;
else
return ERROR;
}
//*********************主函数**********************//
void main()
{
SqList L;
int a[100];
if(InitList_Sq(L))
{
L.elem=a; //将数组的首地址赋给指针elem
printf("请输入数据:\n");
input(L); //输入线性表L }
L.elem=a; //指针elem回到数组首地址,//因为在用的过程中指针已经移动,所以必须归位,才能再从第一个用起。

printf("您输入的数据为:\n");
print(L); //输出线性表L
printf("\n");
printf("请输入插入元素的位置:");
scanf("%d",&i);
printf("请输入新元素:");
scanf("%d",&e); //指针elem回到数组首地址L.elem=a;
if(ListInsert_Sq(L,i,e)) //在指定位置插入待插入元素{
printf("插入元素后的表含%d个元素:\n",L.length);
L.elem=a;
print(L); //输出插入元素后的新表L }
printf("\n");
L.elem=a; //指针elem回到数组首地址printf("请输入删除元素的位置:");
scanf("%d",&i);
if(ListDelete_Sq(L,i,e)) //删除指定元素
{
printf("您删除的元素为:%d\n",e);
printf("删除元素后的表含%d个元素\n",L.length);
L.elem=a; //指针elem回到数组首地址
print(L); //输出删除元素后的新表L }
printf("\n");
L.elem=a; //指针elem回到数组首地址printf("请输入您要找的元素的值:");
scanf("%d",&e);
if(LocateElem_Sq(L,e,Compare)) //找出指定元素在表L中的位序printf("元素%d在顺序线性表L的位序为:%d\n",e,i);
else
printf("您输入的元素不在表L中\n");
}。

相关文档
最新文档