实验一 数据结构顺序表的插入和删除

合集下载

数据结构实验报告-线性表(顺序表实现)

数据结构实验报告-线性表(顺序表实现)

实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。

三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。

顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。

实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1:初始化------------------" << endl;cout << "--------------2:插入元素----------------" << endl;cout << "--------------3:查询元素----------------" << endl;cout << "--------------4:删除元素----------------" << endl;cout << "--------------5:销毁线性表--------------" << endl;cout << "--------------6:清空线性表--------------" << endl;cout << "--------------7:线性表长度--------------" << endl;cout << "--------------8:线性表是否为空----------" << endl;cout << "--------------9:定位满足大小关系的元素--" << endl;cout << "--------------10:查询前驱---------------" << endl;cout << "--------------11:查询后继---------------" << endl;cout << "--------------12:输出线性表-------------" << endl;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。

实验一顺序表的插入和删除实验目的...

实验一顺序表的插入和删除实验目的...
void genAxis(int length) {
int ctrl_loop;
putchar(' '); for (ctrl_loop = 0; ctrl_loop < length; ++ctrl_loop) {
std::cout << ctrl_loop + 1; } putchar('\n'); }
实验一顺序表的插入和删除
实验目的
1、掌握使用 Turbo C 上机调试线性表的基本方法; 2、掌握线性表的基本操作:插入、删除在顺序存储结构上的运算。
实验要求
1、认真阅读和掌握本实验的给定的程序; 2、按照你的操作需要,编制程序、上机调试运行程序; 3、保存程序的运行结果,并结合程序进行分析。
实验内容
std::cout << " Copyright (C) 2014 Spinel Studio" << std::endl; std::cout << " By Andrew Junzki" << std::endl; putchar('\n'); }
实验二链表的插入和删除
实验目的
1、掌握使用 Turbo C 上机调试线性表的基本方法; 2、掌握链表的基本操作:插入、删除和游历的操作。
实验要求
1、认真阅读和掌握本实验的给定的程序; 2、按照你的操作需要,编制程序、上机调试运行程序; 3、保存程序的运行结果,并结合程序进行分析。
实验内容
利用顺序表完成线性表信息的管理。要求首先建立并初始化线性表,并实现 增加、删除和游历等功能。
(1) 对给定字母 A C D E 建立顺序表 (2) 在给定位置插入字母 B,形成顺序表 A B C D E (3) 删除字母 D,形成表 A B C E

数据结构实验一顺序表

数据结构实验一顺序表

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

实验一顺序表的插入和删除

实验一顺序表的插入和删除

山东英才学院实验报告课年月日学院(系)班姓名学号实验题目:成绩:一、实验目的和要求本实验是数据结构后续实验的基础,做好本实验有助于学生理解单顺序线性表的概念,使学生掌握顺序线性表结构体的定义,熟悉顺序线性表的基本操作。

为后续实验打好基础。

定义顺序线性表结构体,定义顺序线性表初始化、销毁、插入、删除操作函数二、实验方法与步骤#include "stdio.h"#include "malloc.h"#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;#define LIST_INIT_SIZE 100 //线性表存储空间初始分配量#define LISTINCREMENT 10 //线性表存储空间分配增量typedef int ElemType;typedef struct{ElemType *elem; //线性表的基址int length; //线性表长度int listsize; //当前分配的存储容量} SqList;//线性表初始化:分配内存,长度置为0,初始容量LIST_INIT_SIZEStatus InitList(SqList &L){ L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if(L.elem==NULL) return OVERFLOW;L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}//释放内存,销毁线性表Status DestroyList(SqList &L){ if(L.elem==NULL) return OVERFLOW;free(L.elem);return OK;}Status ListEmty(SqList &L){ if(L.length==0) return 1;else return 0;}int ListLength(SqList &L){ return L.length;}//定位函数int LocateElem(SqList &L,ElemType e,Status compare(ElemType x, ElemType y)){ int i=1,*p=L.elem;while(i<=L.length ){if( (compare)(*p,e)==TRUE )return i;else{i++;p++;}}if(i>=L.length) return ERROR;}//向线性表中插入新数据Status ListInsert(SqList &L,int i,ElemType e){ if(i<1 || i>L.length+1 ) return ERROR;if(L.length >= L.listsize ){ ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize + LISTINCREMENT)*sizeof(ElemType));if(newbase==NULL) return OVERFLOW;L.elem=newbase;L.listsize=L.listsize+LISTINCREMENT;}ElemType *q=&(L.elem[i-1]);for(ElemType *p=&(L.elem[L.length-1]); p>=q; p--)*(p+1)=*p;*q=e;L.length=L.length+1;return OK;}//向线性表中插入新数据Status ListDelete(SqList &L,int i,ElemType &e){ if(i<1 || i>L.length+1 ) return ERROR;ElemType *p=&(L.elem[i-1]);e=*p;ElemType *q=L.elem+L.length-1;for(++p; p<=q;p++)*(p-1)=*p;L.length=L.length-1;return OK;}//线性表遍历函数void ListTraverse( SqList &L){ printf("线性表长度:%d,线性表容量:%d\n",L.length ,L.listsize );printf("线性表遍历序列:");if(L.length ==0) printf("线性表中无数据");for(int i=0; i<L.length ;i++)printf(" %d",L.elem[i]);printf("\n");}void main(){ SqList La;int pos,choose;ElemType e;InitList(La);while(1){ printf("请选择操作:选择1 进行插入操作,选择2 进行删除操作,选择3 显示表中内容,选择0 结束程序");scanf("%d",&choose);if(choose==1){ while(1){ printf("请输入插入位置(输入位置为0结束插入操作):");scanf("%d",&pos);if(pos==0) break;printf("请输入插入数据:");scanf("%d",&e);ListInsert(La,pos,e);}}else if(choose==2){ while(1){ printf("请输入删除位置(输入位置为0结束删除操作):");scanf("%d",&pos);if(pos==0) break;ListInsert(La,pos,e);}}else if(choose==3) ListTraverse(La);else if(choose==0) break;}DestroyList(La);}实验结果截图心得体会:本实验是数据结构后续实验的基础,做好本实验有助于学生理解单顺序线性表的概念,使学生掌握顺序线性表结构体的定义,熟悉顺序线性表的基本操作。

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

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

