数据结构之顺序表的建立、打印、查找、插入、删除

合集下载

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

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

竭诚为您提供优质文档/双击可除顺序表的基本操作实验报告篇一:顺序表的基本操作--实验报告实验报告附:源程序:#include#definemaxsize100#defineerror0#defineok1typedefstruct{intelem[maxsize];intlast;}seqList;intInsList(seqList*L,inta,inti);intLocate(seqListL,inte);intDel(seqList*L,inti);voidmain(){inti,e,a;intlist1,list2;if(L.elem[st]==-1)seqListL;st=0;for(i=0;i list1=InsList(if(list1){}elseprintf("插入失败!");printf("要查找的元素为\n");scanf("%d",printf("插入后的顺序表为:\n");for(i=0;i list2=Locate(L,e);if(!list2)printf("该元素不存在\n");}printf("该元素所在位置的序号为:%d\n",list2);/*删除元素*/printf("是否要删除该元素?\n");intm;scanf("%d",if(m){Del(printf("删除后的顺序表为:\n");for(i=0;iintInsList(seqList*L,inta,inti)//i位置,下标i-1{for(p=L->last;p>=i-1;p--)L->elem[p+1]=L->elem[p];in tp;if(L->last>=maxsize-1){}printf("表已满,无法插入");return(error);L->elem[i-1]=a;L->last++;return(ok );intLocate(seqListL,inte){}intDel(seqList*L,inti){}for(k=i;klast;k++)L->elem[k-1]=L->elem[k];intk ;inti=0;while((ilast--;returnok;篇二:线性表的基本操作实验报告实验一:线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。

在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。

我们先来介绍一下顺序表的基本概念。

顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。

顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。

在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。

我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。

在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。

总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。

《数据结构》实验指导书

《数据结构》实验指导书
四、实验说明
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语言实现顺序表的插入和删除代码

