实验一 顺序存储线性表的基本运算
实验01 线性表的基本操作
实验01 线性表的基本操作一、实验目的1. 了解线性表的结构特点及有关概念；2. 理解线性表的存储结构；3. 掌握顺序表及单链表的基本操作算法。
二、实验内容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.顺序表初始化:(1)为顺序表L动态分配一个预定大小的数组空间，使elem 指向这段空间的基地址。
(2)将表的当前长度设为0.2.顺序表的取值:(1)判断指定的位置序号i值是否合理（1<=i<=L.length），若不合理则返回ERROR.(2)若i值合理，则将i个数据元素L.elem[i]赋给参数e,通过e返回第i个数据元素的传值。
3.顺序表的查找:(1)从第一个元素起，依次和e相比较，若找到与e相等的元素L.elem[i]，则查找成功，返回该元素的序号i+1.(2)若查遍整个顺序表都没要找到，则查找失败，返回0.4．顺序表的插入:(1)判断插入位置i是否合法(i值的合法范围是1<=i<=n+1)，若不合法则返回值ERROR.(2)判断顺序表的存储空间是否已满，若满则返回值ERROR(3)将第n个至第i个位置的元素依次向后移动一个位置，空出第i个位置(i=n+1时无需移动)。
实验一 线性表的顺序存储及其操作
实验一线性表的顺序存储及其操作一、实验目的与基本要求1．掌握数据结构中的一些基本概念。
数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。
2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。
3．掌握线性表的基本操作：插入、删除、查找等运算。
4．掌握运用C语言上机调试线性表的基本方法。
二、实验条件1．硬件：一台微机2．软件：操作系统和C语言系统三、实验方法确定存储结构后，上机调试实现线性表的基本运算。
四、实验内容在你自己的文件下，建立一个C语言程序SL.C，完成下列要求：（1）定义一个长度为10的数组A，即顺序表的形式，并输入数据1,3,4,5,7,9,12,20,28九个数据，然后输出这九个数组元素的存储单元地址和相应的数值；（2）建立一个数组元素的插入函数，能够按照数据从小到大的次序自动找到插入位置完成插入元素的操作，调用此函数插入数据15，然后输出数值元素的存储单元地址和相应的数值；（3）建立一个数组元素的删除函数，能够按照数据自动删除指定元素的操作，调用此函数删除数据值为9的数组元素，然后输出数组元素的存储单元地址和相应的数值。
程序清单如下：#include <stdio.h>#include<stdlib.h>#include<string.h>void outsl( int n, int a[]){int i;for (i=0;i<=n-1;i++)printf("No.=%d ADD=%x DATA=%d\n", i+1, &a[i], a[i]);getch();}int inssl(int n, int a[], int x){int i=n-1;while (x<a[i]&&i>0){ a[i+1]=a[i];i--;}a[i+1]=x;n++;return(n);}int dlsl( int n, int a[], int x){ int i, m, ok=0;for (i=0;i<=n-1;i++){ if (x==a[i]){ m=i; ok=1; break;}}if (ok==0)printf("No this element %d\n", x); else{ for (i=m; i<=n-1; i++)a[i]=a[i+1];n--;}return(n);main(){int a[10]={1,3,4,5,7,9,12,20,28},n=9; outsl(n,a);printf("==output==\n");n=inssl(n,a,15);printf("==insert==\n");outsl(n,a);printf("==output==\n");n=dlsl(n,a,9);printf("==delete==\n");outsl(n,a);printf("==output==\n");}在“文件”选项（file）里选“新建”（new）,在出来的选项卡中选择win32 console application,然后在右上方“工程名称”（progect name）中随便起个名字，下面选一个保存地址。
数据结构实验报告-实验：1线性表的顺序存储和操作实现
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空，即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度："+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
实验一 线性表操作实验题目
实验一线性表操作实验目的：(1)掌握在顺序、链式存储结构上实现线性表的各种基本运算。
(2)重点掌握单链表的基本操作及应用。
(3)学会综合运用C语言中函数、指针、结构体等知识进行编程。
本次实验中，下列实验项目选做一。
1、顺序表的综合操作[问题描述]设计算法，实现线性结构上的顺序表的建立以及元素的查找、插入、删除等操作。
[基本要求及提示]（1）从键盘输入10个整数，建立顺序表。
（2）从键盘输入1个整数，在顺序表中查找该结点的位置。
若找到，输出结点的位置；若找不到，则显示“找不到”。
（3）从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。
（4）从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。
（5）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
2、线性表的逆置[问题描述]（1）以顺序存储结构实现线性表的就地逆置。
（2）以链式存储结构实现线性表的就地逆置。
注：线性表的就地逆置就是在原表的存储空间内将线性表（a1,a2,a3,…,an）逆置为（an，an-1，…，a2，a1）。
[基本要求及提示]（1）从键盘输入10个整数，建立顺序表。
（2）实现顺序表逆置，并将结果输出。
（3）从键盘输入10个整数，建立链表。
（4）实现链表逆置，并将结果输出。
（5）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。
也可以将顺序表和链表上的操作分开，做成两个程序。
3、线性表的元素分类[问题描述]已知线性表中元素均为正整数，设计算法将其调整为前后两部分，前边均为奇数，后边均为偶数。
即实现线性表的元素的分类。
[基本要求及提示]（6）从键盘输入10个整数，建立顺序表。
（7）实现顺序表上的元素分类，并输出结果。
（8）从键盘输入10个整数，建立链表。
（9）实现链表的元素分类，并输出结果。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置，最将线性表长减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：顺序表基本操作一、实验目的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.(8)打印输出La中的元素值。
主函数见课本P61，各函数具体定义参考P53-60.源程序：//以为例a[12]={3,6,9,12,15,18,21,24,27,30,33,36}为例#include<iostream.h>#include<stdlib.h>typedef int ElemType;struct List {ElemType *list;int size;int MaxSize;};void InitList(List &L) //初始化顺序表La{L.MaxSize=10;L.list=new ElemType[L.MaxSize];if(L.list==NULL){cout<<"动态可分配的存储空间用完，退出运行!"<<endl;exit(1);}L.size=0; //将La置为空表}void ClearList(List &L) //销毁La{if(L.list!=NULL){delete []L.list;L.list=NULL;}L.MaxSize=0;L.size=0;}int LenthList(List &L){return L.size;}bool EmptyList(List &L){return L.size==0;}ElemType GetList(List &L,int pos){if(pos<1 || pos>L.size){cerr<<"pos is out range!"<<endl;exit(1);}return L.list[pos-1];}void TraverseList(List &L) //遍历顺序表la{for(int i=0; i<L.size; i++)cout<<L.list[i]<<' ';cout<<endl;}//在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0。
线性表的顺序存储结构实验报告
南昌航空大学实验报告课程名称：数据结构实验名称：实验一线性表的顺序存储结构班级：XXX 学生姓名：XXX 学号：XXXXX指导教师评定：XXX 签名:XXX设计并实现以下算法：有两张非递增有序的线性表A，B，采用顺序存储结构，两张表合并用C表存，要求C仍为非递增有序的，并删除C表中值相同的多余元素。
一、需求分析⒈本程序中，要求输入到表A,B中的元素是整形的，并且要按非递增顺序输入，否则系统会给出“出错信息”。
输出结果应该是一个不含有重复元素的非递增的表。
⒉本程序以用户和计算机的对话方式执行，即在计算机演示界面上显示“提示信息”后，由用户在键盘上输入相应的信息；相应的输入数据和运算结果显示在其后。
⒊程序执行的命令包括：（1）构造线性表A （2）构造线性表B （3）检验表A,B是否非递减有序（4）求表A与B的合并（5）删除表中值相同的多余元素（6）结束。
4.测试数据（1）A=1 2 3（2）A=9 5 0 -2B=10 5 0 -1 -3 -5 -10二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Stack {数据对象：D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系：R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n}基本操作:init(list *L)操作结果：构造一个空的线性表L。
InputList(List *L)初始条件：线性表L已经存在操作结果：人工输入了一张表。
CheckList(List *L)初始条件：线性表L已经存在操作结果：判断L是否非递增有序，若为否，则重新输入。
MergeList(List *La,List *Lb,List *Lc)初始条件：非递增线性表La，Lb已经存在操作结果：合并La，Lb得到Lc，Lc仍按非递增有序排列。
DeleteSame(List *L)初始条件：非递增线性表L已经存在操作结果：删除了L中值相同的元素。
实习01_线性表的顺序存储和操作(有序表的合并)
实验一线性表的顺序存储和操作(有序表的合并)1.目的用顺序表(SqList)类型实现书上算法2.1和2.2,了解线性表及在计算机中的两类不同的存储结构;熟练掌握线性表的查找、插入和删除等算法并灵活运用这些算法。
2.要求用C语言编写程序,其中Lb={2,4,6,8,10} La={1,2,3,4,5},①算法2.1执行后,得到的new La = 1,2,3,4,5,6,8,10②修改Lb=2,6,8,9,11,15,20,并利用新生成的La,得到合并后的Lc,Lc= 1,2,2,3,4,5,6,6,8,8,9,10,11,15,203、预习要求:1、复习书上第20页的例2-1和例2-2;2、复习算法2.3,理解如何构造线性表;3、复习算法2.7,理解算法的执行步骤和含义;4、项目介绍:前面的课程已经学习了如何用C语言描述顺序表、如何初始化顺序表、以及如何在顺序表中插入和删除数据元素。
现在通过两个顺序表的合并的实验,加深对顺序表的理解,熟悉如何将逻辑上的数学模型转化为计算机能够理解的指令代码。
该实验是数据结构课程的第一个实验,实验的目标除了加深理解课堂内容外,还对学生的动手能力提出了更高的要求,锻炼学生动手的能力。
5、算法设计#include <stdio.h>#include <stdlib.h>#include <malloc.h># define TRUE 1# define ERROR 0# define OK 1# define OVERFLOW -2# define FALSE 0# define LIST_INIT_SIZE 10# define LISTINCREMENT 5void main(){List La,Lb,Lc;int j,b[7]={2,6,8,9,11,15,20};InitList(La); // 创建空表La。
如不成功,则会退出程序的运行for(j=1;j<=5;j++) // 在表La中插入5个元素,依次为1、2、3、4、5 ListInsert(La,j,j);printf("La= ");ListTraverse(La,printer); // 输出表La的内容InitList(Lb); // 创建空表Lbfor(j=1;j<=5;j++) // 在表Lb中插入5个元素,依次为2、4、6、8、10 ListInsert(Lb,j,2*j);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容Union(La,Lb); // 调用算法2.1,将Lb中满足条件的元素插入La(不改变Lb) printf("new La= ");ListTraverse(La,printer); // 输出新表La的内容ClearList(Lb); // 清空表Lbfor(j=1;j<=7;j++) // 在表Lb中重新依次插入数组b[]的7个元素ListInsert(Lb,j,b[j-1]);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容MergeList(La,Lb,Lc); // 调用算法2.2,生成新表Lc(不改变表La和表Lb)printf("Lc= ");ListTraverse(Lc,printer); // 输出表Lc的内容}6.小结线性表是软件设计中最基础的数据结构。
实验一--线性表基本操作的编程实现
实验一--线性表基本操作的编程实现实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求：线性表基本操作的编程实现（2学时，验证型），掌握线性表的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、逆序、排序等操作，存储结构可以在顺序结构或链表结构中任选，可以完成部分主要功能，也可以用菜单进行管理完成大部分功能。
还鼓励学生利用基本操作进行一些更实际的应用型程序设计。
【实验性质】验证性实验（学时数：2H）【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。
建议实现键盘输入数据以实现程序的通用性。
为了体现功能的正常性，至少要编制遍历数据的函数。
【注意事项】1.开发语言：使用C。
2.可以自己增加其他功能。
【思考问题】1.线性表的顺序存储和链表存储的差异？优缺点分析？2.那些操作引发了数据的移动？3.算法的时间效率是如何体现的？4.链表的指针是如何后移的？如何加强程序的健壮性？【参考代码】（以下内容，学生任意选择一个完成即可）（一）利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1) #include<stdio.h>#include<conio.h>#define ListSize 100 //根据需要自己设定一个班级能够容纳的最大学生数(2) typedef struct stu{int num; //学生的学号char name[10]; //学生的姓名float physics; //物理成绩float math; //数学成绩float english; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{STUDENT stu[ListSize]; //存放学生的数组定义，静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=1; ;i++) //输入m个学生的所有信息{printf("请输入第%d位学生的信息:\n",i);printf("学号=");scanf("%d",&Li->stu[i].num); //输入第i个学生的学号printf("姓名=");scanf("%s",&Li->stu[i].name); //输入第i个学生的姓名printf("物理成绩=");scanf("%f",&Li->stu[i].physics); //输入第i 个学生的物理成绩printf("数学成绩=");scanf("%f",&Li->stu[i].math); //输入第i个学生的数学成绩printf("英语成绩=");scanf("%f",&Li->stu[i].english); //输入第i 个学生的英语成绩; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解和掌握线性表的顺序存储结构，通过实际编程实现线性表的基本操作，如创建、插入、删除、查找和遍历等，从而提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言是 C 语言，开发环境为 Visual Studio 2019。
三、实验原理线性表是一种最基本、最简单的数据结构，它是由 n（n≥0）个数据元素组成的有限序列。
在顺序存储结构中，线性表的元素存储在一块连续的存储空间中，逻辑上相邻的元素在物理位置上也相邻。
通过数组来实现顺序存储结构，可以方便地进行随机访问，但插入和删除操作的效率较低，因为可能需要移动大量元素。
四、实验内容及步骤1、定义线性表的数据结构｀｀｀cdefine MAXSIZE 100 ／／线性表的最大长度typedef struct ｛int dataMAXSIZE; ／／存储线性表元素的数组int length; ／／线性表的当前长度｝ SeqList;｀｀｀2、初始化线性表｀｀｀cvoid InitList(SeqList L) ｛L>length ＝ 0;｝｀｀｀3、判断线性表是否为空｀｀｀cint ListEmpty(SeqList L) ｛if （Llength ＝＝ 0) ｛return 1;｝ else ｛return 0;｝｝｀｀｀4、求线性表的长度｀｀｀cint ListLength(SeqList L) ｛return Llength;｝｀｀｀5、按位置查找元素｀｀｀cint GetElem(SeqList L, int i, int e) ｛if （i ＜ 1 ｜｜ i ＞ Llength) ｛return 0;｝e ＝ Ldatai 1;return 1;｝｀｀｀6、按值查找元素的位置｀｀｀cint LocateElem(SeqList L, int e) ｛int i;for （i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ e) ｛return i ＋ 1;｝｝return 0;｝｀｀｀7、插入元素｀｀｀cint ListInsert(SeqList L, int i, int e) ｛int j;if （L>length ＝＝ MAXSIZE) ｛／／表已满return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length ＋ 1) ｛／／插入位置不合法return 0;｝if （i ＜＝ L>length) ｛／／插入位置不在表尾for （j ＝ L>length 1; j ＞＝ i 1; j) ｛L>dataj ＋ 1 ＝ L>dataj;｝｝L>datai 1 ＝ e;L>length+＋；return 1;｝｀｀｀8、删除元素｀｀｀cint ListDelete(SeqList L, int i, int e) ｛int j;if （L>length ＝＝ 0) ｛／／表为空return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length) ｛／／删除位置不合法return 0;｝e ＝ L>datai 1;if （i ＜ L>length) ｛／／删除位置不在表尾for （j ＝ i; j ＜ L>length; j+＋）｛L>dataj 1 ＝ L>dataj;｝｝L>length;return 1;｝｀｀｀9、遍历线性表｀｀｀cvoid TraverseList(SeqList L) ｛int i;for （i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；｝｀｀｀五、实验结果与分析1、对创建的空线性表进行初始化操作，通过判断线性表是否为空的函数验证初始化是否成功。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置，最将线性表长减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语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法，掌握顺序表基本操作的算法实现，同时了解了顺序表的应用。
数据结构实验一线性表的顺序存储结构
实验一：线性表的顺序存储结构实验学时：2实验类型：验证一、实验目的：1. 熟练掌握线性表的基本操作在顺序存储和链式存储上的实现；2. 以线性表的各种操作（建立、插入、删除等）的实现为重点；3. 掌握线性表的动态分配顺序存储结构的定义和基本操作的实现；二、实验内容：1．输入一组整型数据，建立顺序表。
2．实现该线性表的删除。
3、实现该线性表的插入。
4．实现线性表中数据的显示。
5．实现线性表数据的查找和定位5、编写一个主函数,调试上述算法。
三、实验原理、方法和手段1.根据实验内容编程，上机调试、得出正确的运行程序。
2. 编译运行程序，观察运行情况和输出结果。
3. 写出实验报告（包括源程序和运行结果）。
四、实验条件运行Visual c++的微机一台五、实验步骤（程序清单）：（一）、程序代码：#include"stdafx.h"#include<iostream>usingnamespace std;typedefint elemtype;struct list{elemtype *p;int size;int maxsize;};void buildlist(list &a,int b)/*建立顺序表*/{if(b<=0){cout<<"数据有误" <<endl;}a.p=new elemtype[b];if(a.p==NULL){cout<<"动态可分配的空间用完，退出运行!"<<endl;}a.size=0;a.maxsize=b;}void clearlist(list &a)/*清空线性表*/{if(a.p!=NULL){delete []a.p;a.p=NULL;}a.maxsize =0;a.size=0;}bool insertlist(list &a,int pos,elemtype b)/*向线性表中按给定的位置插入一个元素*/ {int i;if(pos<=0||pos-1>a.size){cout<<"位置无效" <<endl;returnfalse;}if(a.maxsize<=a.size){a.p=(elemtype*)realloc(a.p,2*a.maxsize *sizeof(b));a.maxsize=2*a.maxsize;}for( i=a.size;i>=pos;i--)a.p[i]=a.p[i-1];a.p[i]=b;a.size++;returntrue;}bool deletelist(list &a,int pos)/*向线性表中按给定的位置删除一个元素*/{if(a.size==0){cout<<"线性表为空，删除无效！"<<endl;returnfalse;}if(pos<=0||pos>a.size){cout<<"位置无效" <<endl;returnfalse;}for(int i=pos-1;i<a.size-1;i++)a.p[i]=a.p[i+1];a.size--;if(float(a.size)<a.maxsize*0.4&&a.maxsize>10){a.p=(elemtype*)realloc(a.p,a.maxsize*0.5*sizeof(*(a.p)));a.maxsize=a.maxsize*0.5;}returntrue;}bool getlist(list a,int pos,elemtype &item)/*得到线性表中指定位置的元素*/{if(pos<=0||pos>a.size){cout<<"位置无效" <<endl;returnfalse;}item=a.p[pos-1];returntrue;}int findlist(list a,elemtype b)/*从线性表中查找具有给定值的第个元素*/{for(int i=0;i<a.size;i++)if(a.p[i]==b)return i+1;return 0;}void display(list a)/*线性表中数据的显示*/{cout<<"顺序表元素个数为："<<a.size <<endl<<"所占内存单元为："<<a.maxsize*sizeof(*(a.p)) <<"字节"<<endl<<"数据为：";for(int i=0;i<a.size;i++)cout<<a.p[i]<<" ";cout<<endl;}void main(){list L;int i=10;int pos;elemtype a,b,c;buildlist(L,5);for(int j=0;j<10;j++){insertlist(L,j+1,i);i--;}display(L);cout<<endl;cout<<"一、插入操作："<<endl;cout<<"位置：";cin>>pos;cout<<"数据：";cin>>a;if(insertlist(L,pos,a))cout<<"插入成功"<<endl;elsecout<<"插入失败"<<endl;display(L);cout<<endl;cout<<"二、删除操作："<<endl;cout<<"位置：";cin>>pos;if(deletelist(L,pos))cout<<"删除成功"<<endl;elsecout<<"删除失败"<<endl;display(L);cout<<endl;cout<<"三、定位操作："<<endl;cout<<"位置：";cin>>pos;if(getlist(L,pos,b))cout<<"该位置数据为"<<b<<endl;elsecout<<"定位失败"<<endl;cout<<"四、查找操作："<<endl;cout<<"数据：";cin>>c;if(findlist(L,c))cout<<"线性表中第一个等于该数据的位置为"<<findlist(L,c)<<endl; elsecout<<"线性表中没有等于该数据的元素"<<endl;clearlist(L);}（二）、程序运行结果六、实验分析与总结：通过本次实验，我发现了自己身上很多的不足：1.不知道什么时候才需要将函数的返回类型弄成bool类型；2.在编写函数体的时候，对排除非法情况考虑不周；3.对申请、追加及删除动态空间的语法不熟悉；4.没有思路对算法进行优化，例如，不知道怎样将所申请的动态空间适当缩小或放大。
实验一线性表的顺序存储结构实验报告页
L.n=n;
实验报告附页
L.n=0;
}
int Length(SeqList&L)//计算顺序表的长度{
return L.n;
}
int isEmpty(SeqList&L)//判断空否
{
return (L. n==0)?1:0;
}
int isFull(SeqList&L)//判断满否
{
{
L1.data=new DataT yp e[L1.maxSize]; if(! L1.data)
{
cout<<"存储分配错误！\n";
exit(1);
}
}
for(i nt i=1;i<=L2. n;i++)
L1.data[i-1]=L2.data[i-1];
};
int In sert(SeqList&L,i nt iQataTy pe& x)//顺序表插入
if(!L1.data)
主函数代码如下：
void mai n()
{
int ch;
int i;
DataT ype x;
SeqList L;
L.n=0;
in itList(L);
printf(”
**************\n");
顺序表复制
｝；
if(!L. n)return 0; if(i<1 || i>L. n)return 0; x=L.data[i-1];
for(i nt戸;j<L .n ;j++)
顺序存储线性表的基本运算(实验报告)
实验一顺序存储线性表的基本运算一、实验目的1、掌握线性表的定义、顺序存储的方法及基本操作。
2、2掌握将算法在VC++6.0语言环境下实现的过程。
二、实验原理利用线性表的顺序存储结构完成一个班级的一个学期的所有课程成绩的管理，要求实现增加、删除学生的成绩记录等运算。
三、实验仪器和设备1、PC微机２、Microsoft VC++6.0四、预习要求1、复习线性表的定义、线性表的顺序存储结构的定义以及顺序存储线性表的增加、删除元素的算法。
2、掌握顺序存储线性表的C语言的实现。
五、实验内容及步骤编写程序如下：#include <stdio.h>#include <stdlib.h>#include <string.h>#define Max_length 3typedef struct{int xh; /*学号*/char name[35]; /*姓名*/int c1,c2,c3; /*三门课程成绩*/} Element;/*删除第i个学生的记录算法*/int Delete_list(int i,Element s[ ] ,int *n_pointer){int j,n;n=*n_pointer;if((i<1) ||(i>n))return(0);for (j=i+1;j<=n;j++){/*移动*/s[j-1].xh=s[j].xh;// strcopy(s[j-1].name,s[j].name);s[j-1].name,s[j].name;s[j-1].c1=s[j].c1;s[j-1].c2=s[j].c2;s[j-1].c3=s[j].c3;}n--;*n_pointer=n;return (1);}/*查找学号为x的算法*/int Locate_list (Element s[ ], int n, int x){int i;for(i=1;i<=n;i++)if (s[i].xh==x)return (i);return (0);}/*修改学号为i的学生的记录函数*/int Change_list (int i, Element s[ ] ){if( (i<1) || (i>Max_length +1) ) return (0);printf ("Input data for updating :\n");scanf ("%d%s%d%d%d",s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3);return (1);}/*打印已建立的数据记录，n是记录总数*/void printf_list (Element s[ ],int n){int i;if(n>Max_length) return ;printf ("XH Name C1 C2 C3 \n");printf("--------------------------------------------\n");for(i=1;i<=n;i++)printf ("%4d%10s%7d%7d%7d\n",s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3); }/*在第i个记录的后面插入一个学生的记录算法*/int Insert_list (int i,Element s[ ],int *n_pointer){/*n_pointe存放已输入的最大记录数*/int j,n;n=*n_pointer;if((n== Max_length) || (i<1) || (i>n+1)) return (0);for(j=n;j>=1;j--) s[j+1]=s[j]; /*移动*/printf("Input Data for inserting (XH Name C1 C2 C3) \n");scanf("%d%s%d%d%d",&s[i].xh,&s[i].name,&s[i].c1,&s[i].c2,&s[i].c3);n++;*n_pointer=n;return (1);}void main ( ){int i, records=0;Element s[Max_length];/*创建线性表*/for (i=1;i<=Max_length;i++)Insert_list ( i, s, &records);/*创建线性表*/printf_list (s, records); /*显示学生记录内容*/}上机调试、运行源程序。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。
（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。
（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。
数据结构实验一 线性表的顺序存储及其操作 - 副本
实验一线性表的顺序存储及其操作一、【实验目的】掌握线性表在顺序存储下的插入与删除等基本运算二、【指导思想】用数组和线性表长存储线性表，实现线性表的基本操作。
三、【实验内容】实现顺序表的建立、输入、输出、查找、插入、删除等功能，每个功能用一个函数实现。
（1）顺序表的基本操作实践。
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）上的元素9，实现顺序表的删除的基本操作。
（2）请编写求两个集合A、B的交集A∩B的程序。
集合A、B用顺序表存储。
例如A={2，3，4，1，5，6，7}，B={3，2，9，8，7，6}，输出A∩B的结果={2,3,7,6}例如：四、【源程序及运行结果】参考：顺序表的存储结构定义typedefstruct{ElemType data[MAXSIZE]; /*存放顺序表的元素*/int length; /*顺序表的实际长度*/} SqList;#include<stdio.h>#include<stdlib.h>#define NULL 0typedefstruct element//集合元素的结构体{char data;struct element *next;}element;element init_element(element *head)//初始化集合（集合是用单链表存储结构存储的）{head=(element*)malloc(sizeof(struct element));head->next=NULL;return *head;}void readdata_element(element *head)//键盘输入每个集合的元素{char c;printf("请输入集合中的数据元素（以“F”为结束标志，结束输入）：\n");scanf("%c",&c);while(c!='F'){if((c>'a' && c<'z') ||( c>'0' && c<'9')){element *p;p=(element*)malloc(sizeof(struct element));p->data=c;p->next=head->next;head->next=p;scanf("%c",&c);}elseprintf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");}}void display_element(element * head)//输出集合中的所有元素{element *p;p=head->next;while(p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}void bing_element(element *head1,element * head2,element * head3)//求两个集合的并集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;p1=p1->next;}p2=head2->next;while(p2!=NULL){p1=head1->next;while((p1!=NULL) && (p1->data!=p2->data))p1=p1->next;if(p1==NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p2->data;p3->next=head3->next;head3->next=p3;}p2=p2->next;}}void jiao_element(element *head1,element *head2,element *head3)//求两个集合的交集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p2=head2->next;while((p2!=NULL) && (p2->data!=p1->data))p2=p2->next;if(p2->data==p1->data){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;}p1=p1->next;}}void cha_element(element *head1,element *head2,element *head3)//求两个集合的差集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p2=head2->next;while((p2!=NULL) && (p2->data!=p1->data))p2=p2->next;if(p2==NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;}p1=p1->next;}}void bu_element(element *head1,element *head2,element *head3)//求集合的补集{element *p1,*p2,*p3;p1=head1->next;p2=head2->next;while(p1!=NULL){while((p2!=NULL) && (p1->data!=p2->data)){p2=p2->next;}if(p2==NULL){p3->data=p1->data;p3->next=head3->next;head3->next=p3;p3=head3->next;}p1=p1->next;}}void main(){element *head1,*head2,*head3,*head4;init_element(head1);init_element(head2);init_element(head3);init_element(head4);printf("请输入集合1：\n");readdata_element(head1);printf("请输入集合2：\n");readdata_element(head2);printf("请输入集合3（全集）：\n");readdata_element(head3);printf("集合1为：\n");display_element(head1);printf("集合2为：\n");display_element(head2);printf("集合3(全集)为：\n");display_element(head3);char c1;printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");scanf("%c",&c1);if(c1=='A'){printf("集合1与集合2的并集为：\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='B'){printf("集合1与集合2的交集为：\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='C'){printf("集合1与集合2的差集为：\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='D'){printf("集合1的补集为：\n");bing_element(head3,head1,head4);display_element(head4);head4->next=NULL;}if(c1=='E'){printf("集合2的补集为：\n");bing_element(head3,head2,head4);display_element(head4);head4->next=NULL;}}******************************************************************************* *******落实单位姓名性别民族年龄党龄学历职业曾任党内职务与党组织失去联系时间（失联填）失去联系情形（失联填）党组织类别联系电话备注（任填，未注明的必填）是否落实学长学姐，你们好，我是江理信息学院党建小组成员，由于学校开展党员组织梳理排查，需要填好以下信息如果对所填信息有不明白的请尽快联系我，所填信息于明天晚上7点之前发给我，麻烦了，谢谢落实单位姓名性别民族年龄党龄学历职业曾任党内职务与党组织失去联系时间（失联填）失去联系情形（失联填）党组织类别（①国有企业；②非公有制企业：③农村；④党政机关；⑤学校；⑥其他事业单位；⑦街道社区；⑧社会组织；⑨其他。
实验1 线性表的基本操作
实验一线性表的基本操作一、实验目的（1）掌握线性表顺序存储和链式存储的方法及基本运算的实现。
（2）掌握将算法在VC++6.0语言环境下实现的过程。
二、实验准备（1）复习线性表的定义，掌握顺序存储、链式存储的方法及操作。
（2）复习C语言中指针与结构体的概念、定义方式。
（3）掌握链表的C语言的实现。
（4）实验的计算机中安装了Microsoft VC++ 6.0。
三、实验内容顺序表1）首先创建一个顺序表：从键盘读入一组整数（长度小于等于20），按输入顺序放入顺序表，输入以－1结束（注意－1不放到顺序表内）；将创建好的顺序表元素依次输出到屏幕上。
2）在已创建好的顺序表中插入一个元素：从键盘读入需插入的元素值和插入位置，调用插入函数完成插入操作；然后将顺序表元素依次输出到屏幕上。
3）在已创建好的顺序表中删除一个元素：从键盘读入欲删除的元素位置（序号），调用删除函数完成删除操作；然后将顺序表元素依次输出到屏幕上。
算法提示：➢需求分析：1.功能（1）建立一顺序表（2）显示顺序表中每个元素（3）在上述的顺序表中的指定位置插入指定的元素，并输出顺序表中所有数据。
（4）在上述的顺序表中的指定位置删除指定的元素，并输出顺序表中所有数据。
2．输入要求从键盘输入顺序表中所有数据，输入以－1结束（注意－1不放到顺序表内）；需插入的数据元素的位置、值；要删除的数据元素的位置（序号）。
3. 测试数据顺序表中所有数据：15，26，58，27，9插入的数据元素的位置、值：1，28；6，28；0，28要删除的数据元素的位置：3➢概要设计：1.数据结构：提示：相关常量和顺序表数据类型定义#define MAXNUM 20#define true 1#define false 0typedef struct{int data[MAXNUM];int length;}list_type;2．模块划分：a)建立顺序表的createlist函数；b)显示输出顺序中每个结点的数据的showlist函数；c)insertlist函数：插入函数。
线性表的顺序存储实验
实验一线性表的顺序存储实验一、实验目的1、掌握用Visual C++6.0上机调试顺序表的基本方法2、掌握顺序表的基本操作，插入、删除、查找等算法的实现二、实验内容1、顺序表基本操作的实现[问题描述] 当我们要在顺序表的第i个位置上插入一个元素时，必须先将顺序表中第i个元素之后的所有元素依次后移一个位置，以便腾空一个位置，再把新元素插入到该位置。
若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置。
[基本要求] 要求生成顺序表时，可以键盘上读取元素，用顺序存储结构实现存储。
实验代码:#include<stdio.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10//-----------定义顺序表-----------typedef struct{int *base;int length;int listsize;}Sqlist;//-----------初始化顺序表-------------Sqlist InitList_Sq(){Sqlist L;L.base=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(!L.base){printf("初始化失败!");exit(0);}L.length=0;L.listsize=LIST_INIT_SIZE;return L;}//--------顺序储存----------void write(Sqlist *L,int elem){if(L->length<L->listsize){L->base[L->length++]=elem;}else{printf("存储已满!");exit(0);}}//--------------插入--------------void Insert_Sq(Sqlist *L,int position,int element){int *p,*q;if(position<1||position>L->length+1){printf("插入位置非法!");exit(0);}if(L->length>=L->listsize){int *newbase=(int*)realloc(L->base,(L->listsize+LISTINCREMENT)*sizeof(int)); if(!newbase) exit(0);L->base=newbase;L->listsize+=LISTINCREMENT;}q=&(L->base[position-1]);for(p=&(L->base[L->length-1]);p>=q;--p){*(p+1)=*p;}*q=element;L->length++;}//-----------删除指定位置元素------------void delete_Sq(Sqlist *L,int position){int i=0;if(position<1||position>L->length){printf("非法操作!");exit(0);}printf("成功删除base[%d]=%d",position,L->base[position]); for(i=position;i<L->length-1;i++){L->base[i]=L->base[i+1];}L->length--;}//------------随机访问-----------int getElem(Sqlist *L,int position){return L->base[position-1];}//----------打印数据-------------void showData(Sqlist *L){int i=0;for(i=0;i<L->length;i++){if(i%5==0)printf("\n");printf("%d ",L->base[i]);}printf("\n");}//-----------主函数-----------void main(){int i=0,a,b;Sqlist list,*l;list=InitList_Sq();l=&list;for(i=0;i<list.listsize/5;i++){write(l,i+1);}a=getElem(l,8);b=getElem(l,13);printf("base[8]=%d,base[13]=%d",a,b);showData(l);printf("length=%d,listsize=%d\n",list.length,list.listsize); Insert_Sq(l,7,3);showData(l);printf("length=%d,listsize=%d\n",list.length,list.listsize); }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一VC++软件的熟悉与使用一、实验目的1、熟悉VC++控制台程序的建立、编辑、编译、运行步骤。
2、熟悉VC++环境下调试的基本方法。
二、实验原理在VC++6.0 下建立、编译、调试并运行一个控制台程序，程序的功能描述是：有n个人（1≤n≤100）围成一圈，顺序排号（1~n）。
从第一个人开始报数（从1到5报数），凡报到5的人退出圈子，余下的人继续报数，编写程序，实现按退出圈子的先后顺序输出这个序列。
程序源代码如下：#include<stdio.h>#include<stdlib.h>void main( ){int i,k,m,n,number[100],*p;printf(“input count of person:n=”);scanf(“%d”,&n);if(n>100){printf(“error\n”);exit (0);}p=number;for(i=0;i<n;i++)*(p+i)=i+1;i=0;k=0;m=0;while(m<n-1){if(*(p+i)!=0) k++;if(k==5){printf(“%d:%d->”,m+1,*(p+i));*(p+i)=0;k=0;m++;if(m%8==0) printf(“\n”);}i++;if (i==n) i=0;}while(*p==0) p++;printf(“%d:%d”,m+1,*p);}三、实验仪器和设备1、PC微机2、Microsoft VC++6.0四、预习要求1、根据源程序，画出流程图。
2、C语言源程序的编写方法。
五、实验内容及步骤1、编写一个控制台程序在VC++6.0 下建立、编译并运行一个控制台程序，程序的功能描述是：有n个人（1≤n≤100）围成一圈，顺序排号（1~n）。
从第一个人开始报数（从1到5报数），凡到5的人退出圈子，余下的人继续报数，编写程序，实现按退出圈子的先后顺序输出这个序列。
（1）创建新工程。
选择File|New命令，显示New对话框。
在此对话框的列表栏中，选择Win32 Console Application （Win32 控制台应用程序）。
然后在Project Name 栏中输入新建的工程名，如 ex1。
在Location文本框中选择工程存放的文件夹，如图1-1中所示e：\study\ex1。
然后单击OK按钮。
图1－1 新建项目文件对话框在Win32 Console Application-Step 1 of 1对话框中选择An empty project 单选项。
然后单击Finish按钮，如图1-2所示。
图1－2 新建控制台程序对话框在出现New Project Information对话框中单击OK按钮，完成工程的创建过程。
（2）创建C++源程序文件。
编辑C++源程序：编辑C++源程序时，选择File|New命令，打开New窗口。
在New窗口。
选择Files选项卡，在它的列表框中选择C++ Source File，在File Name下面的文本框中输入源程序文件名，单击Add to project复选框，如图1-3所示，再单击OK按钮，出现编辑屏幕。
图1－3 新建源文件对话框（3）在编辑窗口键入编写好的C++源程序，如图1-4所示。
图1－4 编辑窗口（4）保存源程序。
输入完源程序后，应注意存盘。
选择File|Save（或Save all）命令，保存文件。
（5）编译连接和运行源程序。
选择Build|Complie queue.cpp命令，这时系统开始对当前的源程序进行编译，编译过程中所出现的错误信息将显示在屏幕下方的Build窗口中。
错误信息指出了该错误所在行号和该错误的性质。
用户可根据这些错误信息进行修改。
编译过程无错误后，可进行连接生成可执行文件（.exe），这时选择Build|Build ex1.exe命令。
Build窗口如果出现如图实1-4所示信息，说明编译连接成功，并生成以工程项目的名称为名字的可执行文件（ex1.exe）。
运行可执行文件的方法是，选择Build|execute.exe命令，这时，运行该文件，并将结果显示在另一个输出结果的窗口中。
（6）关闭、打开工作区。
选择File|Close WorkSpace命令，关闭工作区。
选择File|Open WorkSpace命令，在弹出的对话框中选定相应得工作区文件（扩展名为.dsw），单击Open按钮，则可重新打开工作区，对建立的工程文件进行修改。
2、VC++环境下程序的调试程序调试一般分为两个步骤：第一步是排除语法错误，使得程序能够运行;第二步是排除逻辑错误（即通常说的Debug），使得程序运行后能得到正确的运行结果。
语法错误可以利用VC++6.0提供的调试工具（Debug）来排查错误。
下面简要介绍在VC++6.0下Debug的基本用法。
（1）进行调试状态。
首先要确保程序能够编译、建立得到执行程序，也就是已经完成第一步的工作（第一步是排除语法错误），然后选择Build|Start Debug|Step Into命令或者按F11键进入单步执行状态（如图1-5所示）。
图1－5 调试窗口界面（2）设置需要观察的变量。
进入Debug状态后，在窗口的右下角有Watch窗口，在该窗口下，有若干个Watch选项卡（Watch１，Watch２等），在每一个选项卡里可以添加需要观察的变量，只要在Watch表格的Name列中输入相应得变量名。
（3）选择适当的执行方式。
在单步调试状态下，主菜单中新增了Debug，该菜单中控制执行的菜单项有以下几种。
Restart: 重新开始执行。
Stop Debugging: 退出单步调试状态，返回到正常编辑窗口。
Step Into(F11): 单步执行，遇到函数调用则进入到函数中执行。
Step Over(F10): 单步执行，遇到函数调用，执行完该函数调用返回到下一条语句。
Step Out(Shift+F11): 执行完当前的函数中所有的语句并返回到主调函数的下一条语句。
Run to Cursor (Ctrl+F10): 执行光标所在的语句。
通过单步执行的方式，可以观察程序执行过程中关键变量的变化情况，从此比较容易的确定错误的原因、改正错误。
针对上例，简单介绍单步跟踪调试的方法。
首先认为设置一个错误：将实验提示（１）中的程序的“if(i==n) i=0;”语句去掉。
编译、连接后执行会发现结果不正确，要找出其中的编辑错误，一般可以按下面的步骤进行：选择Build|Start Debug|Step Into命令，进行调试状态（即单步执行状态）。
设置需要观察的变量。
在右下角Watch窗口的Watch1选项卡的name列分别输入需要观察的变量名称如I,*(p+i),这样在程序单步执行时，可以看到两个变量的值。
当然，在单步执行的任何时候都可以在watch窗口中输入的个变量名或者表达式以观察它们的值。
按F11或F10键单步执行。
注意它们两个的区别。
如果程序中的语句是调用了标准函数，可以按F10键直接得到函数调用后返回的结果，如果是调用了自定义函数，而且怀疑自定义函数有问题，那么可以按F11键进入到子函数中单步执行。
在这里因为程序中没有自定义的函数，可以按F10键单步执行。
在程序执行到输入语句“scanf(“%d”,&n);”时应切换到控制台窗口输入n的值，这里输入“9”后按回车键，返回到VC调试环境，在watch窗口中加入变量n，可以观察到它的值是9。
继续按F10键单步执行，在单步执行第一个While循环的过程中，会出现输出了第一个正确结果，但是第二个就不正确了，这时观察变量i的值（i应该是0～n-1之间的一个值，表示数组元素的位置信息），发现i的值超过了8（这里n=9），显然变量i的值变化有问题。
在仔细分析这个While循环，i是用来计数的，当i的值超过n的，应该从起始位置重新开始，所以应该在“i++”语句后加上一条“if（i==n）i=0;”的语句。
从上面的分析可以知道，单步执行、设置观察变量的母的主要是用来确定错误的大致范围和位置，具体的排错还要通过对程序的仔细分析最终找到错误的原因，进而改正。
六、实验报告要求画出源程序流程图。
实验二顺序存储线性表的基本运算一、实验目的1、掌握线性表的定义、顺序存储的方法及基本操作。
2、掌握将算法在VC++6.0语言环境下实现的过程。
二、实验原理利用线性表的顺序存储结构完成一个班级的一个学期的所有课程成绩的管理，要求实现增加、删除学生的成绩记录等运算。
三、实验仪器和设备1、PC微机2、Microsoft VC++6.0四、预习要求1、复习线性表的定义、线性表的顺序存储结构的定义以及顺序存储线性表的增加、删除元素的算法。
2、掌握顺序存储线性表的C语言的实现。
五、实验内容及步骤1、分析题意，确定算法。
线性表的长度设为全班人数（35人），一个学期的课程设为三门，定义如下：#define Max_length 35typedef struct{int xh; /*学号*/char name[10]; /*姓名*/int c1,c2,c3; /*三门课程成绩*/} Element;2、编辑C语言源程序。
（1）分别编写插入、删除、修改、查找的算法。
/*在第i个记录的后面插入一个学生的记录算法*/int Insert_list (int i,Element s[ ],int *n_pointer){/*n_pointe存放已输入的最大记录数*/int j,n;n=*n_pointer;if((n== Max_length) | | (i<1) | | (i>n+1)) return (0);for(j=n;j>=I;j--) s[j+1]=s[j]; /*移动*/printf(“Input Data for inserting (XH Name C1 C2 C3) \n”);scanf(“%d%s%d%d%d”,&s[i].xh,&s[i].name,&s[i].c1,&s[i].c2,&s[i].c3);n++; *n_pointer=n; return (1);}/*删除第i个学生的记录算法*/int Delete_list(int i,Element s[ ] ,int *n_pointer){int j,n;n=n_pointer;if((i<1) | | (i>n)) return(0);for (j=i+1;j<=n;j++){/*移动*/s[j-1].xh=s[j].xh; strcpy(s[j-1].name,s[j].name;s[j-1].c1=s[j].c1; s[j-1].c2=s[j].c2; s[j-1].c3=s[j].c3;}n--;*n_pointer=n; return (1);}/*查找学好为x的算法*/int Locate_list (Element s[ ], int n, int x){int i;for(i=1;i<=n;i++) if (s[i].xh==x) return (i);return (0);}/*修改学号为i的学生的记录函数*/int Change_list (int i, Element s[ ] ){if( (i<1) | | (i>Max_length +1) ) return (0);printf (“Input data for updating :\n”);scanf (“%d%s%d%d%d”,s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3);return (1);}/*打印已建立的数据记录，n是记录总数*/void printf_list (Element s[ ],int n){int i;if(n>Max_length) return ;printf (“XH Name C1 C2 C3 \n”);printf(“--------------------------------------------\n”);for(i=1;i<=n;i++)printf (“%4d%10s%7d%7d%7d\n”,s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3) }（2）编写主函数调用上述各函数。