元素之后的所有数据都前移一个位置,最将线性表长减1。

3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。

线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool ListEmpty(SqList *L)//判线性表是否为空表{return(L->length==0);}int ListLength(SqList *L)//求线性表的长度{return(L->length);}void DispList(SqList *L)//输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。

实验一:顺序表的插入和删除

实验一:顺序表的插入和删除

实验报告一------顺序表的插入和删除1.实验目的1、输入一批整型数据,建立顺序表;2、实现顺序表的插入(输入插入位置i,插入元素)3、实现顺序表的删除(输入删除元素位置i)4、实现顺序表中数据的显示;5、实现顺序表中数据的查找和定位;6、编写主函数,调试上述算法。

2.实验源代码#include<stdio.h>#define max 100void sequenlist(int s[],int n) //建立一个顺序表{for(int i=0;i<n;i++){printf("顺序表第%d个元素是:\n",i+1);scanf("%d",&s[i]);}printf("所以该顺序表输出为:\n");for(int j=0;j<n;j++){printf("%d\t",s[j]);}putchar('\n');}void insert(int s[],int &n,int i,int x) //顺序表的插入{if(n==max||i<1||i>n+1)printf("插入失败!!!\n");elsefor(int k=n-1;k>=i-1;k--){s[k+1]=s[k];}s[i-1]=x;n++;}void dele(int s[],int &n,int i) //删除元素位置i {if(i<1||i>n+1)printf("无法删除!!!\n");elsefor(int j=i-1;j<n;j++){s[j]=s[j+1];}n--;}void disp(int s[],int n) //输出顺序表数据{printf("该顺序表输出为:\n");for(int j=0;j<n;j++){printf("%d\t",s[j]);}putchar('\n');}void locate(int s[],int &n,int x) //查找和定位{int k;for(int j=0;j<n;j++){if(s[j]==x)k=j+1;}printf("您要查找的数据位于第%d位!\n",k);}int main(){int s[max];int n;int i,x;int num;printf("请输入顺序表的数据元素个数:\n");scanf("%d",&n);sequenlist(s,n); //顺序表的建立printf("******************************************************\n" );printf("*************1.插入***********************************\n");printf("*************2.删除***********************************\n");printf("*************3.输出***********************************\n");printf("*************4.查找***********************************\n");printf("******************************************************\n" );while(1){printf("请选择:\n");scanf("%d",&num);switch(num){case 1:printf("请选择要插入的位置:\n");scanf("%d",&i);printf("请选择要插入的数据:\n");scanf("%d",&x);insert(s,n,i,x);break;case 2:printf("请选择您要删除的元素位置:\n");scanf("%d",&i);dele(s,n,i);break;case 3:disp(s,n);break;case 4:printf("请选择您要查询的元素:\n");scanf("%d",&x);locate(s,n,x);break;default:goto l;break;}}l:return 0;}3.实验结果见下图!。

顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢.

顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢.

实验一顺序表的实现实验目的:熟练掌握顺序表的基本操作(插入、删除、查找等)实验内容:顺序表中的基本操作的实现(初始化、插入、删除、求表长、按值查找、按位置查找)实验要求:以顺序表的动态分配存储结构来实现;所有基本操作均应该以函数的形式表示;要有运行结果并考虑到顺序表中所有情况。