printf("Please In Put The Number To Insert:\n"); scanf("%d",&m); p=&(L->elem[i-1]); for(q=L->elem+L->length-1;p<=q;--q) *(q+1)=*q; *p=m; ++L->length; printf("The New List Is:\n"); for(p=L->elem;p<=L->elem+L->length-1;p++) printf("%-4d",*p); printf("\n"); return OK; } Status ListDelete_Sq(SqList *L) { int i; int e; int *p; int *q; printf("Please In Put The Location To Delete:\n"); scanf("%d",&i); p=&(L->elem[i-1]); e=*p; q=L->elem+L->length-1; for(++p;p<=q;++p) *(p-1)=*p; --L->length; printf("The Delete Number Is %d\n",e); printf("The New List Is:\n"); for(p=L->elem;p<=L->elem+L->length-1;p++) printf("%-4d",*p); printf("\n"); return OK; } main() { int n,i; InitList_Sq(&L); printf("Please In Put Length:\n"); scanf("%d",&n); CreateList_Sq(&L,n); InsertList_Sq(&L); ListDelete_Sq(&L); printf("\n");

数据结构(c语言版)课后习题答案完整版

数据结构(c语言版)课后习题答案完整版

数据结构(c语言版)课后习题答案完整版数据结构(C语言版)课后习题答案完整版一、数据结构概述数据结构是计算机科学中一个重要的概念,用来组织和存储数据,使之可以高效地访问和操作。

在C语言中,我们可以使用不同的数据结构来解决各种问题。

本文将提供完整版本的C语言数据结构的课后习题答案。

二、顺序表1. 顺序表的定义和基本操作顺序表是一种线性表,其中的元素在物理内存中连续地存储。

在C 语言中,我们可以通过定义结构体和使用指针来实现顺序表。

以下是顺序表的一些基本操作的答案:(1)初始化顺序表```ctypedef struct{int data[MAX_SIZE];int length;} SeqList;void InitList(SeqList *L){L->length = 0;}```(2)插入元素到顺序表中```cbool Insert(SeqList *L, int pos, int elem){if(L->length == MAX_SIZE){return false; // 顺序表已满}if(pos < 1 || pos > L->length + 1){return false; // 位置不合法}for(int i = L->length; i >= pos; i--){L->data[i] = L->data[i-1]; // 向后移动元素 }L->data[pos-1] = elem;L->length++;return true;}```(3)删除顺序表中的元素```cbool Delete(SeqList *L, int pos){if(pos < 1 || pos > L->length){return false; // 位置不合法}for(int i = pos; i < L->length; i++){L->data[i-1] = L->data[i]; // 向前移动元素 }L->length--;return true;}```(4)查找顺序表中的元素```cint Search(SeqList L, int elem){for(int i = 0; i < L.length; i++){if(L.data[i] == elem){return i + 1; // 找到元素,返回位置 }}return -1; // 未找到元素}```2. 顺序表习题解答(1)逆置顺序表```cvoid Reverse(SeqList *L){for(int i = 0; i < L->length / 2; i++){int temp = L->data[i];L->data[i] = L->data[L->length - 1 - i]; L->data[L->length - 1 - i] = temp;}}```(2)顺序表元素去重```cvoid RemoveDuplicates(SeqList *L){for(int i = 0; i < L->length; i++){for(int j = i + 1; j < L->length; j++){if(L->data[i] == L->data[j]){Delete(L, j + 1);j--;}}}}```三、链表1. 单链表单链表是一种常见的链式存储结构,每个节点包含数据和指向下一个节点的指针。

第2次课--顺序线性表的创建和输出、插入和删除

第2次课--顺序线性表的创建和输出、插入和删除
《C语言与数据结构》
第2次课----顺序线性表的定义、创建和输出、插入和删除
第5章
顺序线性表的创建
分析 ① 创建顺序线性表就是依次输入线性表元素,存 放到数组中,最后设置线性表的长度。 ② 为简便起见,设元素类型为整型。 typedef int Elemtype;
《C语言与数据结构》
第2次课----顺序线性表的定义、创建和输出、插入和删除
《C语言与数据结构》
第2次课----顺序线性表的定义、创建和输出、插入和删除
第5章
在有序顺序表中插入元素的实现
方法一的流程图 源程序
看源程序 (2_4) 运行程序 (2_4)
注意:创建线性表 时,要有序。
《C语言与数据结构》
第2次课----顺序线性表的定义、创建和输出、插入和删除
第5章
在有序顺序表中插入元素的实现
源程序
看源程序 (2_2) 运行程序 (2_2)
《C语言与数据结构》
第2次课----顺序线性表的定义、创建和输出、插入和删除
第5章
顺序线性表的输出
分析 顺序线性表的输出就是把线性表元素一个一个地 输出。 流程图
源程序
看源程序 (2_2) 运行程序 (2_2)
《C语言与数据结构》
第2次课----顺序线性表的定义、创建和输出、插入和删除
a1 ……
ai ai+1 …… an-1
b+(n-1)L
《C语言与数据结构》
第2次课----顺序线性表的定义、创建和输出、插入和删除
第5章
顺序线性表的类型定义
数组的最大 顺序线性表类型的定义 元素个数 #define MAXSIZE 100 struct sequence /* 定义顺序表类型 */ { Elemtype elem[MAXSIZE]; /* Elemtype表示元素的数据类型,如int */ int len ; /* 表长 */ }; 当前存储的 顺序线性表的定义 数据元素个 struct sequence v; 数,即表长

数据结构实验一顺序表

数据结构实验一顺序表

数据结构实验一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;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

数据结构 顺序表 实验报告

数据结构 顺序表 实验报告

实验报告运行结果:实验总结:对顺序表的理论知识了解还不够透彻,导致在做顺序表实验的时候无从下手,认真查看教程及实验指导后才知道该如何下手敲写代码;此次实验让我发现自己对上学期所学的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,即清空元素。

这些基本操作可以根据具体需求进行使用和扩展。

数据结构-顺序表-实验报告

数据结构-顺序表-实验报告

实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机,Windows,DOS,Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算(1)问题描述顺序表时常进行的运算包括:创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。

试编程实现顺序表的这些基本运算。

(2)基本要求实现顺序表的每一个运算要求用一个函数实现。

(3)算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。

(4)算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果:构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。

数据结构实验最全 顺序表的操作及其应用

数据结构实验最全  顺序表的操作及其应用

实验1 顺序表的操作及其应用一、实验目的1)掌握线性表的顺序存储结构;2)熟练掌握顺序表基本算法的实现;3)掌握利用线性表数据结构解决实际问题的方法和基本技巧;4)按照实验题目要求独立正确地完成实验内容二、实验内容要求:数据元素类型ElemType 取整型int 或者char。

