数据结构-顺序表的查找插入与删除
《数据结构》实验指导书
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.二叉树的二叉链表存储结构
顺序表的实现实验报告
顺序表的实现实验报告顺序表的实现实验报告1. 引言顺序表是一种常见的数据结构,它可以用于存储一组有序的元素。
在本实验中,我们将探索顺序表的实现方式,并通过实验验证其性能和效果。
2. 实验目的本实验的主要目的是掌握顺序表的实现原理和基本操作,并通过实验对比不同操作的时间复杂度。
3. 实验方法3.1 数据结构设计我们选择使用静态数组作为顺序表的底层存储结构。
通过定义一个固定大小的数组,我们可以实现顺序表的基本操作。
3.2 基本操作实现在顺序表的实现中,我们需要实现以下基本操作:- 初始化操作:创建一个空的顺序表。
- 插入操作:向顺序表中插入一个元素。
- 删除操作:从顺序表中删除一个元素。
- 查找操作:在顺序表中查找指定元素。
- 获取长度:获取顺序表中元素的个数。
4. 实验步骤4.1 初始化操作首先,我们需要创建一个空的顺序表。
这可以通过定义一个数组和一个变量来实现,数组用于存储元素,变量用于记录当前顺序表的长度。
4.2 插入操作在顺序表中插入一个元素的过程如下:- 首先,判断顺序表是否已满,如果已满则进行扩容操作。
- 然后,将要插入的元素放入数组的末尾,并更新长度。
4.3 删除操作从顺序表中删除一个元素的过程如下:- 首先,判断顺序表是否为空,如果为空则返回错误信息。
- 然后,将数组中最后一个元素删除,并更新长度。
4.4 查找操作在顺序表中查找指定元素的过程如下:- 首先,遍历整个数组,逐个比较元素与目标元素是否相等。
- 如果找到相等的元素,则返回其位置;如果遍历完仍未找到,则返回错误信息。
4.5 获取长度获取顺序表中元素个数的过程如下:- 直接返回记录长度的变量即可。
5. 实验结果与分析在实验中,我们通过对大量数据进行插入、删除、查找等操作,记录了每个操作的耗时。
通过对比不同操作的时间复杂度,我们可以得出以下结论:- 初始化操作的时间复杂度为O(1),因为只需要创建一个空的顺序表。
- 插入和删除操作的时间复杂度为O(n),因为需要遍历整个数组进行元素的移动。
数据结构大纲知识点
数据结构大纲知识点一、绪论。
1. 数据结构的基本概念。
- 数据、数据元素、数据项。
- 数据结构的定义(逻辑结构、存储结构、数据的运算)- 数据结构的三要素之间的关系。
2. 算法的基本概念。
- 算法的定义、特性(有穷性、确定性、可行性、输入、输出)- 算法的评价指标(时间复杂度、空间复杂度的计算方法)二、线性表。
1. 线性表的定义和基本操作。
- 线性表的逻辑结构特点(线性关系)- 线性表的基本操作(如初始化、插入、删除、查找等操作的定义)2. 顺序存储结构。
- 顺序表的定义(用数组实现线性表)- 顺序表的基本操作实现(插入、删除操作的时间复杂度分析)- 顺序表的优缺点。
3. 链式存储结构。
- 单链表的定义(结点结构,头指针、头结点的概念)- 单链表的基本操作实现(建立单链表、插入、删除、查找等操作的代码实现及时间复杂度分析)- 循环链表(与单链表的区别,操作特点)- 双向链表(结点结构,基本操作的实现及特点)三、栈和队列。
1. 栈。
- 栈的定义(后进先出的线性表)- 栈的基本操作(入栈、出栈、取栈顶元素等操作的定义)- 顺序栈的实现(存储结构,基本操作的代码实现)- 链栈的实现(与单链表的联系,基本操作的实现)- 栈的应用(表达式求值、函数调用栈等)2. 队列。
- 队列的定义(先进先出的线性表)- 队列的基本操作(入队、出队、取队头元素等操作的定义)- 顺序队列(存在的问题,如假溢出)- 循环队列的实现(存储结构,基本操作的代码实现,队空和队满的判断条件)- 链队列的实现(结点结构,基本操作的实现)- 队列的应用(如操作系统中的进程调度等)四、串。
1. 串的定义和基本操作。
- 串的概念(字符序列)- 串的基本操作(如连接、求子串、比较等操作的定义)2. 串的存储结构。
- 顺序存储结构(定长顺序存储和堆分配存储)- 链式存储结构(块链存储结构)3. 串的模式匹配算法。
- 简单的模式匹配算法(Brute - Force算法)的实现及时间复杂度分析。
数据结构(八)查找
99
250
110
300
280
类C程序实现: void InsertBST(*&t,key) //在二叉排序树中插入查找关键字key { if(t= = NULL){ t=new BiTree; t->lchild=t->rchild=NULL; t->data=key; return; } if(key<t->data ) InsertBST(t->lchild,key); else InsertBST (t->rchild, key ); } void CreateBiTree(tree,d[ ],n) //n个数据在数组d中,tree为二叉排序树根 { tree=NULL; for(i=0;i<n;i++) InsertBST(tree,d[i]); }
p q
void delete(*&p) { if(p->rchild = = NULL) { q=p; p=p->lchild; delete q; } else if(p->lchild= =NULL) { q=p; p=p->rchild; delete q; } else { q=p; s=p->lchild; while(s->rchild!=NULL) {q=s; s=s->rchild;} p->data=s->data; if(q!=p) q->rchild=s->lchild; else q->lchild=s->lchild; } delete s; }
在xL中选值最大的代替x,该数据按二叉排序树的性质应在 最右边。
f x f s c
数据结构实验一顺序表
数据结构实验一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;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。
数据结构顺序表实验报告
创作编号:GB8878185555334563BT9125XW创作者:凤呜大王*洛阳理工学院实验报告la=&l;Input(la,la->last+1);Output(la);//按内容查找元素printf("请输入要查找的元素值:\n");scanf("%d",&q);p=Locate(l,q);if(p == -1)printf("在此线性表中没有该元素! \n");elseprintf("该元素在线性表中的位置为:%d \n",p);//插入元素(在i处插入元素e)printf("请输入要插入的位置:\n");scanf("%d",&k);printf("请输入要插入的元素值:\n");scanf("%d",&j);InsList(la,k,j); //调用插入函数Output(la);//删除元素删除第i个元素printf("请输入需要删除的元素的位置:\n");scanf("%d",&m);DelList(la,m,&num);printf("删除成功,删除的元素为%d",num);printf("\n");Output(la);}5.测试数据及结果实验总结:经过调试与测试,实验结果与测试预期一致。
顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。
线性表采用顺序存储的方式存储就称之为顺序表。
顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
创作编号:GB8878185555334563BT9125XW创作者:凤呜大王*。
数据结构 顺序表 实验报告
实验报告运行结果:实验总结:对顺序表的理论知识了解还不够透彻,导致在做顺序表实验的时候无从下手,认真查看教程及实验指导后才知道该如何下手敲写代码;此次实验让我发现自己对上学期所学的java语言知识内容遗忘较多,为方便更好地学习数据结构,只能在课后复习java内容。
附:源程序:package seqList;public class SequenceList<T> {private T[] elements; // 元素private final int maxSize = 10; // 最大容量private int length; // 长度//无参构造方法public SequenceList() {length = 0;elements = (T[]) new Object[maxSize];}//有参构造方法public SequenceList(int n) {if (n <= 0) {System.out.println("errors");System.exit(1);}length = 0;elements = (T[]) new Object[n];}//判断表是否为空public boolean isEmpty() {return elements.length==0;}public int size() {return length;}//插入public boolean add(T obj, int pos) {// 判断pos是否合法if (pos < 1 || pos > length + 1) {System.out.print("pos值不合法");return false;}// 判断空间是否已满if (elements.length == length) {T[] p = (T[]) new Object[length * 2];for (int i = 0; i < elements.length; i++) { p[i] = elements[i];}elements = p;}// 开始插入for (int i = length; i >= pos; i--) {elements[i] = elements[i - 1];}elements[pos - 1] = obj;length++;return true;}//删除public T remove(int pos) {// 判断是否为空表if (isEmpty()) {System.out.println("顺序表为空,无法删除");return null;}// 判断pos是否合法if (pos < 1 || pos > length) {System.out.print("pos不合法");return null;}// 开始删除T x = elements[pos - 1];for (int i = pos; i < elements.length; i++) { elements[i - 1] = elements[i];}length--;return x;}//查找public int find(T obj) {// 判断是否为空表if (isEmpty()) {System.out.println("顺序表为空,无法查找");return -1;} else {for (int i = 0; i < elements.length; i++) { if (elements[i].equals(obj))return i + 1;}return 1;}}//查找public T value(int pos) {if(isEmpty()) {System.out.println("顺序表为空");return null;}if(pos<1||pos>elements.length) {System.out.println("pos值不合法");return null;}return elements[pos-1];}//更新public boolean modify(T obj,int pos) {if(isEmpty()) {System.out.println("顺序表为空");return false;}if(pos<1||pos>elements.length) {System.out.println("pos值不合法");return false;}elements[pos-1]=obj;return true;}//输出public void ListOut() {for (int i = 0; i < elements.length; i++) {System.out.print(elements[i]+" ");}}//验证public static void main(String[] args) {SequenceList<Integer> list1 = new SequenceList<Integer>();for (int i = 1; i <= 10; i++) {list1.add(i * 2, i);}System.out.println("顺序表为:");list1.ListOut();System.out.println();System.out.print("删除的数为:");System.out.println(list1.remove(3));System.out.println("插入后表为:");if (list1.add(100, 6)) {list1.ListOut();System.out.println();}else {System.out.println("不能插入");}System.out.print("元素8的位置为:");System.out.println(list1.find(8));System.out.print("位置为4的元素为:");System.out.println(list1.value(4));System.out.println("更新后的泛型数组为:");if (list1.modify(7, 9)) {list1.ListOut();System.out.println();}else {System.out.println("更新不合法");}// TODO Auto-generated method stub }}。
数据结构中顺序表的基本操作
数据结构中顺序表的基本操作
顺序表是一种线性表的存储结构,使用一组连续的存储单元来存储元素,其基本操作包括:
1. 初始化:创建一个空顺序表,设置其长度为0。
2. 插入元素:在顺序表的指定位置插入一个元素,需要将插入位置之后的元素依次向后移动,然后将新元素放入插入位置,并更新顺序表的长度。
3. 删除元素:删除顺序表中的指定位置的元素,需要将删除位置之后的元素依次向前移动,然后更新顺序表的长度。
4. 查找元素:根据元素的值,查找顺序表中第一个与该值相等的元素,并返回其位置。
如果不存在,则返回-1。
5. 获取元素:根据位置,返回顺序表中指定位置的元素。
6. 修改元素:根据位置,修改顺序表中指定位置的元素。
7. 清空顺序表:将顺序表的长度设置为0,即清空元素。
这些基本操作可以根据具体需求进行使用和扩展。
顺序表的基本操作与应用实验报告
实验报告课程名称数据结构实验名称顺序表基本操作与应用姓名专业班级学号试验日期试验地点E3-502指导老师邹汉斌成绩一、实验目的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) 根据指定学生个数,逐个输入学生信息;(2) 逐个显示学生表中所有学生的相关信息;(3) 根据姓名进行查找,返回此学生的学号和成绩;(4) 根据指定的位置可返回相应的学生信息(学号,姓名,成绩);(5) 给定一个学生信息,插入到表中指定的位置;(6) 删除指定位置的学生记录;(7) 统计表中学生个数。
实验提示:第2题可在第1题的基础上将数据结构的定义修改成下面形式后,程序适当修改即可。
学生信息的定义:typedef struct {char no[8]; //8位学号char name[20]; //姓名int score; //成绩}Student;typedef Student ElemType;顺序表的定义typedef struct {ElemType *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList;四、思考与提高1.编写程序完成下面的操作:(每位同学必做)(1)构造两个顺序线性表La和Lb,其元素都按值非递减顺序排列;(2)实现归并La和Lb得到新的顺序表Lc,Lc的元素也按值非递减顺序排列;(3)假设两个顺序线性表La和Lb 分别表示两个集合A和B,利用union_Sq操作实现A=A∪B。
顺序表的查找插入与删除实验报告
顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。
设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。
具体内容同时实现建议:1.从键盘输入10个整数,产生顺序表,并输入结点值。
2.从键盘输入1个整数,在顺序表搜寻该结点的边线。
若找出,输入结点的边线;若打听不到,则显示“找不到”。
3.从键盘输入2个整数,一个则表示欲填入的边线i,另一个则表示欲填入的数值x,将x挂入在对应位置上,输出顺序表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。
二、源程序及注解:#include#include/*顺序表的定义:*/#include#definelistsize100/*表空间大小可根据实际需要而定,这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值:\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置:\scanf(\printf(\输入要插入的元素:\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置:\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建:*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印:*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找:*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入:*/voidinsertlist(seqlist*l,datatypex,inti){intj;if(i<1||i>l->length+1){printf(\插入位置非法\\n\exit(0);}if(l->length>=listsize){printf(\表空间溢出,退出运行\\n\exit(0);}for(j=l->length-1;j>=i-1;j--)l->data[j+1]=l->data[j];l->data[i-1]=x;l->length++;}/*顺序表的删除:*/voiddeletelist(seqlist*l,inti){intj;if(l->length==0){printf(\现行表为空,退出运行\\n\exit(0);}if(i<1||i>l->length){printf(\删除位置非法\\n\exit(0);}for(j=i;j<=l->length-1;j++)l->data[j-1]=l->data[j];l->length--;}3三、运行输出结果:四、调试和运行程序过程中产生的问题及采取的措施:4。
数据结构上机实验指导
《数据结构》课程上机实验指导书实验一【实验名称】顺序表的基本算法【实验目的】创建一个顺序表,掌握线性表顺序存储的特点。
设计和验证顺序表的查找、插入、删除算法。
【实验要求】(1)从键盘读入一组整数,按输入顺序形成顺序表。
并将创建好的顺序表元素依次打印在屏幕上。
(2)设计一个带选择菜单的主函数,菜单中具备任意选择删除、插入、查找数据元素的功能。
(3)当选择删除功能时,从键盘读入欲删除的元素位置或元素值,按指定方式删除;当选择插入功能时,从键盘读入新元素值和被插入位置,在指定位置插入;当选择查找功能时,从键盘读入欲查找的元素值,返回其位置序号。
(4)每种操作结束后,都能在屏幕上打印出此时顺序表元素的遍历结果。
【实验步骤】1、实验前先写好算法。
2、上机编写程序。
3、编译。
4、调试。
例程:书上参考算法2-1,2-4,2-5,2-6,2-8!带菜单的主函数参考书上2.5综合实例!注意:顺序表的结构体!typedef struct{datatype items[listsize];int length;}SpList;实验二【实验名称】单链表的基本算法【实验目的】创建一个单链表,掌握线性表链式存储的特点。
设计和验证链表的查找、插入、删除、求表长的算法。
【实验要求】(1)从键盘读入一组整数,按输入顺序形成单链表。
并将创建好的单链表元素依次打印在屏幕上。
(注意:选择头插法或者尾插法!)(2)设计一个带选择功能菜单的主函数,菜单中至少具备任意选择删除、插入、查找数据元素,和求单链表表长等几项功能。
(3)当选择删除功能时,从键盘读入欲删除的元素位置,按指定位置删除;当选择插入功能时,从键盘读入新元素值和被插入位置,在指定位置插入;当选择查找功能时,从键盘读入欲查找的元素值,返回其位置序号;当选择求表长功能时,返回该单链表表长的数值。
(4)每种操作结束后,都能在屏幕上打印出此时单链表元素的遍历结果。
【实验步骤】1、实验前先写好算法。
数据结构实验报告(实验)
深 圳 大 学 实 验 报 告课程名称: 数据结构实验与课程设计 实验项目名称: 实验一:顺序表的应用 学院: 计算机与软件学院 专业: 指导教师: **报告人: 文成 学号: ********** 班级: 5 实验时间: 2012-9-17实验报告提交时间: 2012-9-24教务部制一、实验目的与要求:目的:1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求:1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容:Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行插入操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行删除操作后,顺序表内的所有数据,数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置,对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据,数据是小于100的正整数第三行输入两个参数,表示要交换的两个位置第四行输入两个参数,表示要交换的两个位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行第一次交换操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行第二次交换操作后,顺序表内的所有数据,数据之间用空格隔开注意加入交换位置的合法性检查,如果发现位置不合法,输出error。
数据结构实验报告-线性表
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,此题中循环链表可不设头结点,而且必须注意空表和"非空表"的界限。
数据结构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; } 运行及结果:
数据结构实验报告之链表顺序表的操作
数据结构实验报告之链表顺序表的操作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 }。
数据结构 查找
生成二叉排序树过程。
10 3 2 7 8 18 12
注:二叉排序树与关键字排列顺序有关,排列顺 序不一样,得到的二叉排序树也不一样。
二叉排序树的建立的算法
反复调用二叉排序树的插入算法即可 Bitree Creat (int n) { //建立含有n个结点的二叉排序树
Bitree T= NULL;
for ( int i=1; i<=n; i++) {
else if LT(key,p->key) p->lchild=s;
else p->rchild=s
return TRUE; }
//被插结点*s为右孩子
else return FALSE;
}// Insert BST
//树中已有关键字相同的结点,不再插入
4)二叉排序树的建立
例:关键字序列{ 10、18、3、8、12、2、7、3 }
5)二叉排序树上的删除
对于二叉排序树,删去树上一个结点相当于删去有序 序列中的一个记录,在删除某个结点之后依旧要保持二叉 排序树的特性。
如何在二叉排序树上删去一个结点呢?
设在二叉排序树上被删结点为*p(指向结点的指针为 p),其双亲结点为*f,设*p是*f的左孩子。 f F p P c PR C q Q s CL S QL SL
low
( 08,
( 08,
mid
14,
14,
high
55, 68, 79,
79,
23,
23,
37,
37,
46,
46,
91 )
low
55,
mid
68,
high
91 )
low mid
顺序表的建立、输入、输出、查找、插入、删除(数据结构)
顺序表的建⽴、输⼊、输出、查找、插⼊、删除(数据结构)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。
数据结构和算法课程设计题目
北方民族大学课程设计课程名称:数据结构与算法院(部)名称:信息与计算科学学院组长姓名学号同组人员姓名指导教师姓名:纪峰设计时间:2010.6.7----2009.6.27一、《数据结构与算法》课程设计参考题目(一)参考题目一(每位同学选作一个,同组人员不得重复)1、编写函数实现顺序表的建立、查找、插入、删除运算。
2、编写函数分别实现单链表的建立、查找、插入、删除、逆置算法。
3、编写函数实现双向链表的建立、插入、删除算法。
4、编写函数实现顺序栈的进栈、退栈、取栈顶的算法。
5、编写函数实现链栈的进栈、退栈、取栈顶的算法。
6、编写函数实现双向顺序栈的判空、进栈、出栈算法。
7、编写函数实现循环队列的判队空、取队头元素、入队、出队算法。
8、编写函数实现链环队列的判队空、取队头节点、入队、出队算法。
9、编写函数实现串的,求串长、连接、求字串、插入、删除等运算。
10、分别实现顺序串和链串的模式匹配运算。
11、实现二叉树的建立,前序递归遍历和非递归遍历算法。
12、实现二叉树的建立,中序递归遍历和非递归遍历算法。
13、实现二叉树的建立,后序递归遍历和非递归遍历算法。
14、实现二叉树的中序线索化,查找*p结点中序下的前驱和后继结点。
15、分别以临接表和邻接矩阵作为存储就够实现图的深度优先搜索和广度优先搜索算法。
16、利用线性探测处理冲突的方法实现散列表的查找和插入算法。
(二)参考题目二(每三人一组,任选三个题目完成)1.运动会分数统计(限1人完成)任务:参加运动会有n个学校,学校编号为1……n。
比赛分成m个男子项目,和w个女子项目。
项目编号为男子1……m,女子m+1……m+w。
不同的项目取前五名或前三名积分;取前五名的积分分别为:7、5、3、2、1,前三名的积分分别为:5、3、2;哪些取前五名或前三名由学生自己设定。
(m<=20,n<=20)功能要求:1)可以输入各个项目的前三名或前五名的成绩;2)能统计各学校总分,3)可以按学校编号或名称、学校总分、男女团体总分排序输出;4)可以按学校编号查询学校某个项目的情况;可以按项目编号查询取得前三或前五名的学校。
数据结构实验报告 顺序表基本操作
四、实验步骤
一 1. 编 写 头 文 件 。 定 义 数 据 类 型 。 分 别 写 各 个 函 数 如 ListInsern_Sq , ListDelete_Sq,LocateElem 等函数。 2.编写主函数。 在主函数里构造空的线性表, 然后利用 ListInsert 函数使用户 初始化线性表。然后调用函数操作,操作结果用 PrintList_Sq 打印出线性表的内 容 3.运行程序,完整代码见下:
-4-
else { printf("输入位置有错! \n"); printf("-------------------------------------\n"); }/**/ printf("请输入你要删除的元素的位置:\n");//删除元素 scanf("%d",&i); if(ListDelete_Sq(La,i,e)) { printf("你删除的元素为: %d,删除元素后线性表为:\n",e); PrintList_Sq(La); printf("-------------------------------------\n"); } else { printf("输入位置有错! \n"); printf("-------------------------------------\n"); } printf("请输入你要查找的元素:\n");//查找元素 scanf("%d",&e); if(i=LocateElem_Sq(La,e,cmp)) { printf("你要查找的元素在第 %d 个位置。\n",i); printf("-------------------------------------\n"); } else { printf("找不到这个元素: \n"); printf("-------------------------------------\n"); } if(ClearList_Sq(La))//清空线性表 { printf("线性表已清空。 \n"); printf("--------------------------------------\n"); } else { printf("线性表清空出错。 \n"); printf("--------------------------------------\n"); } if(Destroy_Sq(La))//撤销线性表
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
/*顺序表的打印:*/
void PrintList(SeqList L,int n)
{
int i;
for(i=0;i<L.length;i++)
cout<<L.data[i]<<endl;
}
/*顺序表的查找:*/
int LocateList(SeqList L,DataType x)
typedef int DataType;/*DataType可以是任何相应的数据类型如int, float或char*/
typedef struct
{DataType data[ListSize];/*向量data用于存放表结点*/
int length;/*当前的表长度*/
}SeqList;
void main()
一、上机实验的问题和要求:
顺序表的查找、插入与删除。设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。具体实现要求:
1.从键盘输入10个整数,产生顺序表,并输入结点值。
2.从键盘输入1个整数,在顺序表中查找该结点的位置。若找到,输出结点的位置;若找不到,则显示“找不到”。
3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出顺序表所有结点值,观察输出结果。
i=LocateList(L,x);/*顺序表查找*/
printf("输入要插入的位置:");
scanf("%d",&i);
printf("输入要插入的元素:");
scanf("%d",&x);
InsertList(&L,x,i);/*顺序表插入*/
PrintList(L,n);/*打印顺序表*/
printf("输入要删除的位置:");
scanf("%d",&i);
DeleteList(&L,i);/*顺序表删除*/
PrintList(L,n);/*打印顺序表*/
}
/*顺序表的建立:*/
void CreateList(SeqList *L,int n)
{
int i;
for(i=0;i<n;i++)
scanf ("%d",&L->data[i]);
{
SeqList L;
int i,x;
int n=10;/*欲建立的顺序表长度*/
L.length=0;
void CreateList(SeqList *L,int n);
void PrintList(SeqList L,int ;
int LocateList(SeqList L,DataType x);
{
int i=0;
while (i<L.length && L.data [i]!=x)
++i;
if (i<L.length)
return i+ 1;
else return 0;
}
/*顺序表的插入:*/
void InsertList(SeqList *L,DataType x,int i)
{
int j;
{
printf("删除位置非法\n");
exit(0);
}
for(j=i;j<=L->length -1;j++)
L->data[j-1]=L->data[j];
L->length --;
}
三
四
L->data[i-1]=x;
L->length++;
}
/*顺序表的删除:*/
void DeleteList(SeqList *L,int i)
{
int j;
if (L->length ==0)
{
printf("现行表为空,退出运行\n");
exit(0);
}
if (i<1 || i>L->length)
4.从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。
二
#include <stdio.h>
#include <stdlib.h>
/*顺序表的定义:*/
#include<iostream.h>
#define ListSize 100/*表空间大小可根据实际需要而定,这里假设为100*/
void InsertList(SeqList *L,DataType x,int i);
void DeleteList(SeqList *L,int i);
CreateList(&L,n);/*建立顺序表*/
PrintList(L,n);/*打印顺序表*/
printf("输入要查找的值:");
scanf("%d",&x);
if(i<1 || i>L->length +1)
{
printf("插入位置非法\n");
exit(0);
}
if(L->length >=ListSize)
{
printf("表空间溢出,退出运行\n");
exit(0);
}
for(j =L->length-1; j>=i-1;j--)
L->data[j+1]=L->data[j];