实验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),记录输出结果。
- 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);}运行结果:。