顺序存储实现如下算法:1)创建一顺序表;2)输出该顺序表;3)在顺序表中查找第i 个元素,并返回其值;4)在顺序表中第i 个元素之前插入一已知元素;5)在顺序表中删除第i 个元素;6)实现顺序表的合并。

(选做)源程序://A Sequential List顺序表#include <stdio.h>#include <malloc.h>#include <process.h>#include <stdlib.h>#include <conio.h>#include <windows.h>#define InitSize 100 //线性表存储空间的初始分配量#define ListIncrement 10 //线性表存储空间的分配增量typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;Status InitList(SqList &L) //初始化{L.elem=(ElemType *)malloc(InitSize*sizeof(ElemType));if(!L.elem)exit(OVERFLOW);L.length=0;L.listsize=InitSize;return OK;}//求表长int ListLength(SqList &L){return L.length;}//输入元素int DataInput(SqList &L){int i=1,j=1;printf("输入数据后,按“0”结束输入\n");while(j){scanf("%d",&j);if(j!=0){L.elem[i]=j;L.length++;i++;if(i>InitSize)break;}}return FALSE;}//输出顺序表Status ListTraverse(SqList L){ElemType *p;int i;p=L.elem;for(i=0;i<L.length;i++)printf("%d ",*p++);printf("\n");return OK;}Status GetElem(SqList L,int i,ElemType &e){if(i<1||i>L.length)exit(ERROR);e=L.elem[i-1];return OK;}//插入元素Status ListInsert(SqList &L,int i,ElemType e){ElemType *newbase,*q,*p;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){newbase=(ElemType *) realloc(L.elem,(L.listsize+ListIncrement)*sizeof(ElemType));if(!newbase)exit(OVERFLOW);L.elem=newbase;L.listsize=L.listsize+ListIncrement;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}//删除元素Status ListDeletSq(SqList &L,int i,ElemType &e){ElemType *p,*q;if(i<1||i>L.length)return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return OK;}int main(){SqList L;ElemType e;char ch;int t;while(1){system("cls");printf("\t------------MENU------------------\n");printf("\t|1.创建一顺序表|\n"); printf("\t|2.输入数据|\n"); printf("\t|3.输出顺序表|\n"); printf("\t|4.查找表中元素|\n"); printf("\t|5.于表中插入元素|\n"); printf("\t|6.删除表中元素|\n"); printf("\t|7.退出|\n"); printf("\t|---------------------------------\n");fflush(stdin);ch=getchar();if(ch=='7')break;switch(ch){case '1': InitList(L);printf("初始化顺序表成功!\n");printf("按任何键继续操作···\n");getch();break;case '2':DataInput(L);printf("数据输入成功!\n");printf("按任何键继续操作···\n");getch();break;case '3':ListTraverse(L);getch();break;case '4':printf("你查找是第几个元素:");fflush(stdin);scanf("%d",&t);GetElem(L,t,e);printf("你查找的元素是:%d\n",e);printf("按任何键继续操作···\n");getch();break;case '5':printf("输入你要插入的元素:");scanf("%d",&e);ListInsert(L,t,e);printf("成功插入!\n");printf("按任何键继续操作···\n");getch();break;case '6':printf("你想删除第几个数据:");scanf("%d",&t);ListDeletSq(L,t,e);printf("成功删除!\n");printf("按任何键继续操作···\n");getch();break;default:break;}}return FALSE;}运行截图:主菜单:1.创建顺序表;2.输入数据:3.插入数据:三、实验总结:问题:1.刚开始接触数据结构时,完全不知道这门课程是学什么的,一脸茫然,通过反复看书,最后逐渐明白了其中的含义。

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告

顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。

设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。

具体内容同时实现建议: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。

c语言顺序表实验报告

c语言顺序表实验报告

c语言顺序表实验报告C语言顺序表实验报告引言:C语言是一种广泛应用于软件开发领域的编程语言,其灵活性和高效性备受开发者青睐。

在本次实验中,我们将探索C语言中的一种数据结构——顺序表。

顺序表是一种线性表的存储结构,通过数组实现,具有快速访问元素的特点。

本实验将通过实际操作,深入了解顺序表的创建、插入、删除和查找等基本操作,并对其性能进行评估。

实验目的:1. 掌握顺序表的创建和初始化方法;2. 熟悉顺序表的插入、删除和查找等基本操作;3. 评估顺序表在不同操作下的性能。

实验步骤:1. 创建顺序表在C语言中,可以通过定义一个结构体来表示顺序表,其中包含一个数组和一个记录当前元素个数的变量。

通过动态内存分配,可以根据需要调整顺序表的大小。

```ctypedef struct {int* data; // 数组指针int length; // 当前元素个数int capacity; // 顺序表的容量} SeqList;```在主函数中,可以通过调用malloc函数为顺序表分配内存空间,并对其进行初始化。

```cSeqList* createSeqList(int capacity) {SeqList* list = (SeqList*)malloc(sizeof(SeqList));list->data = (int*)malloc(capacity * sizeof(int));list->length = 0;list->capacity = capacity;return list;}```2. 插入元素顺序表的插入操作需要考虑插入位置的合法性以及顺序表是否已满的情况。

在插入元素时,需要将插入位置之后的元素后移一位,为新元素腾出空间。

```cvoid insert(SeqList* list, int position, int element) {if (position < 0 || position > list->length) {printf("插入位置非法!");return;}if (list->length >= list->capacity) {printf("顺序表已满,无法插入!");return;}for (int i = list->length - 1; i >= position; i--) {list->data[i + 1] = list->data[i];}list->data[position] = element;list->length++;}```3. 删除元素顺序表的删除操作需要考虑删除位置的合法性以及顺序表是否为空的情况。

数据结构实验报告—顺序表

数据结构实验报告—顺序表

《算法与数据结构》课程实验报告一、实验目的1、实现线性表的顺序存储结构。

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

3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现。

二、实验内容及要求对顺序存储的线性表进行一些基本操作。

主要包括:(1)插入:操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入。

(2)删除:操作方式可分为删除指定元素、删除指定位置的元素等,尝试实现逻辑删除操作。

(3)显示数据。

(4)查找:查询指定的元素(可根据某个数据成员完成查询操作)。

(5)定位操作:定位指定元素的序号。

(6)更新:修改指定元素的数据。

(7)数据文件的读写操作等。

其它操作可根据具体需要自行补充。

要求线性表采用类的定义,数据对象的类型自行定义。

三、系统分析(1)数据方面:能够实现多种数据类型顺序表的创建,并进行操作,不同的数据类型数据使用不同的文本文件保存。

(2)功能方面:能够实现线性表的一些基本操作,主要包括:1.计算表最大可以容纳表项个数以及当前表的当前长度。

2.能够进行添加操作,在已有的数据文件中进行数据的添加。

3.能够进行搜索操作,返回搜索项在表中表项序号4.能够进行定位操作,定位到表中合理位置。

5.能够进行取值操作,根据用户需求取出表中某项的值。

6.能够进行修改操作,在用户选择修改项后将重新输入内容修改到对应位置。