一、实验算法描述:1、顺序表的声明和创建typedef struct{int* data;//int*型元素int length;//顺序表的实际长度int listsize;//顺序表的最大长度}sqlist;void creatsqlist(sqlist &list){list.data=(int*)malloc(sizeof(int)*maxsize);//开辟一个名为l的顺序表if(!list.data)//判断顺序表是否存在exit(1);list.length=0;list.listsize=maxsize;}2、初始化函数initsqlist(list)void initsqlist(sqlist &list)//初始化操作{int* p;int n;cout<<"请输入顺序表元素数(1-50):"<<endl;//让用户输入顺序表元素个数cin>>n;cout<<"您申请的顺序表的长度是---"<<n<<endl;p=list.data;//p指向头指针cout<<"请依次输入无重复数字的有序顺序表(相邻数据用空格隔开,回车键完成输入):"<<endl;for(int i=0;i<n;i++)//逐个赋值{cin>>*p;p++;list.length++;}cout<<"您输入的递增顺序表为:"<<endl;//打印出初始化的顺序表for(i=0;i<n;i++)cout<<list.data[i]<<"\t";cout<<endl;}3、输出函数put(list)void put(sqlist &list) //输出函数{ int i;for(i=0;i<list.length;i++)cout<<list.data[i]<<"\t";cout<<endl;}4、定位函数locateElem(list)void locateElem(sqlist &list){int i,j=0,b;cout<<"请输如要查找的字符:\n";cin>>b;for(i=0;i<list.length;i++)if(list.data[i]==b){j=i+1;break;}if(j)cout<<"该数字的位置是:"<<j<<endl;elsecout<<"很抱歉,表中没有这个数字,请重试!"<<endl; }5、插入函数insert(list)void insert(sqlist &list)//插入函数{int i;cout<<"您想在第几位插入数字:\n";cin>>i;int x;cout<<"请输入要插入的数字:\n";cin>>x;int j;if(i<0||i>list.length){cout<<"位置错误"<<endl;put(list);}else{ for(j=list.length;j>=i;j--)list.data[j]=list.data[j-1];list.data[j]=x;list.length++;}cout<<"插入操作完成后的顺序表:"<<endl;put(list);}6、删除函数delete1(list)和delete2(list)void delete1(sqlist &list)//删除第i个位置的数字的函数{int i,b;cout<<"请输入你想要删除数据的位置:"<<endl;cin>>i;if(i<0||i>list.length){cout<<"输入错误!"<<endl;return;}else{b=list.data[i-1];for(i=i-1;i<list.length-1;i++)list.data[i]=list.data[i+1];--list.length;cout<<"需要删除的元素是:"<<b<<endl;cout<<"删除操作完成后的顺序表是:"<<endl;put(list);}}void delete2(sqlist &list)//删除指定数字的函数{int b;cout<<"输入您想删除的数字:"<<endl;cin>>b;int i,j=0;for(i=0;i<list.length;i++){if(list.data[i]==b){j=i+1;break;}}if(j!=0){for(;i<list.length-2 ;i++)list.data[i]=list.data[i+1];--list.length;cout<<"该位置是第"<<i<<"位"<<endl;cout<<"删除操作完成后的顺序表是:"<<endl;put(list);}elsecout<<"很遗憾,表中没有找到此数字,删除不成功,请重试!"<<endl;}二、实验程序描述:主函数如下:int main(){int flag;sqlist l;creatsqlist(l);initsqlist(l);cout<<endl<<"********************************************************* *****************"<<endl;cout<<"请输入要进行的操作序号:\n";cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"0.退出"<<endl<<endl;cin>>flag;do{switch(flag){case 1:insert(l);break;case 2:locateElem(l);break;case 3:delete1(l);break;case 4:delete2(l);break;default:cout<<"请重新输入||代码错误"<<endl;}cout<<"*********************************************************** ***************"<<endl;cout<<"请输入要进行的操作序号:\n";cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"0.退出"<<endl<<endl;cin>>flag;}while(flag!=0);return 0;}三、实验结果(输入和输出):1、输入界面:2、插入操作:3、查找操作:4、删除操作:最新文件仅供参考已改成word文本。

顺序表的建立、输出、插入、删除

顺序表的建立、输出、插入、删除

顺序表的建⽴、输出、插⼊、删除1.顺序表的建⽴,⼀定要记得要分配内存,然后就把输⼊的数插⼊进去就可以了。

//建⽴顺序表Status InitList_Sq(SqList &L,int n){L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配内存if(!L.elem)exit(OVERFLOW);//判断是否溢出printf("请输⼊顺序表中元素:");for(int i=0;i<n;i++){scanf("%d",&L.elem[i]);}L.length=n;L.listsize=LIST_INIT_SIZE;return OK;}2.插⼊元素的时候,要判断位置是否有效,还要注意内存分配的问题,要判断,如果内存不够他插⼊新的元素就要重新分配内存,然后插⼊要从最后⼀个往下移,倒数第⼆个移到倒数第⼀个.......顺序不要弄反了。

//顺序表的插⼊Status InsertList_Sq(SqList &L,int i,ElemType e){if(i<1||i>L.length+1)return ERROR;//判断位置是否有效if(L.length>=L.listsize){//判断是否需要重新分配内存ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));//重新分配内存,这⾥newbase对应的是elem,所以定义的时候必须是ElemType *newbase if(!newbase)exit(OVERFLOW);//重新分配完之后还要判断是否溢出L.elem=newbase;//把新的内存赋给L.elemL.listsize+=LISTINCREMENT;}ElemType *q=&(L.elem[i-1]);//定义⼀个指针指向需要插⼊的位置ElemType *p=&(L.elem[L.length-1]);//定义⼀个指针指向指针的末尾for(p;p>=q;p--){*(p+1)=*p;//就是把倒数第⼀赋给倒数第⼆,倒数第三赋给倒数第⼆......}*q=e;//最后吧需要插⼊的元素的值赋给qL.length++;//顺序表的长度加⼀return OK;}3.删除的时候还是要先判断删除的位置是否有效,然后就找到删除的位置,让他下⾯的元素依次往上赋值//顺序表的删除Status DeleteList_Sq(SqList &L,int i){if(i<1||i>L.length)return ERROR;//判断位置是否有效ElemType *p=&(L.elem[i-1]);//定义⼀个指针指向要删除位置ElemType *q=&(L.elem[L.length-1]);//定义⼀个指针指向顺序表的末尾for(p;p<=q;p++){*p=*(p+1);//将删除位置以下的元素依次向上赋值}L.length--;//顺序表的长度减⼀return OK;}4.总的代码为#include <stdio.h>#include<malloc.h>//分配内存的时候需要使⽤#include <iostream>//exit需要使⽤#define OK 1#define ERROR 0#define OVERFLOW -1//判断是否溢出的时候要使⽤#define LIST_INIT_SIZE 10#define LISTINCREMENT 100typedef int ElemType;typedef int Status;typedef struct{ElemType *elem;int length;int listsize;}SqList;//建⽴顺序表Status InitList_Sq(SqList &L,int n){L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配内存if(!L.elem)exit(OVERFLOW);printf("请输⼊顺序表中元素:");for(int i=0;i<n;i++){scanf("%d",&L.elem[i]);}L.length=n;L.listsize=LIST_INIT_SIZE;return OK;}//输出顺序表中的元素Status ExitList_Sq(SqList L){for(int i=0;i<L.length;i++){printf("%d ",L.elem[i]);}printf("\n");}//顺序表的插⼊Status InsertList_Sq(SqList &L,int i,ElemType e){if(i<1||i>L.length+1)return ERROR;//判断位置是否有效if(L.length>=L.listsize){//判断是否需要重新分配内存ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));//重新分配内存,这⾥newbase对应的是elem,所以定义的时候必须是ElemType *newbaseif(!newbase)exit(OVERFLOW);//重新分配完之后还要判断是否溢出L.elem=newbase;//把新的内存赋给L.elemL.listsize+=LISTINCREMENT;}ElemType *q=&(L.elem[i-1]);//定义⼀个指针指向需要插⼊的位置ElemType *p=&(L.elem[L.length-1]);//定义⼀个指针指向指针的末尾for(p;p>=q;p--){*(p+1)=*p;//就是把倒数第⼀赋给倒数第⼆,倒数第三赋给倒数第⼆...... }*q=e;//最后吧需要插⼊的元素的值赋给qL.length++;//顺序表的长度加⼀return OK;}//顺序表的删除Status DeleteList_Sq(SqList &L,int i){if(i<1||i>L.length)return ERROR;//判断位置是否有效ElemType *p=&(L.elem[i-1]);//定义⼀个指针指向要删除位置ElemType *q=&(L.elem[L.length-1]);//定义⼀个指针指向顺序表的末尾for(p;p<=q;p++){*p=*(p+1);//将删除位置以下的元素依次向上赋值}L.length--;//顺序表的长度减⼀return OK;}int main(){SqList L;int n;printf("请输⼊顺序表中元素的个数:");scanf("%d",&n);InitList_Sq(L,n);//建⽴顺序表ExitList_Sq(L);int i;ElemType e;//顺序表的插⼊printf("请输⼊想插⼊的位置:");scanf("%d",&i);printf("请输⼊想插⼊的元素:");scanf("%d",&e);InsertList_Sq(L,i,e);ExitList_Sq(L);printf("请输⼊想删除的位置:");//顺序表的删除int m;scanf("%d",&m);DeleteList_Sq(L,m);ExitList_Sq(L);}5.实验结果。

数据结构与算法实验一顺序表

数据结构与算法实验一顺序表

数据结构与算法实验一顺序表
本实验主要是针对顺序表的操作进行实践。

顺序表是一种线性表,其元素是按照一定顺序排列的。

顺序表的实现基于数组,因此支持随机访问,但插入和删除元素时需要移动大量元素,效率较低。

本实验主要包含以下内容:
1. 创建顺序表:通过动态分配内存,创建一个指定大小的顺序表。

2. 插入元素:在指定位置插入一个元素,需要注意顺序表已满
的情况。

3. 删除元素:删除指定位置的元素,需要注意顺序表为空的情况。

4. 查找元素:按照指定方式查找符合条件的元素,例如查找最
大值、最小值、指定值等。

5. 排序:按照指定方式对顺序表进行排序,例如冒泡排序、选
择排序、插入排序等。

通过本实验的实践,可以加深对顺序表的理解,并掌握常用的操作方式。

同时,实践过程中还需要注意代码的规范性和注释的清晰性,提高编程能力。

- 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。

数据结构实验,线性表的插入和删除,单链表操作,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.掌握线性表的顺序存储结构的表示和实现方法。

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

3.了解顺序表的应用。

4.学会用Java语言编写算法并上机调试通过。

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

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

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

4.完成一个简单学生成绩管理系统的设计(应用性设计内容)。

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

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

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

(4)在顺序表中查找第i个元素,如果查找成功,则显示“查找成功”和该元素在顺序表中的位置,否则显示“查找失败”。

2. 设计性实验要求编程实现删除有序顺序表中的所有重复元素,即使有序顺序表中相同的元素只保留一个:(1) 根据输入的n个非递减的有序数据建立一个有序顺序表,并输出有序顺序表中各元素值。

(2) 删除有序顺序表中所有的重复元素,并显示删除后的有序顺序表中各元素值。

3. 应用性设计实验要求编程实现一个简单学生成绩表的操作,此系统的功能包括:(1) 查询:按特定的条件查找学生(2) 修改:按学号对某个学生的某门课程成绩进行修改(3) 插入:增加新学生的信息(4) 删除:按学号删除已退学的学生的信息。

要求采用顺序存储结构来实现对上述成绩表的相关操作。

四、源程序代码/**** 验证性实验的源程序代码**/import java.util.Scanner;public class SX1_SqList {private Object[] listElem; // 线性表存储空间private int curLen; // 当前长度// 顺序表的构造函数,构造一个存储空间容量为maxSize的线性表public SX1_SqList(int maxSize) {curLen = 0; // 置顺序表的当前长度为0listElem = new Object[maxSize];// 为顺序表分配maxSize个存储单元}// 在线性表的第i个数据元素之前插入一个值为x的数据元素。

数据结构实验顺序表的基本操作

数据结构实验顺序表的基本操作

数据结构实验-顺序表的基本操作顺序表是一种线性数据结构,它的元素在内存中是连续存储的。

顺序表具有随机访问的特点,可以通过下标直接访问元素,因此在访问元素时具有较高的效率。

顺序表的基本操作包括插入、删除、查找等,下面将对这些基本操作进行详细介绍。

1. 初始化:初始化顺序表需要为其分配一定的内存空间,以存储元素。

可以使用静态分配或动态分配两种方式来初始化顺序表。

静态分配是在编译时为顺序表分配固定大小的内存空间,而动态分配是在运行时根据需要动态地为顺序表分配内存空间。

2. 插入操作:插入操作是将一个元素插入到顺序表的指定位置上。

在插入元素之前,需要判断顺序表是否已满,如果已满则需要进行扩容操作。

插入元素时,需要将插入位置以及其后的元素向后移动一位,为插入元素腾出位置。

插入操作的时间复杂度为O(n),其中n为顺序表的长度。

3. 删除操作:删除操作是将顺序表中的一个元素删除。

在删除元素之前,需要判断顺序表是否为空,如果为空则无法进行删除操作。

删除元素时,需要将删除位置后面的元素向前移动一位,覆盖删除位置上的元素。

删除操作的时间复杂度为O(n),其中n为顺序表的长度。

4. 查找操作:查找操作是根据给定的关键字,在顺序表中查找满足条件的元素。

可以使用顺序查找或二分查找两种方式进行查找。

顺序查找是从顺序表的第一个元素开始,逐个比较关键字,直到找到满足条件的元素或遍历完整个顺序表。

二分查找是在有序顺序表中进行查找,每次将待查找区间缩小一半,直到找到满足条件的元素或待查找区间为空。

查找操作的时间复杂度为O(n),其中n为顺序表的长度。

5. 修改操作:修改操作是将顺序表中的一个元素修改为新的值。

修改操作需要先进行查找操作,找到待修改的元素,然后将其值修改为新的值。

修改操作的时间复杂度为O(n),其中n为顺序表的长度。

6. 遍历操作:遍历操作是依次访问顺序表中的每个元素。

可以使用for循环或while循环进行遍历,从第一个元素开始,依次访问每个元素,直到遍历完整个顺序表。

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

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

元素之后的所有数据都前移一个位置,最将线性表长减1。

3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。

线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool ListEmpty(SqList *L)//判线性表是否为空表{return(L->length==0);}int ListLength(SqList *L)//求线性表的长度{return(L->length);}void DispList(SqList *L)//输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。

顺序表的查找 删除 插入

顺序表的查找 删除 插入

数据结构实验报告(一)实验一:线性表的基本操作一、实验目的1.掌握使用Turbo C上机调试线性表的基本方法;2.掌握顺序表的基本操作:插入、删除运算的实现。

二、实验要求1、阅读下面的程序,分析各个函数的功能,并输入数据调试。

2、现要删除线性表某位置上的元素,并保持线性表原有的顺序不变,请在给出的程序中加入一个删除函数,实现上述功能要求。

ElemType delete_sq(SqList *L, int i)为删除函数的原型,L表示线性表,I表示插入位置。

注意菜单中给出了菜单项,请在switch语句给出调用语句,#include <stdio.h>#include <stdlib.h>#define MAXSIZE 20typedef int ElemType;typedef struct{ ElemType a[MAXSIZE];int length;}SqList;SqList a,b,c;void creat_list(SqList *L);void out_list(SqList L);void insert_sq(SqList *L,int i,ElemType e);int locat_sq(SqList L,ElemType e);main(){ int i,k,loc; ElemType e,x;do { printf("\n\n\n");printf("\n 1. creat " );printf("\n 2. insert");printf("\n 3. delete");printf("\n 4. find");printf("\n 5. end");printf("\n***************");printf("\n input:1-5");scanf("%d",&k);switch(k){ case 1:{ creat_list(&a); out_list(a);} break;case 2:{ printf("\n i,e=?"); scanf("%d,%d",&i,&e);insert_sq(&a,i,e); out_list(a);} break;case 3:{ printf("\n i=?"); scanf("%d",&i);DeleteList(&a,i); out_list(a);} break;case 4:{ printf("\n e=?"); scanf("%d",&e);loc=locat_sq(a,e);if (loc==-1) printf("\n not find %d",loc);else printf("\n find weizhi shi %d",loc);} break;} /* switch */}while(k!=5);printf("\n byebye");printf("\n enter,return");getch();}void creat_list(SqList *L){ int i;printf("\n n=?"); scanf("%d",&L->length);for(i=0;i<L->length;i++){ printf("\t data %d=?",i);scanf("%d",&(L->a[i]));}} /* creat_list */void out_list(SqList L){ int i; char ch;printf("\n");for(i=0;i<=L.length-1;i++) printf("%10d",L.a[i]);printf("\n\n "); getch();} /* out_list */void insert_sq(SqList *L,int i,ElemType e){ int j;if(i<1||i>L->length+1){printf("error");}//保证i插入的位置是第一个之前到最后一个之后插入的L->length++;//L的长度加1for(j=L->length-1;j>=i-1;j--)L->a[j+1]=L->a[j]; //将第i个元素(包括本身)向后移一位.L->a[i-1]=e;//第i个位置赋上e的值} /* insert_sq */int locat_sq(SqList L, ElemType e){ int i=0;while(i<=L.length-1 && L.a[i]!=e) i++;if(i<=L.length-1) return(i+1);else return(-1);}/* locat_sq */int DeleteList(SqList *L,int i){int j;if(i<1||i>L->length){printf("error");return -1;}//保证删除的是第一个到最后一个之间的元素L->length--;//L的长度减1for(j=i-1;j<L->length;j++)L->a[j]=L->a[j+1];//将i向后的元素向后移一位return 1;}三、实验结果1﹑查找2、插入3、删除。

数据结构 顺序表 建立 插入 删除 实验

数据结构 顺序表 建立  插入 删除 实验
{
if(slt->size==maxsize)
{printf("顺序表是满的\n");}
slt->a[slt->size]=x;
slt->size=slt->size+1;
}
void dele(sequence_list *slt,int y )
{
int i;
if(slt->size==0)
{printf("\n顺序表是空的");}
for(i=0;i<slt->size;i++)
{
if(slt->a[i]==y)
{for(;i<slt->size-1;i++)
slt->a[i]=slt->a[i+1];
}
}
slt->size--;
}
void main()
{
int number,j;
init(&mylist);
display(mylist);
dele(&mylist,y);
display(mylist);
printf("\n删除成功\n");
}
#include<stdio.h>
#include<conio.h>
#define maxsize 100
typedef int datatype;
typedef struct
{
datatype a[maxsize];
printf("请输入你要插入的数x和它的位置positio\n");

实验一数据结构顺序表的插入和删除

实验一数据结构顺序表的插入和删除

实验一顺序表的操作1.实验题目:顺序表的操作2.实验目的和要求:1)了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。

2) 通过在Turbo C(WinTc,或visual stdio6)实现以上操作的C语言代码。

3)提前了解实验相关的知识(尤其是C语言)。

