DS:线性表的顺序存储结构实现学生记录表
线性表的顺序存储
一元多项式相乘问题解决方案设计
01
实现多项式类的构造函数,初始化节点数组和长度。
02
实现多项式类的乘法运算符重载,实现两个多项式的
相乘。
03
在主函数中创建两个多项式对象,调用乘法运算符实
现相乘,并输出结果。
06
总结回顾与拓展延伸
关键知识点总结回顾
线性表的定义与基本 操作
线性表是一种具有n个数据元素的 有限序列,其基本操作包括插入、 删除、查找等。
顺序存储结构的特点
线性表的顺序存储结构是用一段 地址连续的存储单元依次存储线 性表的数据元素,其优点是可以 随机存取,即通过下标可以直接 访问到对应元素,缺点是插入和 删除操作需要移动大量元素。
在指定位置插入一个元素,需要将插 入位置及其后的所有元素后移一位, 然后在空出的位置上插入新元素。
删除操作
删除指定位置的元素,需要将删 除位置及其后的所有元素前移一 位,然后释放空出的存储空间。
查找操作
通过下标或元素值查找指定元素, 可以直接通过下标访问或遍历整 个线性表进行查找。
初始化
为线性表分配一块连续的存储空 间,并设置其初始状态(如长度、 容量等)。
顺序存储结构内存分配方式
静态分配
在程序编译时确定线性表的最大长度,并为其分配一块固定大小的内存空间。这种方式适用于长度固定的线性 表,但可能造成内存浪费。
动态分配
在程序运行时根据需要动态地分配和释放内存空间。这种方式适用于长度可变的线性表,可以充分利用内存资 源。
顺序存储结构下基本操作实现
插入操作
线性表的顺序存储
目录
实验一 线性表的顺序存储结构
实验一线性表的顺序存储结构一.实验的目的要求: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线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一,它是一种有序的数据元素集合,其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式,其中顺序存储结构是最简单的一种,它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素,但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现,数组的长度应该大于等于线性表的长度,以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时,需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作:________在指定位置插入一个元素时,需要将插入位置之后的元素依次后移,给待插入的元素腾出位置。
●删除操作:________删除指定位置的元素时,需要将删除位置之后的元素依次前移,覆盖删除位置上的元素。
●修改操作:________修改指定位置的元素时,直接对该位置上的元素进行修改即可。
●查找操作:________根据指定的元素值,查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素,可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点:________可以快速地访问任意位置的元素,节省存储空间。
2.缺点:________插入和删除操作需要移动大量的元素,不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中,我们以顺序存储结构为基础,实现了线性表的增删改查操作,并进行了遍历操作。
通过实验,我们发现顺序存储结构在查询操作上有较好的性能,但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
线性表的顺序存储结构
相邻两个数据元素的存 储地址之间的关系: LOC(ai+1)=LOC(ai)+k
第i个数据元素ai的存储地址: LOC(ai)=LOC(a1)+(i-1)×k
线性表的顺序存储结构是一种随机存取的存储结构。
若已知线性表的起始位置(基地址)和表中每个数据元素所占 存储单元的大小k,就可以计算出线性表中任意一个数据元素 的存储地址,这种存取元素的方法称为随机存取法
对表中数据元素进行操作应使用L.elem[i] 方法二:SeqList *L,表示将L定义为指向SeqList类型的指针。
对表中数据元素进行操作应使用L->elem[i]
二、顺序表的基本操作
1.初始化顺序表 2.插入数据元素 3.删除数据元素 4.查找数据元素
1.初始化顺序表
初始化顺序表操作是指构造一个空的顺序表,并为其分配存储空间。 其算法描述如下:
while (item >= L.elem[i]) //寻找item的插入位置i
i ++;
ListInsert (&L, i, item); } //将item插入到位置i
L.length ++; }
//表长增1
数据结构
//表长增1
return TRUE; }
假设在顺序表中第i个位置插入一个元素的概率为pi,则在长度为n的 线性表中插入一个数据元素时,需要移动其他元素的平均次数为:
该算法的时间复杂度为O(n)。
3.删除数据元素
删除顺序表中第i(1≤i≤n)个 数据元素,需将第i+1个至第n 个元素(共n-i个)依次向前 移动一个位置。顺序表进行删 除操作的前后,其数据元素在 存储空间中的位置变化如图2-3 所示。
数据结构实验报告-线性表的顺序存储
姓 名
专业班级
实验地点
指导教师
实验时间
一、实验目的及要求
本次实验目的是通过上机练习,熟悉和掌握课堂所讲授的基本知识点。要求上机以前要认真复习课堂教学内容。完成教师带领实验,完成线性表的顺序存储实验。
二、实验设备(环境)及要求
计算机;学生不许把食物带到机房吃;不许上网做与实验无关的内容;不许同学之间聊天;保持实验室安静卫生。下课把键盘,座椅放回原处。
Integer length;/*当前线性表长度,线性表中现有元素个数*/
Integer listsize;/*当前分配的存储量以下定义线性表的操作*/
Integer InitList(Class_List *SqList)
/*构造一个空的线性表*/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int Integer;
typedef char *String;
typedef struct
{
Integer number;
String name[10];
Integer age;
String interest[50];
完成一个有多于3个学生的线性表。并且显示学生信息。删除其中一个学生。然后再打印显示。
Source.cpp
#include"header.h"
void main()
{
Class_List xinji2013;
InitList(&xinji2013);
Student st;
Integer i,n=2,w,q,e;
三、实验内容与步骤
线性表的顺序存储及运算实现
2.2 线性表的顺序存储及运算实现2.2.1 顺序表线性表的顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表的各元素,用这种存储形式存储的线性表称其为顺序表。
因为内存中的地址空间是线性的,因此,用物理上的相邻实现数据元素之间的逻辑相邻关系是既简单,又自然的。
如图 2.1 所示。
设 a1的存储地址为Loc(a1),每个数据元素占d个存储地址,则第i个数据元素的地址为:Loc(ai)=Loc(a1)+(i-1)*d 1<=i<=n这就是说只要知道顺序表首地址和每个数据元素所占地址单元的个数就可求出第i个数据元素的地址来,这也是顺序表具有按数据元素的序号随机存取的特点。
在程序设计语言中,一维数组在内存中占用的存储空间就是一组连续的存储区域,因此,用一维数组来表示顺序表的数据存储区域是再合适不过的。
考虑到线性表的运算有插入、删除等运算,即表长是可变的,因此,数组的容量需设计的足够大,设用:data[MAXSIZE]来表示,其中MAXSIZE是一个根据实际问题定义的足够大的整数,线性表中的数据从 data[0] 开始依次顺序存放,但当前线性表中的实际元素个数可能未达到MAXSIZE多个,因此需用一个变量 last 记录当前线性表中最后一个元素在数组中的位置,即 last 起一个指针的作用,始终指向线性表中最后一个元素,因此,表空时last=-1。
这种存储思想的具体描述可以是多样的。
如可以是:datatype data[MAXSIZE];int last;这样表示的顺序表如图2.1 所示。
表长为 last+1,数据元素分别存放在data[0]到data[last]中。
这样使用简单方便,但有时不便管理。
0 1 … i-1 i … n-1 ... MAXSIZE1-1data a1 a2 … ai-1 ai ai+1 … an …图2.1 线性表的顺序存储示意图从结构性上考虑,通常将 data 和 last 封装成一个结构作为顺序表的类型:typedef struct{ datatype data[MAXSIZE];int last;} SeqList;定义一个顺序表:SeqList L ;这样表示的线性表如图2.2(a)所示。
数据结构 基于顺序存储结构对学生成绩表的设计 课程设计 实验报告
数据结构课程设计设计题目:基于顺序存储结构对学生成绩表的设计目录一、课题的目的和意义 (1)二、需求分析 (2)2.1、问题描述 (2)2.2、数据需求分析 (2)2.3、功能需求分析 (2)三、概要设计 (3)3.1、系统模块划分 (3)3.2 系统模块结构图 (3)四、详细设计 (3)4.1 结构类型定义 (3)4.2初始化 (4)4.3 创建学生成绩信息表 (4)4.4 插入和删除学生信息 (5)4.5 求每个学生的平均成绩 (6)4.6 对学生的平均成绩排序 (7)4.7 查找学生的信息 (8)4.8 输出学生信息表 (8)4.9 主函数 (9)五、运行结果和分析 (12)5.1、主界面 (12)5.2、创建学生成绩信息并输出以后的结果 (13)5.3、插入学生成绩信息并输出后的运行结果 (14)5.4、求出学生的平均成绩、进行排序并输出以后的结果 (15)5.5、根据学号查找学生的成绩信息后的结果 (16)六、实验总结 (16)七、源代码 (16)八、参考文献 (23)一、课题的目的和意义:数据结构作为一门学科主要研究数据的各种逻辑结构和存储结构,以及对数据的各种操作。
因此,主要有三个方面的内容:数据的逻辑结构;数据的物理存储结构;对数据的操作(或算法)。
通常,算法的设计取决于数据的逻辑结构,算法的实现取决于数据的物理存储结构。
数据结构是信息的一种组织方式,其目的是为了提高算法的效率,它通常与一组算法的集合相对应,通过这组算法集合可以对数据结构中的数据进行某种操作。
在当今信息时代,信息技术己成为当代知识经济的核心技术。
我们时刻都在和数据打交道。
比如人们在外出工作时找最短路径,在银行查询存款、通过互联网查新闻、以及远程教育报名等,所有这些都在与数据发生关系。
实际上,现实世界中的实体经过抽象以后,就可以成为计算机上所处理的数据。
数据结构课程主要是研究非数值计算的程序设计问题中所出现的计算机操作对象以及它们之间的关系和操作的学科。
数据结构线性表的顺序存储结构C语言实现
完成时间
typedef int ElemType; typedef struct{
ElemType *elem; int length; int listsize; }SqList;
void color(const unsigned short color1)//颜色函数 {
/*仅限改变 0-15 的颜色;如果在 0-15 那么实现他的颜色 因为如果超过 15 后面的改 变的是文本背景色*/
int *p; //在线性表 L 中查找第一个值与 e 满足 compare()的元素的位序 //若找到,则返回其在 L 中的位序,否则返回 0 int i=1; p=L->elem; while((i<=L->length) && (!(*compare)(*p++,5))) ++i; if(i<=L->length) return i; else return 0; } */ void search_L(SqList *L,ElemType e)//查找操作 { int j,flag=0; color(13); printf("\n 顺序表当前数据:"); printsq_L(L); color(10); printf("\n 请输入要查找的元素:");
学号:2015201018
数学与信息技术学院 2016~2017(下)学年
计科专业 2015 级《数据结构》实验报告 1
实验名称 线性表的顺序存储结构
实验目的
实验内容
姓名:汪继超
1. 掌握线性表的概念,掌握顺序表的概念及其各种运算 的原理。
2. 通过对线性表的查找、插入和删除算法的实现以加深 对线性表的顺序存储结构的理解,为加强线性表在实 际中的应用打下基础。
数据结构实验报告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、对创建的空线性表进行初始化操作,通过判断线性表是否为空的函数验证初始化是否成功。
线性表的顺序表示及实现实验报告
ListDelete(&fibo,c,&item);
PrintList(fibo);
}
实验步骤
1、WIN-TC开发环境安装与配置
1)首先在网上下载WIN-TC的版本;
2)下载完成后进行安装,安装路径默认就可以了,一路next就ok了;
3)打开WIN-TC会出现如下界st(SqList fibo)
{
int i;
for(i=0;i<fibo.length;i++) printf("%d\t",fibo.items[i]);
printf("\n");
return 1;
}
main()
{
int i;
int a,b,c;
int data[10];
DataType item;
{
printf("cha ru bu he fa");
return 0;
}
for(i=fibo->length-1;i>=pos-1;i--)
fibo->items[i+1]=fibo->items[i];
fibo->items[pos-1]=item;
fibo->length++;
return 1;
DataType items[LISTSIZE];
int length;
}SqList;
int ListDelete(SqList *fibo,int pos,DataType *item)
{
int i;
if(ListEmpty(*fibo))
线性表的顺序存储结构实验报告样例
年南昌航空大学实验报告(用实验报告纸,手写)课程名称:数据结构实验名称:实验一线性表的顺序存储结构班级: 08061 1 学生姓名:赖凌学号: 08061101 指导教师评定:签名:题目:有两张非递减有序的线性学生表A,B,采用顺序存储结构,两张表合并用c表存,要求C仍为非递减有序的,并删除C中值相同的表。
一、需求分析⒈本演示程序根据已有的6位学生的信息,实现两张表的合并及删除值相同元素的操作,不需要用户重新输入学生的信息。
⒉在演示过程序中,用户敲击键盘,即可观看演示结果。
⒊程序执行的命令包括:(1)构造线性表A(2)构造线性表B(3)求两张表的并(4)删除C中值相同的元素二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Stack{数据对象:D={ai :|ai∈ElemSe t,i=1…n,n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D,i=2,…n≥0}基本操作:init(list *L)操作结果:构造一个空的线性表L。
ListLe ngth(List *L)初始条件:线性表L已经存在操作结果:返回L中数据元素的个数。
GetEle m(List L, int i, ElemTy pe *e)初始条件:线性表L已经存在,1≤i≤ListLe ngth(&L)操作结果:用e返回L中第i个数据元素的值。
EqualL ist(ElemTy pe *e1,ElemTy pe *e2)初始条件:数据元素e1,e2存在操作结果:以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
Less_E quaLi st(ElemTy pe *e1,ElemTy pe *e2)初始条件:数据元素e1,e2存在操作结果:以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
数据结构线性表的顺序表示和实现的实习报告
数学与计算科学学院实验报告实验项目名称线性表的顺序表示与实现所属课程名称数据结构实验类型验证型__________实验日期___________________________班级----------------------------学号____________________________姓名____________________________成绩----------------------------实验概述:【实验目的】1线性表的逻辑结构特征1.1以元素在计算机内“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。
1.2有且仅有一个开始结点,没有直接前驱,且仅有一个直接后继;有且仅有一个终结结点,没有直接后继,且仅有一个直接前驱。
1.3其余内部结点都有且仅有一个直接前驱和一个直接后继。
2掌握线性表的基本操作在顺序存储结构上的实现。
【实验原理】1顺序表的特点1.1逻辑位置上相邻和物理位置上相邻1.2是一种随机存储结构,其存储位置可以用一简单直观的公式表示2顺序表的类C语言表示:#define LIST_INIT_SIZE 9 II线性表存储空间的初始分配量#define LISTINCREMENT? II线性表存储空间的分配增量typedef struct{ElemType * elem;//存储空间基址int len gth;II 当前长度int listsize;II 当前分配的存储容量(以sizeof ( ElemType)为单位)}SqList;【实验环境】VC++6.0、【实验内容】【实验方案】编写主函数,调用顺序表的初始化建空表,插入和删除算法,调试运行得出结果【实验过程】(实验步骤、记录、数据、分析)*(p+1)=*p;*q=e;++L .len gth; return OK;}Status ListDelect_Sq(SqList &L,int i,ElemType &e) {if((i<1)||(i>L.length)) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L .len gth-1;for(++p;p<=q;++p)*(p-1)=*p;--L .len gth;return OK;}void main(){SqList L;int i;In itList_Sq(L); for(i=0;i<LIST_INIT_SIZE;i++){scan f("%d",&L.elem[i]); L.len gth++;} for(i=0;i<L .len gth;i++) prin tf("%d ",L .elem[i]);prin tf("\n");ElemType e;sca nf("%d%d", &i,& e);ListI nsert_Sq(L,i,e);for(i=0;i<L .len gth;i++)prin tf("%d",L.elem[i]);prin tf("\n");sca nf("%d",&i);ListDelect_Sq(L,i,e);for(i=0;i<L .len gth;i++) prin tf("%d ",L .elem[i]);prin tf("\n");}2. 调试第一次出现的错误:C214:<: syntax error : missing befcre ***: Eienriipe^ : nlssirtg storage-class or specifiers CZFhl : ' elpn 11 : mi^ini| ?>Lordt|i?-tla^^ ur Lypt? spt?tiFiers C2146: 5i|ritax error : missing ' ;' before identif ier ' InitList _Sq C2591: 1Status * : missing storage-class or type ^pocifier£ error C130*ure»p&cted pnd oF Fil® found原因:由于许多变量未定义,以及没有头文件与宏定义所以错误许多,还有更多错 误没有显示出来3. 将以下语句编入程序中:#include "stdio.h" #inelude "stdlib.h" #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 9#define LISTINCREMENT 2 typedef int ElemType; typedef int Status;4. 调试第二次出现以下错误:.cpp(9£) : error C2965; *ncMbase" : Ufidrcl^rrd identifier■ eppe 蓟 :trror 02^0; : Cdniml cutivcrt fruin 'ibl *ftv 'inL rpi rirprprpt c^^T r J c-^ryi p r cr Funrttnn^^ryip r^«;r.cpp(3S> : error '-' : cannot convert fram 'int 1 ta 1int **pe to pointer type requires i pinterprrt cast, C style cast or functioncast:umJecltireij iJentifii?r :cannot convert +rom "int 备* to or Function-style cjst ;uiideLldreL iJetitifier :cannnr cflruprt 卡ram -i nr *■ tn cast oi* Punction-ft^lc c^stcpp■ - error cpp<^) ■ -error cpp(3) ■ errorcpp(6) - 启■cpp(e ■ ■■ errorcpp(8)■■ ■aFatal .) : t-rrtirC?965: .cpp)(Ji1 > : errorC2JPiU : * =' reinterpretoast, a C-st^le 工: trror CZ905: p".rp pl 即2》:frrur cpiuin : ' = ■ reinterpretcast, 2 C-'inL 'inr -^es a reinterpret cast * a C-style cast or function-style cast us _cpp(52) :error C2018: unknown character * 0xa1* us _cpp<52) : error C2 018: unknown character 'Qxa!*a reinterpretcast, a C^style cast or function^style cast fvs.cppCSS) : error C2100:illegal indirection Fus.cpp(55) : error C2100: illegal indirection Fus.cpp(55) : error原因:是在每个算法中有许多变量未定义,导致许多错误 5.再将语句:int *newbase;int *q; int *p;写入插入算法中; 将语句:int *p; int *q;写入删除算法中;6. 调试第三次显示没有错误:Compiling … asFvs ・(7ppasfus.obj - & error(s), 0 warning(s) 7. 运行第一次显示结果为:FUS.cpp(52) fus .cpp(S2) FUS .cpp(52) fU5.cpp(52) Fvs«cpp(52) 丽scpp(53) error error error error error error C2 018: C2EMB : C2018: C2 01«: unknown unknovjn unknovm unkin om character ch^ract^r character character• Oxal 1■'0xa1' 'Oxal 1C210O: illegal C2^40: indirection・:cannot convertfrom *int *pto 'int ' "es a reinterpret cast, a C^style cast or Function-st^le cast ^asFus _cpp02) tasfiis >cpp(42) ^asFus.cpp(42) ^asfus>cpp(U3) 需弓fu 与 _cpp<51) IQS F US _C PPCE1) idsFus .cpp (51 j idsFu^ >cpp(51) ^asfu^.cpp(51) error error error error error □ rr or error error err or C21OO: illegal indirectioin C21oo : illegal indirectionC2196: 1=' : left operand must be 1-ualueC210C: illegalC2018: C20i8:C2918: C2C18: unknown unicnoun unknown unknownC244C :' indirection character 10xa11character '* character '0xa1* character 'Oxa1*:cannot conuert from 'int to * int' C2106: • : left operand must be 1-ualueuunt xyui auxutt. i 忖丄Compiling ____asfvs.cppasfus.ob j - Q error(s)r0 warning(s)13.运行第四次显示结果为:*H:\De bug時临恚或咗序表尹W实現芒灼耳请输入您想构建的顺序表(元素为9个)=1 2 3 4 E 6 7 S 9您构建的顺序表杲:■£22456789请输入您想在第几个元素位置前插入元素二18输入的数字错误.(只乘U下瞅重新输入符合要求的数字的机会)常入的数字错误.(只剩Ft枕重新输入符合要求的数字的机会){青输入您想插入的数:6183形成的新顺序表为;彳7 4 4 C 仇 ~(曲4 £."5 Q o睛输入您想删除的是第几个元素:13输入的数字诸误.(只剩下2次重新输入符合要求的数字的机会)易入的数字错误,(只剩下丄次重新输入符合要求的数字的机会)电除的数为:協咸的新顺序表为=1 2 3 4 5 6183 ? 8 9Press ani^ y to comtinue1 刑这样那么程序就完整了,清晰明了,用户运行的时候也容易知道自己要输入什么了【实验结论】(结果)i 曲%谍性義的1驚表示与实现心b L 口 |屈*3^附录1源程序\n",p);附录2:实验报告填写说明1.实验项目名称:要求与实验教学大纲一致。
实验一线性表的顺序存储结构实验报告页
实验一线性表的顺序存储结构实验报告页攀枝花学院实验报告实验课程数据结构实验项目:线性表的顺序存储实验日期:系:班级:姓名:学号:同组人:指导老师:成绩:[ 实验目的:]1、掌握线性表的顺序存储结构。
2、能熟练地利用顺序存储结构实现线性表的基本操作。
3、能熟练地掌握顺序存储结构中算法的实现。
[ 实验仪器设备、药品、器材 ]1、硬件环境微型计算机一台2、软件环境Windows98/20XX/XP/win7操作系统、调试程序VC[ 实验原理]无[ 实验步骤]一、建立含有若干个元素的顺序表,并将结果在屏幕上输出。
1、顺序表源代码如下创建了顺序表的头文件主要代码如下:void initList(SeqList& L) { =new DataType[initSize]; if (! ) { cerr+1) return 0;for(int j=;j>=i;j--) int Search(SeqList& L,DataType x)//顺序查找算法{ [j]=[j-1]; for(int i=1;i=1 && i)return 0; }; x=[i-1];for(int j=i;j<;j++) void Copy(SeqList& L1,SeqList& L2)//顺序表复制 [j-1]=[j]; 算法{ ; =; return 1; =; }; if(!)主函数代码如下:void main { int ch; int i; DataType x; SeqList L; =0; initList(L); printf(\ **************\\n\printf(\欢迎进入CHEN CHENG 顺序表结构******************\\n\ Creat(L); menu ;/*显示菜单*/ scanf(\输入一个数符*/ while(1) {switch(ch) { case 0: printf(\2实验报告附页Print(L); Copy(La,L); break; printf(\输出顺序表L的值:case 1: printf(\\\n\Length(L)); Print(L);break;printf(\case 2: i=isEmpty(L);printf(\输出顺序表La的值:if(i==0) \\n\Print(La);printf(\顺序表非break; 空!\\n\if(i==1) case 7:printf(\scanf(\ printf(\顺序表为printf(\空!\\n\break;printf(\ case 3: i=isFull(L); scanf(\ if(i==1) printf(\if(Insert(L,i,x)==1)printf(\顺序表已{ 满!\\n\if(i==0)printf(\printf(\顺序表未printf(\输出插入元素后的顺满!\\n\序表L!\\n\ break;Print(L); case 4:printf(\} scanf(\ else i=Search(L,x); printf(\ !\\n\ if(i==0)break;printf(\查找失败!\case 8:printf(\ else scanf(\if(Remove(L,i,x))printf(\查找成功:\\n%d { 为查找数!\\n\break;printf(\ case 5:printf(\ deleted data is %d!\\n\ scanf(\ printf(\输出删除后元素后的i=Locate(L,i); 顺序表L!\\n\if(i==0) printf(\Print(L); find %d\\n\}else else printf(\ printf(\of %d is %d\\n\ break; break; case 9:printf(\创建一个新的顺序表!\\n\SeqList Lc; case 6: printf(\创建一个新的顺序=0; 表!\\n\SeqList La; initList(Lc); =0; Creat(Lc); initList(La); Merge(Lc,L);3实验报告附页printf(\输出求交后的顺序表的值: \Print(Lc); break; case 10:printf(\创建一个新的顺序表!\\n\SeqList Lb;=0; initList(Lb);Creat(Lb);Intersection(Lb,L); printf(\输出求交后的顺序表的值: \Print(Lb); break;case 11: printf(\ printf(\ exit(1); } printf(\再次输入选择:\ scanf(\ } }程序运行结果如下:2、对刚建立的表实现插入、删除、修改、查找,并将结果在屏幕上输出。
实验报告 线性表的顺序存储结构
**大学实验报告学院:专业:班级:
实
验
总
结
1、线性表的初始化为一个空表时,要明确给空(l.list==NULL)
2、线性表的插入、删除操作前都要进行非法位置的剔除
3、插入、删除等操作非法时,一定要有返回值(return false),否则操作会出现错误
4、程序编写过程中,要注意细节部分,减少错误的产生,减少调试时间
指
导
教
师
意
见签名:年月日注:各学院可根据教学需要对以上栏木进行增减。
表格内容可根据内容扩充。
(资料素材和资料部分来自网络,供参考。
可复制、编制,期待你的好评与关注)。
线性表的顺序储存结构
重庆交通大学 《算法与数据结构》课程实验报告班 级:计算机科学与技术 级 班实验项目名称: 线性表的顺序储存结构实验项目性质:实验所属课程: 算法与数据结构实验室☎中心✆: 指 导 教 师 : 鲁云平实验完成时间: 年 月 日一、实验目的、实现线性表的顺序存储结构、熟悉 程序的基本结构,掌握程序中的头文件、实现文件和主文件之 间的相互关系及各自的作用、熟悉顺序表的基本操作方式 掌握顺序表相关操作的具体实现二、实验内容及要求对顺序存储的线性表进行一些基本操作。
主要包括:( )插入:操作方式为在指定元素前插入、在指定元素之后插入、在指定 位置完成插入( )删除:操作方式可分为删除指定元素、删除指定位置的元素等,尝试 实现逻辑删除操作。
( )显示数据( )查找:查询指定的元素(可根据某个数据成员完成查询操作)( )定位操作:定位指定元素的序号( )更新:修改指定元素的数据( )数据文件的读写操作等。
其它操作可根据具体需要自行补充。
要求线性表采用类的定义 数据对象的类型自行定义。
三、实验设备及软件✞四、设计方案㈠ 题目线性表的顺序存储结构㈡ 设计的主要思路、新建 ♏❑☹♓♦♦♒头文件,定义 ♏❑☹♓♦♦模板类、设计类数据成员,包括:❆ ✉♎♋♦♋(用于存放数组)、♓⏹♦ ❍♋⌧♓♏(最 大可容表项的项数)、♓⏹♦ ●♋♦♦(当前已存表项的最后位置)、设计类成员函数,主要包括:♓⏹♦ ♦♏♋❒♍♒☎❆ ⌧✆♍☐⏹♦♦搜索⌧在表中位置,函数返回表项序号♓⏹♦ ☹☐♍♋♦♏☎♓⏹♦ ♓✆♍☐⏹♦♦定位第♓个表项,函数返回表项序号♌☐☐● ♑♏♦♋♦♋☎♓⏹♦ ♓❆ ⌧✆♍☐⏹♦♦去第♓个表项的值❖☐♓♎ ♦♏♦♋♦♋☎♓⏹♦ ♓❆ ⌧✆用⌧修改第♓个表项的值♌☐☐● ✋⏹♦♏❒♦☎♓⏹♦ ♓❆ ⌧✆插入⌧在第♓个表项之后♌☐☐● ♏❍☐❖♏☎♓⏹♦ ♓❆ ⌧✆ 删除第♓个表项,通过⌧返回表项的值♌☐☐● ✋♦☜❍☐♦⍓☎✆判表空否,空则返回♦❒◆♏;否则返回♐♋●♦♏♌☐☐● ✋♦☞◆●●☎✆判表满否,满则返回♦❒◆♏;否则返回♐♋●♦♏❖☐♓♎ ♓⏹☐◆♦☎✆ 输入❖☐♓♎ ☐◆♦☐◆♦☎✆输出❖☐♓♎ ☐♐♓●♏☎✆存储在文件中❖☐♓♎ ♓♐♓●♏☎✆读取文件并显示㈢ 主要功能、建立新表、对表进行插入(指定元素前、后以及指定位置插入)、删除(指定 元素删除及指定位置删除)、修改等操作、显示当前操作表的全部内容、存储在文件中、从文件中读取表五、主要代码㈠ ♏❑☹♓♦♦♒中的主要代码:、类成员声明部分:☐❒☐♦♏♍♦♏♎❆ ✉♎♋♦♋ 存放数组♓⏹♦ ❍♋⌧♓♏ 最大可容纳表项的项数♓⏹♦ ●♋♦♦ 当前已存表项的最后位置(从 开始)❖☐♓♎ ❒♏♓♏☎♓⏹♦ ⏹♏♦♓♏✆改变♎♋♦♋数组空间大小☐◆♌●♓♍♏❑☹♓♦♦☎♓⏹♦ ♦ ♎♏♐♋◆●♦♓♏✆构造函数♏❑☹♓♦♦☎♏❑☹♓♦♦❆ ☹✆复制构造函数❞♏❑☹♓♦♦☎✆♎♏●♏♦♏☯ ♎♋♦♋❝析构函数♓⏹♦ ♓♏☎✆♍☐⏹♦♦❒♏♦◆❒⏹ ❍♋⌧♓♏❝计算表最大可容纳表项个数♓⏹♦ ☹♏⏹♑♦♒☎✆♍☐⏹♦♦❒♏♦◆❒⏹ ●♋♦♦❝计算表长度♓⏹♦ ♦♏♋❒♍♒☎❆ ⌧✆♍☐⏹♦♦搜索⌧在表中位置,函数返回表项序号♓⏹♦ ☹☐♍♋♦♏☎♓⏹♦ ♓✆♍☐⏹♦♦定位第♓个表项,函数返回表项序号♌☐☐● ♑♏♦♋♦♋☎♓⏹♦ ♓❆ ⌧✆♍☐⏹♦♦去第♓个表项的值♓♐☎♓♓●♋♦♦✆⌧♎♋♦♋☯♓❒♏♦◆❒⏹ ♦❒◆♏❝♏●♦♏ ❒♏♦◆❒⏹ ♐♋●♦♏❝❖☐♓♎ ♦♏♦♋♦♋☎♓⏹♦ ♓❆ ⌧✆用⌧修改第♓个表项的值♓♐☎♓♓●♋♦♦✆ ♎♋♦♋☯♓⌧❝♌☐☐● ✋⏹♦♏❒♦☎♓⏹♦ ♓❆ ⌧✆插入⌧在第♓个表项之后♌☐☐● ♏❍☐❖♏☎♓⏹♦ ♓❆ ⌧✆删除第♓个表项,通过⌧返回表项的值♌☐☐● ✋♦☜❍☐♦⍓☎✆❒♏♦◆❒⏹ ☎●♋♦♦ ✆✍♦❒◆♏♐♋●♦♏❝ 判表空否,空则返回♦❒◆♏;否则返回♐♋●♦♏♌☐☐● ✋♦☞◆●●☎✆❒♏♦◆❒⏹ ☎●♋♦♦ ❍♋⌧♓♏ ✆✍♦❒◆♏♐♋●♦♏❝ 判表满否,满则返回♦❒◆♏;否则返回♐♋●♦♏❖☐♓♎ ♓⏹☐◆♦☎✆ 输入❖☐♓♎ ☐◆♦☐◆♦☎✆输出♏❑☹♓♦♦❆☐☐♏❒♋♦☐❒☎♏❑☹♓♦♦❆ ☹✆表整体赋值❖☐♓♎ ☐♐♓●♏☎✆ 存储在文件中❖☐♓♎ ♓♐♓●♏☎✆ 读取文件并显示、部分成员函数搜索函数:在表中顺序搜索与给定值⌧匹配的表项,找到则函数返回该表项是第几个元素否则函数返回 ,表示搜索失败♦♏❍☐●♋♦♏♍●♋♦♦ ❆♓⏹♦ ♏❑☹♓♦♦❆♦♏♋❒♍♒☎❆ ⌧✆♍☐⏹♦♦♐☐❒☎♓⏹♦ ♓ ♓ ●♋♦♦ ♓✆♓♐☎♎♋♦♋☯♓ ⌧✆ ❒♏♦◆❒⏹ ♓顺序搜索❒♏♦◆❒⏹ 搜索失败❝定位函数:♦♏❍☐●♋♦♏♍●♋♦♦ ❆♓⏹♦ ♏❑☹♓♦♦❆☹☐♍♋♦♏☎♓⏹♦ ♓✆♍☐⏹♦♦♓♐☎♓ ♓♓ ●♋♦♦✆ ❒♏♦◆❒⏹ ♓♏●♦♏ ❒♏♦◆❒⏹ ❝插入函数将新元素⌧插入到表中第♓(♓♓●♋♦♦)个表项之后,函数返回插入成功的信息,若插入成功,则返回♦❒◆♏;否则返回♐♋●♦♏♓是虚拟的,实际上是插入的第 个元素位置♦♏❍☐●♋♦♏♍●♋♦♦ ❆♌☐☐● ♏❑☹♓♦♦❆✋⏹♦♏❒♦☎♓⏹♦ ♓❆ ⌧✆♓♐☎●♋♦♦ ❍♋⌧♓♏✆ ❒♏♦◆❒⏹ ♐♋●♦♏ 表满,不能插入♓♐☎♓ ♓●♋♦♦✆ ❒♏♦◆❒⏹ ♐♋●♦♏参数♓不合理,不能插入♐☐❒☎♓⏹♦ ●♋♦♦ ♓✆依次后移,空出第♓号位置♎♋♦♋☯ ♎♋♦♋☯♎♋♦♋☯♓ ⌧ 插入●♋♦♦ 最后位置 ❒♏♦◆❒⏹ ♦❒◆♏ 插入成功❝删除函数从表中删除第♓个表项,通过应用型参数⌧返回删除的元素值,函数返回删除成功的信息,如删除成功则返回♦❒◆♏,否则返回♐♋●♦♏♦♏❍☐●♋♦♏♍●♋♦♦ ❆♌☐☐● ♏❑☹♓♦♦❆♏❍☐❖♏☎♓⏹♦ ♓❆ ⌧✆ ♓♐☎●♋♦♦ ✆❒♏♦◆❒⏹ ♐♋●♦♏♓♐☎♓ ♓●♋♦♦✆❒♏♦◆❒⏹ ♐♋●♦♏⌧ ♎♋♦♋☯♓♐☐❒☎♓⏹♦ ♓ ●♋♦♦✆♎♋♦♋☯ ♎♋♦♋☯●♋♦♦❒♏♦◆❒⏹ ♦❒◆♏❝输入函数从标准输入逐个数据输入,建立顺序表♦♏❍☐●♋♦♏♍●♋♦♦ ❆❖☐♓♎ ♏❑☹♓♦♦❆♓⏹☐◆♦☎✆♍☐◆♦✂开始建立顺序表,请输入表中的元素个数 ✂♦♒♓●♏☎✆♍♓⏹●♋♦♦♓♐☎●♋♦♦❍♋⌧♓♏✆ ♌❒♏♋♍☐◆♦✂表元素个数有误,范围不能超过✂❍♋⌧♓♏✂✂❝♐☐❒☎♓⏹♦ ♓ ♓ ●♋♦♦♓✆♍☐◆♦✂✁✂♓✂✂♍♓⏹♎♋♦♋☯♓❝❝输出函数♦♏❍☐●♋♦♏♍●♋♦♦ ❆❖☐♓♎ ♏❑☹♓♦♦❆☐◆♦☐◆♦☎✆♍☐◆♦✂顺序表当前元素最后的位置为:✂●♋♦♦♏⏹♎●♐☐❒☎♓⏹♦ ♓ ♓ ●♋♦♦♓✆♍☐◆♦✂✁✂♓✂✂♎♋♦♋☯♓♏⏹♎●❝存储在文件中♦♏❍☐●♋♦♏♍●♋♦♦ ❆❖☐♓♎ ♏❑☹♓♦♦❆☐♐♓●♏☎✆☐♐♦♦❒♏♋❍ ♐☎✂❆♏♦♦♦⌧♦✂♓☐♦☐◆♦✆♓♐☎✐♐✆♍☐◆♦✂存储文件失败!✂♏⏹♎●♏⌧♓♦☎✆❝♐☐❒☎♓⏹♦ ♓ ♓ ●♋♦♦♓✆♐♦❒♓♦♏☎☎♍♒♋❒✉✆ ♎♋♦♋☯♓♦♓♏☐♐☎♎♋♦♋☯♓✆✆♍☐◆♦✂存储成功!✂♏⏹♎●♐♍●☐♦♏☎✆❝读取文件并打印出文件内容♦♏❍☐●♋♦♏♍●♋♦♦ ❆❖☐♓♎ ♏❑☹♓♦♦❆♓♐♓●♏☎✆♓♐♦♦❒♏♋❍ ♐☎✂❆♏♦♦♦⌧♦✂♓☐♦♌♓⏹♋❒⍓✆♓♐☎✐♐✆♍☐◆♦✂打开文件失败!✂♏⏹♎●♏⌧♓♦☎✆❝♍☐◆♦✂文件内容如下:✂♏⏹♎●♐☐❒☎♓⏹♦ ♓ ✐♐♏☐♐☎✆♓✆♐❒♏♋♎☎☎♍♒♋❒✉✆♎♋♦♋☯♓♦♓♏☐♐☎♎♋♦♋☯♓✆✆❝♐☐❒☎♓⏹♦ ♓✆♍☐◆♦✂✁✂✂✂♎♋♦♋☯♏⏹♎●♐♍●☐♦♏☎✆❝㈡ 测试主函数、插入功能,对不同位置的插入通过修改函数✋⏹♦♏❒♦☎♓⏹♦ ♓⌧✆第一形参实现 位置可通过成员函数♦♏♋❒♍♒☎⌧✆确定♍♋♦♏ 指定元素后插入♓⏹♦ ⌧⍓♍☐◆♦✂请输入指定元素 ✂♍♓⏹⌧♍☐◆♦✂请输入要插入的元素 ✂♍♓⏹⍓♏❑✋⏹♦♏❒♦☎♏❑♦♏♋❒♍♒☎⌧✆⍓✆♌❒♏♋❝♍♋♦♏ 指定位置插入♓⏹♦ ♓⌧♍☐◆♦✂请输入插入的位置 ✂♍♓⏹♓♍☐◆♦✂请输入要插入的元素 ✂♍♓⏹⌧♏❑✋⏹♦♏❒♦☎♓⌧✆♌❒♏♋❝♍♋♦♏ 按内容删除指定元素♓⏹♦ ♓⌧♍☐◆♦✂请输入要删除的元素内容 ✂♍♓⏹⌧♓ ♏❑♦♏♋❒♍♒☎⌧✆指定元素位置♓♐☎♏❑♏❍☐❖♏☎♓⌧✆✆ ♍☐◆♦✂删除成功!✂♏⏹♎●♏●♦♏ ♍☐◆♦✂删除失败!✂♏⏹♎●♌❒♏♋❝、删除功能,指定序号删除直接调用 ♏❍☐❖♏☎♓⌧✆即可实现,指定表项的内容删除可通过♦♏♋❒♍♒☎⌧✆函数返回得到该表项的序号,再通过 ♏❍☐❖♏☎♓⌧✆实现♍♋♦♏ 按内容删除指定元素♓⏹♦ ♓⌧♍☐◆♦✂请输入要删除的元素内容 ✂♍♓⏹⌧♓ ♏❑♦♏♋❒♍♒☎⌧✆ 指定元素位置♓♐☎♏❑♏❍☐❖♏☎♓⌧✆✆ ♍☐◆♦✂删除成功!✂♏⏹♎●♏●♦♏ ♍☐◆♦✂删除失败!✂♏⏹♎●♌❒♏♋❝♍♋♦♏ 按位置删除指定元素♓⏹♦ ♓⌧♍☐◆♦✂请输入要删除的元素序号 ✂♍♓⏹♓♓♐☎♏❑♏❍☐❖♏☎♓⌧✆✆ ♍☐◆♦✂删除成功,删除的元素 是 ✂⌧♏⏹♎●♏●♦♏ ♍☐◆♦✂删除失败!✂♏⏹♎●♌❒♏♋❝、显示功能,直接调用成员函数☐◆♦☐◆♦☎✆即可实现。
线性表的顺序存储结构和实现
线性表的顺序存储结构和实现线性表的顺序存储结构和实现石家庄经济学院实验报告学院: 数理学院专业: 数学与应用数学学号: XXXXXXXX姓名: XXXXXX信息工程学院计算机实验中心制实验题目:线性表的顺序存储结构和实现1.熟悉C 语言的上机环境,掌握C 语言的基本结构。
2.会定义线性表的顺序存储结构。
3.熟悉对顺序表的一些基本操作(建表、插入、删除等)和具体的函数定义。
1、掌握顺序存储结构的特点 2. 掌握顺序存储结构的常见算法3、掌握顺序存储结构的特点,了解、掌握并实现顺序表的常用的基本算法。
三、实验的内容及完成情况1. 需求分析(1)线性表的抽象数据类型ADT的描述及实现。
本实验实现使用Visual c++6.0实现线性表顺序存储结构的表示及操作。
具体实现要求:(2)完成对线性表顺序存储结构的表示和实现。
(3)实现对线性表的建立和初始化。
(4)实现对线性表插入和删除部分元素。
抽象数据类型线性表的定义:数据对象:D={ai |ai∈ ElemSet,i=1,2,……,n,n≥0}数据关系:R1={|ai-1,ai∈ D,i=2,……,n}InitList_sq(&L)操作结果:构造一个空的线性表L。
ListInsert_sq(&L,i,e)初始条件:线性表L已存在,1≤i≤L.Length+1。
操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1。
ListDelete_sq(&L,i,&e)初始条件:线性表L已存在且非空,1≤i≤L.Length。
操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减1。
input()(1)抽象数据类型线性表顺序存储结构的表示和实现//线性表结构类型#define LIST_INIT_SIZE 100//线性表存储空间的初始分量#define LISTINCREMENT 10//线性表存储空间的分配增量typedef structelemtype *elem;//存储空间基址int length;//当前线性表的长度int listsize;//当前分配的存储容量(以sizeof(elemtype)为单位)}sqlist;//建立线性表Status InitList_sq(sqlist &L){//构造一个空的线性表L.elem=(elemtype *)malloc(LIST_INIT_SIZE*sizeof(elemtype)); if(!L.elem) exit(OVERFLOW);//存储分配失败 L.length=0; //空表长度为0L.listsize=LIST_INIT_SIZE;//初始存储容量 return OK;}//InitList_sq//在线性表指定位置插入指定元素Status ListInsert_sq(sqlist &L,int i,int e){ //在线性表L中第i个位置前插入新的元素e//i的合法值1if(iL.length+1) return ERROR;//i值不合法if(L.length>=L.listsize)//当存储空间已满,增加分配{ newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!newbase) exit(OVERFLOW);//存储分配失败 L.elem=newbase; //新基址L.listsize+=LISTINCREMENT; //增加存储容量 } q=&(L.elem[i-1]); //q为插入位置for(p=&(L.elem[L.length-1]);p>=q;--p) *(p+1)=*p; //插入位置及之后的元素后移*q=e; //插入e ++L.length;//表长增加1 return OK;}//ListInsert_sq//在线性表指定位置删除元素Status ListDelete_sq(sqlist &L,int i,int &e){ //在顺序表L中删除第i个元素,并用e返回其值//i的合法值为1if(iL.length) return ERROR;//i值不合法 p=&(L.elem[i-1]);//p为被删除元素的位置 e=*p; //被删除元素复制给e q=L.elem+L.length-1;//表尾元素的位置 for(++p;p}//ListDelete_sq(2)主函数的伪码算法void main()//主函数printf("\t\t》》》》》》》>>数据结构实验一printf("\t\t*********线性表的顺序存储结构和实现***********\n");menu();printf("\t\t★请按提示输入指令:");。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
printf("Please input the student's position to insert a new record:");
scanf("%d", &position);
//printf("and then please input the new information:"); //这句可以看作是多余的,因为WriteInfo函数中已有该提示语句。
}
void Store( SeqList *L)
{
int n, i;
void InsertList( SeqList *L, int i, DataType x ); //插入函数的声明
printf(" Please input the number of records: ");
=================================Main.c=============================================
#include <stdlib.h>
#include "SeqList_Basic.h"
void main(){
return L->records[i];
}
DataType DeleteList( SeqList *L, int i)
{
int j;
DataType temp;
if( i<1 || i>L->length )
{
printf("Postion Error!\n");
}
}
void Show( SeqList *L)
{
int i;
printf("\t\t\t\t学号:\t姓名:\t年龄:\t学分:\n");
for( i=0 ; i<L->length ; i++)
printf("\t\t\t\t%s \t%s \t%3d \t%6.2f \n", L->records [i].number ,L->records [i].name ,L->records [i].age , L->records [i].score );
else if(j==3){
printf("input Age: ");
scanf("%d", &temp.age );
}
else{
printf("input Score: ");
scanf("%f", &temp.score );
}
}
return temp;
temp= WriteInfo();
InsertList(&student, position, temp); //向第i个学生之前插入一个信息为temp的新学生,并把记录表长加1
printf("Please input a student's name to get his information:");
scanf("%s", name);
temp = LocateNode(&student, name); // 根据姓名获取学生信息
printf("\t\t\t\t%s \t%s \t%3d \t%6.2f \n", temp.number , , temp.age , temp.score );
printf("input Name: ");
scanf("%s", );
}
else if(j==3){
printf("input Age: ");
scanf("%d", &temp.age );
}
else{
scanf("%d", &n);
for( i=0; i<n; i++) //每循环一次存储一个学生的信息
{
int j;
DataType temp;
printf("\n\n\t\t\t PLEASE INPUT the INFORMATION of STUDENT%d \n", i+1);
DS:顺序表
利用线性表的顺序存储结构实现学生记录表
===================================================================================
===========================Node.h==================================================
#include <stdio.h>
#include <string.h>
#include "Node.h"
void InitList( SeqList *L)
{
L->length = 0;
}
DataType WriteInfo () //向一个记录节点中写入信息
{
printf("input Score: ");
scanf("%f", &temp.score ); tList( L, i+1, temp ); //向记录表中插入第i个学生的信息;经过n次插入后,
//n个学生的信息就存储在记录表里面了。
int position;
char *name=(char *)malloc(6*sizeof(char));
DataType temp;
SeqList student; //生成一个名为"student"的记录表
InitList(&student); //对新生成的 记录表 置空
L->records[i-1] = x ; //插入元素
L->length++ ; //修改表长
}
int ListLength( SeqList *L)
{
return L->length ;
}
//void LocateList( SeqList *L, char )
}
void InsertList( SeqList *L, int i, DataType x )
{
int j;
if( i < 1 || i > L->length +1 ) //插入位置的检查
{
printf(" position error! \n");
return;
}
return L->records [i-1];
}
DataType LocateNode( SeqList *L, char * name)
{
int i;
for(i=0; i< L->length; i++)
if( strcmp( name, L->records[i].name ) == 0 )
#define ListSize 20
typedef struct record {
char number[6];
char name[10];
int age;
float score;
} DataType;
typedef struct {
DataType records[ListSize];
===================================================================================
===========================SeqList_Basic.h=========================================
int j;
DataType temp;
printf("\n\n\t\t\t Please input a new student's information:\n");
for( j=1; j<=4; j++) //给第 i个 学生 输入信息
{
if(j == 1){
int length;
}SeqList;
===================================================================================
===================================================================================
for( j=1; j<=4; j++) //给第 i个 学生 输入信息
{
if(j == 1){
printf("input Number (5 figures): ");
scanf("%s", temp.number );
}
else if(j ==2){
//{