7.能够进行插入操作,在用户选择合理位置并输入插入内容后即可。

8.能够进行删除操作,用户根据选择表中项数删除对应数据。

9.能够进行判断表空或表满。

四、系统设计(1)设计的主要思路根据实验要求,首先将顺序表模板类完成,并将需要实现的功能代码完善,在写实现各个功能的菜单并将模板类实例化为简单数据类型最后进行调试,由于还需使得顺序表能够存储自定义的学生类类型数据,故根据要求写出Student类,并将之前所写得模板类用学生类数据类型实例化,再进行调试。

数据结构上机实验指导

数据结构上机实验指导

《数据结构》课程上机实验指导书实验一【实验名称】顺序表的基本算法【实验目的】创建一个顺序表,掌握线性表顺序存储的特点。

设计和验证顺序表的查找、插入、删除算法。

【实验要求】(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、实验前先写好算法。

数据结构实验报告之链表顺序表的操作

数据结构实验报告之链表顺序表的操作

数据结构实验报告之链表顺序表的操作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 }。

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

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

实验1:顺序表的基本操作实验2:单链表的基本操作实验3:查找实验4:排序实验1代码及结果:#include <iostream>using namespace std;template <class T>class sq_LList{private:int mm;int nn;T *v;public:sq_LList(){mm=0;nn=0;return;}sq_LList(int);void prt_sq_LList();int flag_sq_LList();void ins_sq_LList(int,T);void del_sq_LList(int);};//建立空顺序表template <class T>sq_LList<T>::sq_LList(int m){mm=m;v=new T[mm];nn=0;return;}//顺序输出顺序表中的元素与顺序表长度template <class T>void sq_LList<T>::prt_sq_LList(){int i;cout<<"nn="<<nn<<endl;for(i=0;i<nn;i++)cout<<v[i]<<endl; return;}//检测顺序表的状态template <class T>int sq_LList<T>::flag_sq_LList(){if(nn=mn)return(-1);if(nn=0)return(0);return (1);}//在表的指定元素前插入新元素template<class T>void sq_LList<T>::ins_sq_LList(int i,T b){int k;if(nn==mm){cout<<"overflow"<<endl;return;}if(i>nn)i=nn+1;if(i<1)i=1;for(k=nn;k>=i;k--)v[k]=v[k-1];v[i-1]=b;nn=nn+1;return ;}//在顺序表中删除指定元素template<class T>void sq_LList<T>::del_sq_LList(int i){int k;if(nn==0){cout<<"underflow!"<<endl;return;}for(k=i;k<nn;k++)v[k-1]=v[k];nn=nn-1;return ;}int main(){sq_LList<double>s1(100);cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();s1.ins_sq_LList(0,1.5);s1.ins_sq_LList(1,2.5);s1.ins_sq_LList(4,3.5);cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();s1.del_sq_LList(0);s1.del_sq_LList(2);cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList();return 0;}运行及结果:实验2代码#include<iostream>#include<iomanip>using namespace std;struct node{float data;node *next;};node *create(){ //建立单链表node *head,*p,*s;head=new node;p=head;p->data=0;p->next=0; //表头创建完成float newnum=0;cin>>newnum;if(newnum<0){cout<<"未输入数据...\n";//输入负数则结束system("pause");}while(newnum>=0 ){ //??如何用字符型作为结束标志s=new node; //创建表中数据s->data=newnum;p->next=s;p=s;cin>>newnum;}p->next=NULL; //最后元素指针return(head); //返回空表头}//插入一个结点x,将成为第i个节点void insertnode(node *head,int i,float x){node *s,*p;int j;s=new node;s->data=x;p=head;j=1; //查找第i个结点,由p指向while(p!=NULL && j<i){j++;p=p->next;}s->next=p->next;p->next=s;}//删除结点xvoid deletenode(node *head,float x){node *p,*s;if(head->next==NULL)cout<<"这是空链表,不能执行删除操作\n"; else{s=head;p=head->next;while(p!=NULL && p->data!=x)if(p->data!=x){s=p;p=p->next;}if(p!=NULL){s->next=p->next;delete(p);}else cout<<"未找到!\n";}}//存取链表某节点Kvoid read(node*head,int k){while(head->next!=0&&k>0){head=head->next;k--;}cout<<"该处数据为"<<head->data<<".\n\n"; }int main( ) {node *linktable=0;int choice=1;cout<<"1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"请输入您的选择:";cin>>choice;while(1){switch (choice){case 0: exit(0);case 1:{cout<<"输入正数数据,并以负数作为结束标记\n";linktable=create();break;}case 2:{cout<<"链表长度为"<<length(linktable)<<",详细信息:\n";printlist(linktable);break;}case 3:{cout<<"要删除的数据为?\n";float del;cin>>del;deletenode(linktable,del);break;}case 4:{if(linktable->next==0)cout<<"链表为空,不能查找\n";else{cout<<"要查找数据为?";float search;cin>>search;find(linktable,search);} break;}case 5:{cout<<"存储数据为?";int des;float it;cin>>it;cout<<"想让该数据存储为第几个节点?";cin>>des;if((des>(length(linktable)+1)||des<1))cout<<"输入错误\n";elseinsertnode(linktable,des,it);break;}case 6:{cout<<"想读取第几个节点?";int c;cin>>c;if(c<1||c>length(linktable))cout<<"位置不合法\n";elseread(linktable,c);break;}default :cout<<"输入错误!\n";}system("pause");system("cls");cout<<"当前信息:\n";printlist(linktable);cout<<"\n1.创建链表\n";cout<<"2.显示信息\n";cout<<"3.删除信息\n";cout<<"4.查找信息\n";cout<<"5.插入信息\n";cout<<"6.读取信息\n";cout<<"0.退出程序\n";cout<<"继续选择:\n";cin>>choice;}return 0;}实验三查找实验名称:实验3 查找实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序树和哈希表的构造和查找方法。