3.实验内容:(二选一)1) 顺序表的插入算法,删除算法,顺序表的合并算法2) 与线性表应用相关的实例(自己选择具体实例)4.部分参考实验代码:⑴顺序表结构的定义:#include <stdio.h>#define MAXLEN 255typedef int ElemType;typedef struct{ ElemType elem[MAXLEN];int length;}sqList;⑵顺序表前插(在第i号元素前插入一个新的元素)int ListInsert(sqList *la,int i,int x){ int j;if(i<0||i>la-> length +1){ printf(“\n the value of i is wrong!”);return 0;}if(la-> length +1>=MAXLEN){ printf(“\n overflow!”);return 0;}. for(j=la-> length;j>=i;j--)la->list[j+1]=la->list[j];la->list[i]=x;la-> length ++;return 1;}⑶顺序表删除int ListDelete(sqList *la,int i){ if(i<0||i>la-> length){ printf(“\n the position is wrong!\n”);return 0;}for(i;i<la-> length;i++)la->list[i-1]=la->list[i];la-> length --;return 1;}5.附录:实验预备知识:⑴复习C语言中数组的用法。

实验一、顺序表的插入和删除操作

实验一、顺序表的插入和删除操作
ElemType elem[MaxSize];
int len;
} SQlist;
void insert( SQlist *L, int i , ElemType x ){
int j;
for(j=L->len; j>=i; j--)
L->elem[j+1]=L->elem[j];
L->elem[i]=x;
山东英才学院
课年月日
学院(系)班姓名学号
实验题目:实验一、线形表的的插入、删除操作成绩:
一、实验目的和要求
1.掌握线性表的概念。
2.掌握线性表的插入、删除和查找算法。
二、实验原理
线性表(Linear List)是具有相同数据类型的数据元素的一个有限序列。
1.插入
线性表的插入操作是指在线性表的第i-1个数据元素和第i个数据元素之间插入一个新的数据元素b,就是要使长度为n的线性表(a1 ,…,ai-1 ,ai ,…an)变成长度为n+1的线性表(a1 ,…,ai-1 ,b ,ai ,…an)
while(1)
{
printf("\t\t\t 1继续录入,2退出并排序\n");
scanf("%d",&j);
if(j==2) break;
else {
printf(“please input the value k and x: ”);
scanf(“%d”,&k);
scanf(“%d”,&x);
3、查找
查找操作是指在具有n个结点的线性表中查找结点x在表中的位置,表的长度不发生变化。
三、主要仪器设备或材料
1、计算机一台

顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢复习过程

顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢复习过程
creatsqlist(l);
initsqlist(l);
cout<<endl<<"**************************************************************************"<<endl;
cout<<"请输入要进行的操作序号:\n";
cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"0.退出"<<endl<<endl;
顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢
实验一顺序表的实现
实验目的:熟练掌握顺序表的基本操作(插入、删除、查找等)
置查找)
实验要求:以顺序表的动态分配存储结构来实现;所有基本操作均应该以函数的形式表示;要有运行结果并考虑到顺序表中所有情况。
if(list.data[i]==b)
{j=i+1;break;}
if(j)
cout<<"该数字的位置是:"<<j<<endl;
else
cout<<"很抱歉,表中没有这个数字,请重试!"<<endl;
}
5、插入函数insert(list)
void insert(sqlist &list)//插入函数

顺序表的插入和删除

顺序表的插入和删除

《数据结构》实验报告实验名称:顺序表的插入和删除班级学号:学生姓名:指导老师:实验日期: 2012-10-26实验二顺序表的插入和删除实验学时:2学时一. 实验目的1.掌握顺序表的存储结构;2.掌握在顺序表上进行的插入、删除等操作。

二. 实验内容对已定义好的顺序表编写插入、删除等函数。

三. 实验重点插入、删除函数的编写。

四. 实验要求1.用C语言完成顺序表插入、删除函数的编写;2.源程序必须编译调试成功,结果正确。

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

六. 实验过程分实验预习、上机操作和实验报告三部分。

七. 原始程序#include <stdio.h>#include <malloc.h>#define MAXSIZE 100 //顺序表的最大长度typedef struct{int data[MAXSIZE];int curLength; //当前长度}SqList;void Init_Sq(SqList *L); //顺序表的初始化void Show_Sq(SqList *L); //顺序表的显示int Insert_Sq(SqList *L,int x,int i); //顺序表的插入int Delete_Sq(SqList *L,int i); //顺序表的删除void main(){SqList *L;L=(SqList*) malloc(sizeof(SqList));//初始化操作Init_Sq(L);printf("原始顺序表:\n");Show_Sq(L);//插入操作Insert_Sq(L,23,4);printf("插入之后顺序表:\n");Show_Sq(L);//删除操作Delete_Sq(L,1);printf("删除之后顺序表:\n");Show_Sq(L);}//顺序表的初始化void Init_Sq(SqList *L){printf("请输入初始化数据(以“-1”结束):");int b=0;int i=0;L->curLength=0;scanf("%d",&b);while(b!=-1){L->data[i]=b;i++;L->curLength++;scanf("%d",&b);}}//顺序表的显示void Show_Sq(SqList *L){int i;if(L->curLength==0){printf("顺序表中没有元素!\n");return;}else{for(i=0;i<L->curLength;i++)printf("%d\n",L->data[i]);}}//顺序表的插入int Insert_Sq(SqList *L,int x,int i){//实现插入操作return(1);}//顺序表的删除int Delete_Sq(SqList *L,int i){//实现删除操作return(1);}一、实验内容对已定义好的顺序表编写插入、删除等函数。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验一顺序表的操作
1.实验题目:顺序表的操作
2.实验目的和要求:
1)了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。

