实验1：线性表的顺序存储
验证性实验一 线性表的顺序存储实验
验证性实验一线性表的顺序存储实验实验课程名：数据结构专业班级：学号：姓名：实验时间：实验地点：指导教师：一、实验目的和要求1、掌握用Visual C++6.0上机调试顺序表的基本方法2、掌握顺序表的基本操作，插入、删除、查找、以及有序顺序表的合并等算法的实现二、实验内容1、顺序表基本操作的实现。
要求生成顺序表时，可以键盘上读取元素，用顺序存储结构实现存储。
#include<stdio.h>#include<string.h>#include<conio.h>#include<iostream.h>#include<malloc.h>#define LIST_INIT_SIZE 10#define OK 1#define ERROR 0#define LISTINCREMENT 10typedef int ElemType;typedef struct{ int *elem;int length;int listsize;}SqList;int InitList_Sq(SqList &L) //InitList_Sq() function{ //Inititial a Sq_ListL.elem=(ElemType *)malloc(LIST_INIT_SIZE *sizeof(ElemType));if (!L.elem) return(0);L.length=0;L.listsize=LIST_INIT_SIZE;return(1);}//end of InitList_Sq() functionint ListInsert_sq(SqList &L,int i,int e)//ListInsert_sq(){ if(i<1||i>L.length+1) //i (location) is illegal{ cout <<"Initial failure!"<<endl;getch();return (ERROR);}if(L.length>=L.listsize) //insert into the end of the Sqlist{ int *Newbase;Newbase=(int *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!Newbase){ cout<<"Overflow!"<<endl;getch();return (ERROR);}L.elem=Newbase;L.listsize+=LISTINCREMENT;}int *p,*q;q=&(L.elem[i-1]); //q point at the element before the inserted onefor(p=&(L.elem[L.length-1]);p>=q;--p) //move the element*(p+1)=*p;*q=e;++L.length;return (OK);} //ListInser_sq() endvoid main(){ int m,i,x;SqList A;InitList_Sq(A);cout<<"Input the size of A:\n"<<endl;cin>>m;cout<<"Input the element of A:\n";for(i=1;i<=m;i++){cin>>x;ListInsert_sq(A,i,x);}cout<<"The element of A:"<<endl;for(i=0;i<A.length;i++)cout<<A.elem[i]<<'\t';cout<<endl;}实验结果：（本人运行程序得到实验截图）实验结果分析：本程序中首先定义了一个链表的结构体，然后定义了一个线性表，在插入函数中先申请了一个与头文件中定义的线性表大小相同的内存空间，然后用if语句判断这个线性表是否存在，若不存在则返回0，若存在则将线性表的长度设置为与申请的空间大小相同。
实验一 线性表的顺序存储及其操作
实验一线性表的顺序存储及其操作一、实验目的与基本要求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）中随便起个名字，下面选一个保存地址。
数据结构实验线性表的顺序存储结构
南昌航空大学实验报告课程名称：数据结构实验名称：实验一线性表的链式存储结构班级：080611 学生姓名：冯武明学号：16 指导教师评定：XXX 签名: XXX题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。
一、需求分析⒈先构造两个多项式链表，实现两个多项式的和及删除值为零元素的操作，不同用户输入的多项式不同。
⒉在演示过程序中，用户需敲击键盘输入值，即可观看结果。
⒊程序执行的命令包括：（1）构造多项式链表A （2）构造多项式链表B （3）求两张链表的和（4）删除值为零元素，即不创建链表。
二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：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≥0}基本操作:init(linklist *L)操作结果：destroylist(List *L)clearlist(List *L)初始条件：线性表L已经存在，1≤i≤ListLength(&L)操作结果：用e返回L中第i个数据元素的值。
insfirst(link h,link s)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
delfirst(link h,link *q)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
append(linklist *L,link s)初始条件：线性表La已经存在操作结果：判断La中是否有与e相同的元素。
remove(linklist *L,link *q)初始条件：非递减线性表La，Lb已经存在操作结果：合并La，Lb得到Lc，Lc仍按非递减有序排列。
实验一 线性表的顺序存储结构
实验一线性表的顺序存储结构一．实验的目的要求：1．掌握顺序存储结构的特点。
2．掌握顺序存储结构的常见算法。
二．实验内容1．建立一个接口，定义一些常用的基本方法；2．用类实现该接口的基本方法：◆依次插入数据元素，建立顺序表；◆按指定位置查找在该顺序表中查找某一元素；◆按指定位置删除该顺序表中的某一元素；◆实现该顺序表的遍历；3．定义客户类来调用接口中的方法；三．程序分析顺序表：顺序存储结构，可以实现随机的存取，核心的方法有插入删除和查找。
优点在于：数据之间，逻辑相邻，物理相邻，可随机存取任一元素，存储空间使用很紧凑。
缺点：在插入删除操作时，需要移动大量元素，而且预先分配最大的存储空间，造成内存空间的利用不充分。
四．源程序1. 线性表接口public interface ListInterface<T> {/*** 任务：往线性表的末尾插入新元素* 输入：newEntry作为新元素插入的对象* 返回：如果插入成功则返回true,否则返回false*/public boolean add(T newEntry);/*** 任务：将newEntry插入到线性表中位置newPosition* 输入：newPosition是一个整数,newPosition>=1并且* newPosition<=getLength()+1,newEntry作为新元素插入的对象* 返回：如果插入成功则返回true,否则返回false*/public boolean add(int newPosition, T newEntry);/*** 任务：从线性表中删除指定位置的元素。
* 原本位于比指定位置更高位置的元素移动到线性表中下一个更低的位置。
* 线性表的大小减1。
* 输入：givenPosition>=1并且givenPosition<=getLength()* 返回：如果删除成功，则返回givenPosition位置的元素，否则返回null */public T remove(int givenPosition);/*** 任务：删除表中所有元素*/public void clear();/*** 任务：替换表中指定位置的元素* 输入: givenPosition指定替换元素位置的一个整数；* givenPosition>=1并且givenPosition<=getLength();* givenPosition非法，则返回false ;* newEntry 用以替换givenPosition位置的元素的对象*/public boolean replace(int givenPosition, T newEntry);/*** 任务：检索线性表中指定位置的元素* 输入：givenPosition指定被检索元素位置的一个整数；* givenPosition>=1 并且givenPosition<=getLength()* 返回：如果找到指定的线性表元素，返回对它的引用，否则返回null */public T getEntry(int givenPosition);/*** 任务：确定线性表是否含有一个给定的元素* 输入：anEntry表示待查元素的对象* 返回：如果线性表含有anEntry，返回true，否则返回false*/public boolean contains(T anEntry);/*** 任务：获得线性表的长度* 返回：返回线性表中当前所含元素个数的整数*/public int getLength();/*** 任务：确定线性表是否为空* 返回：如果线性表为空，返回true,否则返回false */public boolean isEmpty();/*** 任务：确定线性表是否为满* 返回：如果线性表为满，返回true,否则返回false*/public boolean isFull();/*** 任务：按照元素在线性表中的顺序显示线性表中的所有元素*/public void display();/*** 任务：完成指定位置之间元素的逆置* 输入：head和tail分别指示起始位置和结束位置*/public void invert(int head, int tail);/*** 任务：将表中前m个元素和后n元素，位置进行互换* 输入：m和n分别指示互换的前后互换元素的长度*/public void exchage(int m, int n);/*** 任务：删除表中相同元素*/public void purge();/*** 任务：将两个线性表进行合并，相同元素不并入* 输入：willBeUnion表示合并的线性表* 输出：合并成功返回true,否则返回false*/public boolean union(ListInterface<T> willBeUnion);}2.public class AList<T> implements ListInterface<T> {/****/private T[] entry;private int length; // 线性表中元素的当前个数private static final int MAX_SIZE = 50;public AList() {// TODO Auto-generated constructor stubthis(MAX_SIZE);}public AList(int maxsize) {// TODO Auto-generated constructor stublength = 0;entry = (T[]) new Object[maxsize];}/*** @param newEntry*/public boolean add(T newEntry) {boolean isSuccessful = true;if (!isFull()) {entry[length + 1] = newEntry;length++;} elseisSuccessful = false;return isSuccessful;}public boolean add(int newPosition, T newEntry) {// TODO Auto-generated method stubboolean result = false;if (!isFull()) {// 从newPosition开始到length-1之间的元素后移一位for (int i = length; i >= newPosition; i--)entry[i + 1] = entry[i];entry[newPosition] = newEntry;length++;result = true;}return result;}public void clear() {// TODO Auto-generated method stublength = 0;}public boolean contains(T anEntry) {// TODO Auto-generated method stubboolean result = false;int i = 1;for (; (i <= length) && !anEntry.equals(entry[i]); i++) ;if (i <= length)result = true;return result;}public void display() {for (int i = 1; i <= length; i++) {System.out.println(entry[i]);}}public T getEntry(int givenPosition) {// TODO Auto-generated method stubT gotEntry = null;if (givenPosition >= 1 && givenPosition <= length) { gotEntry = entry[givenPosition];}return gotEntry;}public int getLength() {return length;}public boolean isEmpty() {// TODO Auto-generated method stubboolean result = false;if (length == 0)result = true;return result;}public boolean isFull() {// TODO Auto-generated method stubboolean returnV al = false;if (length >= MAX_SIZE)returnV al = true;return returnV al;}public T remove(int givenPosition) {T removedEntry = null;if ((givenPosition >= 1) || (givenPosition <= length)) {// 删除位置合法removedEntry = entry[givenPosition]; // 被删除元素的值赋给efor (int i = givenPosition + 1; i <= length; i++) {entry[i - 1] = entry[i];}length--;}return removedEntry;}public boolean replace(int givenPosition, T newEntry) {boolean result = false;if ((givenPosition >= 1) || (givenPosition <= length)) {// 替换的位置合法entry[givenPosition] = newEntry;result = true;}return result;}public void exchage(int m, int n) {if (m >= 1 && n >= 1 && m + n <= length) {invert(1, length);// System.out.println("第一次互换：");// display();invert(1, n);//System.out.println("第二次互换：");//display();invert(n + 1, length - m);//System.out.println("第三次互换：");//display();this.invert(length + 1 - m, length);//System.out.println("第四次互换：");// list.display();}}public void exchage2(int m, int n) {int listLen = getLength();if (m >= 1 && n >= 1 && m + n <= listLen) {int firsEntryLoc = 1;for (int i = listLen - n + 1; i <= listLen; i++) {T temp = remove(i);add(firsEntryLoc, temp);firsEntryLoc++;}for (int j = m + n + 1; j <= listLen; j++) {T temp = remove(j);add(firsEntryLoc, temp);firsEntryLoc++;}}}@Overridepublic void invert(int head, int tail) {if (!isEmpty() && (head >= 1 && head < tail && tail <= length)) { while (head < tail) {T temp = getEntry(head);replace(head, getEntry(tail));replace(tail, temp);head++;tail--;}}}@Overridepublic void purge() {for (int i = 1; i <= getLength(); i++) {for (int j = i + 1; j <= getLength();) {if (getEntry(i).equals(getEntry(j))) {remove(j);} else {j++;}}}}// 删除顺序表L中的冗余元素，即使操作之后的顺序表中只保留// 操作之前表中所有值都不相同的元素public void purge2() {int k = 0; // k 指示新表的表尾for (int i = 1; i <= length; ++i) { // 顺序考察表中每个元素int j = 1;while (j <= k && (!getEntry(j).equals(getEntry(i)))) {// 在新表中查询是否存在和第i位置相同的元素++j;}if (k == 0 || j > k) {// k=0表明当前考察的是第一个元素k++;replace(k, getEntry(i));}} // forlength = k;// 修改表长}@Overridepublic boolean union(ListInterface<T> willBeUnion) {int lb_len = willBeUnion.getLength(); // 求线性表的长度for (int i = 1; i <= lb_len; i++) {T e = willBeUnion.getEntry(i); // 取Lb中第i个数据元素赋给eif (!contains(e))add(e);}return true;}}3测试类import java.util.Scanner;public class TestAList {private ListInterface<String> alist;TestAList() {alist = new AList<String>();}public ListInterface<String> getAList() {return alist;}public void setAList(ListInterface<String> alist) {this.alist = alist;}public void testGetLength(){System.out.println("初始化后，线性表的长度为："+alist.getLength()); }public void testInvert(){alist.add("B");alist.add("C");alist.add("D");alist.add("E");alist.add("F");alist.add("G");System.out.println("逆置之前：");alist.display();alist.invert(2, 6);System.out.println("逆置之后：");alist.display();}public void testExchage(){alist.add("A");alist.add("B");alist.add("C");alist.add("D");alist.add("E");alist.add("F");alist.add("G");System.out.println("互换之前：");alist.display();alist.exchage(2, 3);System.out.println("互换之后：");alist.display();}public void testExchage2(){AList<String> alist2=new AList<String>();alist2.add("1");alist2.add("2");alist2.add("3");alist2.add("4");alist2.add("5");alist2.add("6");System.out.println("互换之前：");alist2.display();alist2.exchage2(2, 3);System.out.println("互换之后：");alist2.display();}public void testPurge(){alist.add("A");alist.add("B");alist.add("B");alist.add("C");alist.add("B");alist.add("A");alist.add("D");System.out.println("删除重复元素之前：");alist.display();alist.purge();System.out.println("删除重复元素之后：");alist.display();}public void testPurge2(){AList<String> alist3=new AList<String>(15);alist3.add("1");alist3.add("2");alist3.add("2");alist3.add("2");alist3.add("1");//alist3.add("2");//alist3.add("1");System.out.println("删除重复元素之前：");alist3.display();alist3.purge2();System.out.println("删除重复元素之后：");alist3.display();}public void testUnion(){alist.add("A");alist.add("C");alist.add("D");AList<String> willBeUnioned=new AList<String>();willBeUnioned.add("D");willBeUnioned.add("E");willBeUnioned.add("A");willBeUnioned.add("F");System.out.println("合并前：");alist.display();alist.union(willBeUnioned);System.out.println("合并后：");alist.display();}/*** @param args*/public static void main(String[] args) {TestAList testAList=new TestAList();//测试获取线性表的长度//testAList.testGetLength();//测试线性表逆置//testAList.testInvert();//测试互换实现一//testAList.testExchage();//测试互换实现二//testAList.testExchage2();//测试删除重复元素实现一testAList.testPurge();//测试删除重复元素实现二//testAList.testPurge2();//测试线性表合并//testAList.testUnion();//Scanner keyboard=new Scanner(System.in);//String message=keyboard.next( );//AList<String> alist2=new AList<String>();//alist2.add(message);//message=keyboard.next( );//alist2.add(message);//alist2.display();}}五．实验总结线性表是一种ADT，其数据由有序的数据元素构成，每个数据元素都由其在线性表中的位置识别。
数据结构实验报告-实验：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线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一，它是一种有序的数据元素集合，其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式，其中顺序存储结构是最简单的一种，它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素，但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现，数组的长度应该大于等于线性表的长度，以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时，需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作：________在指定位置插入一个元素时，需要将插入位置之后的元素依次后移，给待插入的元素腾出位置。
●删除操作：________删除指定位置的元素时，需要将删除位置之后的元素依次前移，覆盖删除位置上的元素。
●修改操作：________修改指定位置的元素时，直接对该位置上的元素进行修改即可。
●查找操作：________根据指定的元素值，查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素，可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点：________可以快速地访问任意位置的元素，节省存储空间。
2.缺点：________插入和删除操作需要移动大量的元素，不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中，我们以顺序存储结构为基础，实现了线性表的增删改查操作，并进行了遍历操作。
通过实验，我们发现顺序存储结构在查询操作上有较好的性能，但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
《线性表的顺序存储》实验报告
《线性表的顺序存储》实验报告1.需解决的的问题利用顺序表，设计一组输入数据。
2.数据结构的定义typedefstruct{ElemType *elem;int length;intlistsize;}SqList;3.程序的结构图4.函数的功能1）初始化一个空顺序表voidInitSqList(SqList *L){L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) exit(OVERFLOW);L->length=0;L->listsize=LIST_INIT_SIZE;}2）输入元素voidPushSqList(SqList *L){inti;printf("input the length of the list:");scanf("%d",&L->length);printf("input the sqlist:");for(i=0;i<L->length;i++){printf("input the %dth number:",i+1);scanf("%d",&L->elem);}}3）在指定位置插入一个指定的元素voidInsertSqList(SqList *L,inti,ElemType x){ElemType *newbase;intn,m;if(i<1||i>L->length+1){printf("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+=LISTINCREMENT;}else{for(n=L->length;n>=i;n--){++L->length;L->elem[n]=L->elem[n-1];}L->elem[i-1]=x;printf("the list is:");for(m=0;m<L->length+1;n++)printf("%d",L->elem[n]);}}4）删除指定位置的元素voidDelSqList(SqList *L,inti){ElemType *p,*q;ElemType x;int n;if(i<1||i>L->length)printf("ERROR!");p=&(L->elem[i-1]);x=*p;for(q=p;q<&(L->elem[L->length-1]);q++)*q=*(q+1);L->length--;printf("the element which is delete is %d",x);printf("the list is:");for(n=0;n<L->length-1;n++)printf("%d",L->elem[n]);}5）将顺序表中所有的元素颠倒voidChangeoverSqList(SqList *L){SqList S;inti,j;if(L->length==L->listsize)S.elem=(ElemType*)malloc(L->length*sizeof(ElemType));if(!S.elem) exit(OVERFLOW);else{for(i=0;i<L->length;i++)S.elem[i]=L->elem[L->length-i-1];for(i=0;i<L->length;i++)L->elem[i]=S.elem[i];}printf("the list is:");for(j=0;j<L->length;i++)printf("%d",L->elem[i]);}6）按顺序输出表中元素voidPrintSqList(SqList *L){inti;for(i=0;i<L->length;i++)printf("%d ",L->elem[i]);}7）摧毁顺序表voidDestroySqList(SqList *L){if(L->elem) free(L->elem);}8）清空顺序表voidClearSqList(SqList *L){L->length=0;}9）查找指定位置的元素，并返回该元素的值intGetElem(SqList *L,inti){ElemType x;if(i<1||i>L->length+1) {printf("ERROR!");}else{x=L->elem[i-1];printf("the elem is %d",x);}}5.输入/输出数据1）创建一个顺序表，先输入表长度，然后输入数据2）选择菜单，进行不同操作选‘1’，在指定位置插入指定元素选‘2’，删除指定位置的元素选‘3’，颠倒顺序表中元素的顺序选‘4’，按顺序输出表中的元素选‘5’，摧毁顺序表选‘6’，清空线性表选‘7’，输出当前顺序表的长度选‘8’，输出指定位置的元素选‘9’，退出该程序6.总结这个实验让我更好的掌握了在线性表的顺序存储中如何初始化，如何进行输入输出的处理，以及各种常用功能是怎样实现的。
线性表实验
实验一线性表的顺序存储一、实验说明实验项目名称：线性表的顺序存储实验类型：基础实验课时：2实验所用主要仪器：微型计算机1台，安装中文版Windows 2000/XP 操作系统、VC++6.0集成编程环境。
二、实验目的：1. 掌握线性表的顺序存储结构。
2. 利用顺序存储结构实现线性表的基本操作。
3. 了解线性表的应用。
三、实验内容1. 运行顺序表的演示程序，掌握顺序表的存储结构的实现，进一步了解顺序表的初始化、查找、插入、删除、销毁等算法的编程实现。
（请运行源程序，写出创建线性表以及线性表的插入、删除、查找等一组测试结果）2. 按课本P43题2.6的要求，在演示程序中增加顺序表逆置功能。
本题要求：(1) 写出顺序表逆置算法加入到程序中并上机验证通过。
(2) 设计一组测试数据，并测试程序各个功能，记录输出结果。
（请查看源码中的reverse（L）函数）3. 约瑟夫圈问题：假设有n个人按1、2、3、…、n的顺序围成一圈。
现在，从第s个人开始按1、2、3、…、m的顺序报数，数到m的人出圈，接着从出圈的下一个人开始重复此过程，直到所有人出圈为止。
求出所有人的出圈顺序。
本题解法1：用顺序表为数据结构来解决这个问题。
算法如下：可以将n个人的编号存入一个一维数组中，表的长度就是人数n，因此，就可以用一维数组来代替顺序表。
算法的思想是：先求出出圈人的编号，用一个临时单元保存它，然后从出圈人的后一个开始，直到最后一个，都按顺序向前移动一个位置，再将临时单元的出圈人编号存入最后。
当这个重复步骤完成后，数组中存放的是出圈人的逆序列。
本题中，围圈的人数n、出圈的报数号m、开始报数的位置s，在程序中预先给定为10、3、2。
当然，用户也可以从键盘临时输入。
本题提供源程序。
（请查看源码中的joes(int n,int s,int m)、joes1(SqList &a,int n,int s,int m)、joes2(SqList a,int n,int s,int m)函数，对比两种方法解决约瑟夫问题的优劣性）本题要求：要求在main函数中修改joes、Joes1函数，设计出至少三组不同的测试数据(对应三个变量人数n、报数号m、开始位置s)，记录输出结果。
线性表的顺序存储结构实验报告
南昌航空大学实验报告课程名称：数据结构实验名称：实验一线性表的顺序存储结构班级：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中值相同的元素。
实验一：线性表的存储结构定义及基本操作
操作结果：返回 L 中数据元素值为 e 的元素位置； . “判表空算法”初始条件：顺序线性表 L 已存在；
操作结果：若 L 为空表，则返回 TRUE，否则返回 FALSE； 分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
(二）基本实验内容（链表）：
建立单链表，完成链表（带表头结点）的基本操作：建立链表、插入、删除、查找、输 出、求前驱、求后继、两个有序链表的合并操作。
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、 搜索结点。 1． 问题描述：
利用线性表的链式存储结构,设计一组输入数据（假定为一组整数），能够对单链表进行 如下操作： . 初始化一个带表头结点的空链表； . 创建一个单链表是从无到有地建立起一个链表，即一个一个地输入各结点数据，并建立 起前后相互链接的关系。又分为逆位序(插在表头)输入 n 个元素的值和正位序(插在表尾)输 入 n 个元素的值； . 插入结点可以根据给定位置进行插入（位置插入），也可以根据结点的值插入到已知的链 表中（值插入），且保持结点的数据按原来的递增次序排列，形成有序链表。 . 删除结点可以根据给定位置进行删除（位置删除），也可以把链表中查找结点的值为搜索 对象的结点全部删除（值删除）； . 输出单链表的内容是将链表中各结点的数据依次显示，直到链表尾结点； . 编写主程序，实现对各不同的算法调用。 其它的操作算法描述略。 2．实现要求：
操作结果：依次对 L 的每个数据元素进行交换，为了使用最少的额外 空间，对顺序表的元素进行交换； . “输出算法”的初始条件：顺序线性表 L 已存在；
操作结果：依次对 L 的每个数据元素进行输出； . “销毁算法”初始条件：顺序线性表 L 已存在；
操作结果：销毁顺序线性表 L； . “置空表算法”初始条件：顺序线性表 L 已存在；
[数据结构]实验一 线性表的顺序存储结构和链式存储结构
![[数据结构]实验一 线性表的顺序存储结构和链式存储结构](https://img.taocdn.com/s3/m/81694a01a6c30c2259019e72.png)
中山大学新华学院实验报告课程名称：数据结构实验名称：实验一线性表的顺序存储结构和链式存储结构班级：09级计算机学生姓名：郑永坤学号：09052029指导教师评定：签名:题目：利用线性表的顺序存储结构和链式存储结构分别存储数据并把数据输出。
一、需求分析⒈本演示程序分别用顺序存储结构和链式存储结构存储数据并把数据输出。
⒉在演示过程序中，用户敲击键盘，输入数据存储，即可看到数据的输出。
⒊程序执行的命令包括：（1）定义结构体（2）建立空表（3）构造输入数据的函数（4）构造输出数据的函数二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：顺序存储结构的抽象数据类型：ADT SqList {数据对象：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≥0}基本操作:InitList_Sq(SqList *L)操作结果：构造一个空的线性表L。
inputlist(SqList *L)初始条件：线性表L已经存在操作结果：存储输入的数据元素。
outputlist(SqList *L)初始条件：线性表L已经存在操作结果：输出表L。
}ADT SqList链式存储结构的抽象数据类型：ADT linklist {数据对象：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≥0}基本操作:linklist *creatL(linklist *L)初始条件：线性表L已经存在操作结果：存储输入的数据元素。
output(linklist *L)初始条件：线性表L已经存在操作结果：输出表L。
}ADT linklist2. 本程序有三个模块：⑴主程序模块void main(){初始化；{接受命令；显示结果；｝｝⑵线性表单元模块：实现线性表抽象数据类型；⑶结点结构单元模块：定义线性表中的结点结构。
数据结构实验报告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线性表顺序存储
姓名：学号：班级：指导教师：实验一线性表的建立及相关操作[实验目的]1、掌握VC上机调试的基本方法。
2、了解顺序表的结构特点及相关概念，掌握顺序表中的插入和删除的实现。
[实验要求]1、建立一个有20个结点的顺序表并掌握如何定义结点的结构。
2、输出原线性表的各元素值，以及插入和删除一个元素后的线性表的元素值。
[操作步骤][程序]#include <stdio.h>//下标为0的数组元素没有使用typedef struct//线性表结构{int elem[20];int len;}SqList;void prt(SqList L)//输出函数for(int i=1;i<=L.len;i++)printf(“%d %d\n”,I,L.elem[i]);}int Insert_Sq(SqList &L,int i,int x)//插入函数{int j;if(i<1||i>L.len+1) return 0;if(L.len==20) return -1;for(j=L.len;j>=i;--j)L.elem[j+1]=L.elem[j];L.elem[i]=x;++L.len;return 1;}int Delete_Sq(SqList &L,int i)//删除函数{int j;if(i<1||i>L.len) return 0;if(L.len==0) return -1;for(j=i;j<=L.len-1;j++)L.elem[j]=L.elem[j+1];--L.len;return 1;}void initsql(SqList &L)//线性表的初始化L.len=0;}void main(){SqList L;int i,x;initsql(L);for(i=1;i<=10;i++){scanf(“%d”,&x);Insert_Sq(L,i,x);}prt(L);Insert_Sq(L,5,90);//将90插入到第5个元素的位置prt(L);Delete_Sq(L,1);//删除第1个元素prt(L);}。
数据结构实验一线性表的顺序存储结构
实验一：线性表的顺序存储结构实验学时：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); /*显示学生记录内容*/}上机调试、运行源程序。
数据结构实验一 线性表的顺序存储及其操作 - 副本
实验一线性表的顺序存储及其操作一、【实验目的】掌握线性表在顺序存储下的插入与删除等基本运算二、【指导思想】用数组和线性表长存储线性表，实现线性表的基本操作。
三、【实验内容】实现顺序表的建立、输入、输出、查找、插入、删除等功能，每个功能用一个函数实现。
（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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验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。
bool FindList(List &L,ElemType& item){for(int i=0;i<L.size;i++)if(L.list[i]==item){item=L.list[i];return true;}return false;}bool UpdateList(List &L, const ElemType& item){for(int i=0; i<L.size;i++)if(L.list[i]==item){L.list[i]=item;return true;}return false;}bool InsertList(List &L,ElemType item,int pos)//在La中插入一个新的元素{if(pos<-1 || pos>L.size+1){cout<<"pos值无效!"<<endl; return false;}int i;if(pos==0) {for(i=0; i<L.size; i++)if(item<L.list[i]) break;pos=i+1;}else if(pos==-1) pos=L.size+1;if(L.size==L.MaxSize){int k=sizeof(ElemType);L.list=(ElemType*)realloc(L.list,2*L.MaxSize*k);if(L.list==NULL){cout<<".......!"<<endl;exit(1);}L.MaxSize=2*L.MaxSize;}for(i=L.size-1;i>=pos-1;i--)L.list[i+1]=L.list[i];L.list[pos-1]=item;L.size++;return true;}bool DeleteList(List &L, ElemType& item, int pos)//删除La中的某一元素{if(L.size==0) {cout<<"线性表为空，删除无效!"<<endl;return false;}if(pos<-1 || pos>L.size) {cout<<"pos值无效!"<<endl;return false;}int i;if(pos==0){for(i=0;i<L.size;i++)if(item==L.list[i]) break;if(i==L.size) return false;pos=i+1;}else if(pos==-1) pos=L.size;item=L.list[pos-1];for(i=pos;i<L.size;i++)L.list[i-1]=L.list[i];L.list--;if(float(L.size)/L.MaxSize<0.4&& L.MaxSize>10){ int k=sizeof(ElemType);L.list=(ElemType*)realloc(L.list,L.MaxSize*k/2);L.MaxSize=L.MaxSize/2;}return true;}void SortList(List &L){int i,j;ElemType x;for(i=1;i<L.size;i++){x=L.list[i];for(j=i-1;j>=0;j--)if(x<L.list[j])L.list[j+1]=L.list[j];else break;L.list[j+1]=x;}}void main(){int a[12]={3,6,9,12,15,18,21,24,27,30,33,36};int i; ElemType x;List t;InitList(t);for(i=0;i<12;i++) InsertList(t,a[i],i+1);InsertList(t,48,13);InsertList(t,40,0);cout<<GetList(t,4)<<' '<<GetList(t,9)<<endl;TraverseList(t);cout<<"输入待查找的元素值:";cin>>x;if(FindList(t,x)) cout<<"查找成功!"<<endl;else cout<<"查找失败!"<<endl;cout<<"输入待删除元素的值:";cin>>x;if(DeleteList(t,x,0)) cout<<"删除成功!"<<endl;else cout<<"删除失败!"<<endl;for(i=0;i<6;i++)DeleteList(t,x,i+1);TraverseList(t);cout<<"按值插入，输入待插入元素的值:";cin>>x;if(InsertList(t,x,0)) cout<<"插入成功!"<<endl;else cout<<"插入失败!"<<endl;TraverseList(t);cout<<"线性表长度:"<<LenthList(t)<<endl;if(EmptyList(t)) cout<<"线性表为空!"<<endl;else cout<<"线性表不空!"<<endl;ClearList(t);}运行结果：。