顺序表的建立、输入、输出、查找、插入、删除(数据结构)

顺序表的建立、输入、输出、查找、插入、删除(数据结构)

顺序表的建⽴、输⼊、输出、查找、插⼊、删除(数据结构)1.顺序表的基本操作实践。

(1)建⽴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。

数据结构实验课教案

数据结构实验课教案

数据结构教案实验一:线性表的顺序表示与实现实验学时:2学时一.实验目的:1.掌握线性表的顺序存储结构;2.掌握在顺序表上进行的插入、删除、查找、修改等操作。

二.实验内容:1.分别建立顺序表,并输入初始数据;2.对顺序表分别编写插入、删除、查找、修改等函数。

三.实验重点:顺序表的建立及操作。

四.实验要求:1.用C语言编写程序源代码;2.要分别完成建立、插入、删除、查找、修改五种功能。

3.源程序必须编译调试成功,独立完成。

五.实验器材:一个装有C语言编译环境的计算机。

六.实验步骤:顺序表:1.定义头文件和顺序表的存储结构类型等#define ok 1#define error 0#define overflow 0#define null 0#include<stdio.h>#include<stdlib.h>#define list_init_size 100#define listincrement 10typedef int elemtype;typedef int status;typedef struct{elemtype *elem;int length;int listsize;}sqlist;2.编写构造空顺序表的函数status listinit(sqlist *l){l->elem=(elemtype *)malloc(list_init_size*sizeof(elemtype));if(!l->elem)return overflow;l->length=0;l->listsize=list_init_size;return ok;}3.编写对顺序表进行插入操作的函数:status listinsert(sqlist *l,int i,elemtype e){elemtype *newbase,*q,*p;if(i<1||i>listlength(*l)+1)return error;if(l->length==l->listsize){newbase=(elemtype *)realloc(l->elem,(l->listsize+listincrement)*sizeof(elemtype));if(!newbase)return overflow;l->listsize+=listincrement;}q=&(l->elem[i-1]);for(p=&(l->elem[l->length])-1;p>=q;--p)*(p+1)=*p;*q=e;++l->length;return ok;}4.编写对顺序表进行删除操作的函数:status listdelete(sqlist *l,int i,elemtype *e){elemtype *p,*q;if(i<1||i>l->length)return error;p=&(l->elem[i-1]);*e=*p;q=l->elem+l->length-1;for(++p;p<=q;++p)*(p-1)=*p;--l->length;return ok;}5.编写对顺序表进行查找操作的函数:status getelem(sqlist l,int i,elemtype *e){if(i<1||i>listlength(l))return error;*e=l.elem[i-1];return ok;}6.编写对顺序表进行修改操作的函数:status locateelem(sqlist l,elemtype e){int i;for(i=0;i<listlength(l);i++)if(l.elem[i]==e)return i+1;return 0;}7.编写实现两个线性表的归并操作的函数void mergelist(sqlist la,sqlist lb,sqlist *lc) {int i,j,k;int la_len,lb_len;elemtype ai,bj;i=j=1; k=0;listinit(lc);la_len=listlength(la); lb_len=listlength(lb); while(i<=la_len&&j<=lb_len){getelem(la,i,&ai);getelem(lb,j,&bj);if(ai<=bj){listinsert(lc,++k,ai);++i;}else{listinsert(lc,++k,bj);++j;}}while(i<=la_len){getelem(la,i++,&ai);listinsert(lc,++k,ai);}while(j<=lb_len){getelem(lb,j++,&bj);listinsert(lc,++k,bj);}}8.销毁线性表、清空线性表、判空、求表长等status destroylist(sqlist *l){if(l->elem)free(l->elem),l->elem=null;return ok;}status clearlist(sqlist *l){l->length=0;return ok;}status listempty(sqlist l){return(l.length==0);}status listlength(sqlist l){return l.length;}9.打印线性表void print(sqlist l){int i;printf("\nlist: ");for(i=0;i<l.length;i++)printf("%d ",l.elem[i]);}10.编写主函数void main(){int i;int n;elemtype a;sqlist l,la,lb,lc;clrscr();listinit(&l); listinit(&la); listinit(&lb);printf("please input list number");scanf("%d",&n);printf("\n");for(i=0;i<n;i++){scanf("%d",&a);listinsert(&l,i+1,a);}print(l);printf("\nlist length:%d",listlength(l));getelem(l,4,&a);printf("\ngetelem(l,4,&a),%d",a);listdelete(&l,3,&a);printf("\nlistdelete(&l,3,&a),%d",a);print(l);printf("\ninput list la");for(i=0;i<5;i++){scanf("%d",&a);listinsert(&la,i+1,a);}printf("\ninput list lb");for(i=0;i<7;i++){scanf("%d",&a);listinsert(&lb,i+1,a);}mergelist(la,lb,&lc);print(la);print(lb);print(lc); }实验二:链表实验学时:2学时一.实验目的:11.掌握单、双向链表的存储结构;12.掌握在单、双向链表上进行的插入、删除、查找、修改等操作。