2) 通过在Turbo C(WinTc,或visual stdio6)实现以上操作的C语言代码。

3)提前了解实验相关的知识(尤其是C语言)。

3.实验内容:(二选一)
1) 顺序表的插入算法,删除算法,顺序表的合并算法
2) 与线性表应用相关的实例(自己选择具体实例)
4.部分参考实验代码:
⑴顺序表结构的定义:
#include <stdio.h>
#define MAXLEN 255
typedef int ElemType;
typedef struct
{ ElemType elem[MAXLEN];
int length;
}sqList;
⑵顺序表前插(在第i号元素前插入一个新的元素)
int ListInsert(sqList *la,int i,int x)
{ int j;
if(i<0||i>la-> length +1)
{ printf(“\n the value of i is wrong!”);
return 0;
}
if(la-> length +1>=MAXLEN)
{ printf(“\n overflow!”);
return 0;
}
. for(j=la-> length;j>=i;j--)
la->list[j+1]=la->list[j];
la->list[i]=x;
la-> length ++;
return 1;
}
⑶顺序表删除
int ListDelete(sqList *la,int i)
{ if(i<0||i>la-> length)
{ printf(“\n the position is wrong!\n”);
return 0;
}
for(i;i<la-> length;i++)
la->list[i-1]=la->list[i];
la-> length --;
return 1;
}
5.附录:实验预备知识:
⑴复习C语言中数组的用法。