数据结构图实验报告

数据结构图实验报告

数据结构图实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构图的基本概念、原理和操作方法,通过实际编程和操作,提高对数据结构的应用能力和解决问题的能力。

二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。

三、实验内容(一)线性表1、顺序表实现顺序表的创建、插入、删除、查找等基本操作。

分析顺序表在不同操作下的时间复杂度。

2、链表实现单链表、双向链表的创建、插入、删除、查找等基本操作。

比较单链表和双向链表在操作上的优缺点。

(二)栈和队列1、栈实现顺序栈和链式栈。

用栈解决表达式求值问题。

2、队列实现顺序队列和链式队列。

用队列模拟银行排队问题。

(三)树1、二叉树实现二叉树的创建、遍历(前序、中序、后序)。

计算二叉树的深度和节点数。

2、二叉搜索树实现二叉搜索树的插入、删除、查找操作。

分析二叉搜索树的性能。

(四)图1、图的存储实现邻接矩阵和邻接表两种图的存储方式。

比较两种存储方式的优缺点。

2、图的遍历实现深度优先遍历和广度优先遍历算法。

用图的遍历解决最短路径问题。

四、实验步骤(一)线性表1、顺序表定义一个数组来存储顺序表的元素,并使用一个变量记录当前表的长度。

插入操作时,需要判断插入位置是否合法,如果合法则将插入位置后的元素依次向后移动一位,然后将新元素插入指定位置。

删除操作时,先判断删除位置是否合法,合法则将删除位置后的元素依次向前移动一位,并更新表的长度。

查找操作通过遍历数组来实现。

分析不同操作的时间复杂度,插入和删除操作在最坏情况下为O(n),查找操作在平均情况下为 O(n/2)。

2、链表对于单链表,定义一个节点结构体,包含数据域和指向下一个节点的指针域。

通过操作指针来实现插入、删除和查找操作。

双向链表则在节点结构体中增加指向前一个节点的指针,使得操作更加灵活,但也增加了空间复杂度。

比较单链表和双向链表在插入、删除操作中指针的调整过程,得出双向链表在某些情况下更方便,但空间开销较大的结论。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
void PrintList(SeqList L);
int LocateList(SeqList L,DataType x);
void InsertList(SeqList *L,DataType x,int i);
void DeleteList(SeqList *L,int i);
CreateList(&L,n);//建立顺序表
L->length++;
L->data[i-1]=x;
cout<<"插入成功!"<<endl;
}
//顺序表的删除:
void DeleteList(SeqList *L,int i)
{
if(i<1 || i>L->length)
{
cout<<"删除位置不合法!"<<endl;
return;
}
for(int j=i;j<L->length;j++)
for(int i=0;i<n;i++)
{ cin>>L->data[i]; }
L->length=n;
}
//顺序表的打印:
void PrintList(SeqList L)
{
cout<<"顺序表的顺序为:"<<endl;
for(int i=0;i<L.length;i++)
{ cout<<setw(6)<<L.data[i]; }
PrintList(L);//打印顺序表
cout<<"输入要删除的位置:";
cin>>i;
DeleteList(&L,i);//顺序表删除
PrintList(L);//打印顺序表
}
//顺序表的建立:
void CreateList(SeqList *L,int n)
{
cout<<"请输入10个数据:"<<endl;
void InsertList(SeqList *L,DataType x,int i)
{
if(i<1 || i>L->length+1)
{
cout<<"插入位置合法!"<<endl;
return;
}
for(int j=L->length-1;j>=i-1;j--)
{ L->data[j+1]=L->data[j]; }
cout<<endl;
}
//顺序表的查找:
int LocateList(SeqList L,DataType x)
{
for(int i=0;i<L.length;i++)
{
if(L.data[i]==x)
{ return i+1; }
}
cout<<x<<"找不到"<<endl;L->data[j-1]=L->data[j];}
L->length--;
cout<<"删除成功!"<<endl;
}
typedef struct
{DataType data[ListSize];//向量data用于存放表结点
int length;//当前的表长度
}SeqList;
void main()
{
SeqList L;
int i,x;
int n=10;//欲建立的顺序表长度
L.length=0;
void CreateList(SeqList *L,int n);
PrintList(L);//打印顺序表
cout<<"输入要查找的值:";
cin>>x;
i=LocateList(L,x);//顺序表查找
cout<<"查找的值所在的位置:"<<i<<endl;
cout<<"输入要插入的位置:";
cin>>i;
cout<<"输入要插入的元素:";
cin>>x;
InsertList(&L,x,i);//顺序表插入
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <iomanip.h>
//顺序表的定义:
#define ListSize 100//表空间大小可根据实际需要而定,这里假设为100
typedef int DataType;//DataType可以是任何相应的数据类型如int, float或char
相关文档
最新文档