⑵了解线性表和顺序表的概念,顺序表的定义方法;
线性表是n个数据元素的有限序列,至于每个数据元素的具体含义,在不同的情况下各不相同。

顺序表是线性表的顺序存储表示,是用一组地址连续的存储单元依次存储线性表的数据元素。

在C语言中,顺序表是用数组来实现的。

⑶掌握线性表在顺序存储结构上实现基本操作:查找、插入、删除和合并
的算法。

在实现这些算法的时候,要注意判断输入数据的合法性,除此之外还要要注意以下内容:
在实现查找的时候,首先要判断该顺序表是否为空,其次要判断查找后的结果(查到时输出查到的数据,未查到时给出未查到提示)。

在实现插入的时候,首先要判断该顺序表是否为满,如为满则报错(此时要注意:顺序表是用数组来实现的,它不能随机分配空间);如
不为满,则需判断要插入的位置是否合法(例如:如果一个线性表的
元素只有10个,而要在第0个元素前插入或在第11个元素后插入就
为不合法)。

其次要注意是前插还是后插,两者是有区别的;最后还要
注意插入时各个数据元素移动的次序是从后面依次开始移动。

在实现删除的时候,首先要判断该顺序表是否为空,如为空则报错,如不为空,则需判断要删除的位置是否合法(例如:如果一个线性表
的元素只有10个,而要删除第0个或第十一个元素就为不合法)。


次还要注意删除时各个数据元素移动的次序是从前面依次开始移动。

相关文档
最新文档