实验一线性表的顺序存储及其操作

合集下载

实验一线性表的顺序存储结构

实验一线性表的顺序存储结构一．实验的目的要求：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.缺点：________插入和删除操作需要移动大量的元素，不适用于频繁插入和删除的场景。

第五章实验过程和结果分析在本次实验中，我们以顺序存储结构为基础，实现了线性表的增删改查操作，并进行了遍历操作。

通过实验，我们发现顺序存储结构在查询操作上有较好的性能，但在插入和删除操作上的性能较差。

第六章附件本文档涉及的附件详见附件文件。

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

实验报告线性表的顺序存储结构

**大学实验报告
学院: 专业: 班级:
姓名
学号
实验组
实验时间
指导教师
成绩
实验项目名称实验一线性Fra bibliotek的顺序存储结构
实验目的
1、熟练掌握线性表的基本操作在顺序存储与链式存储上的实现;
2、以线性表的各种操作(建立、插入、删除等)的实现为重点;
3、掌握线性表的动态分配顺序存储结构的定义与基本操作的实现;
if(pos<1||pos>l、size+1)
{
cout<<"插入的位置非法!"<<endl;
return false;
}
if(l、size==l、maxsize)
{
int k=sizeof(Elemtype);
l、elem=(Elemtype *)realloc(l、elem,2*l、maxsize*k);
insertlist(k,a[i],i+1);
traverselist(k);
cout<<"插入一个位置:"<<endl;
cin>>x;
cout<<endl;
insertlist(k,0,x);
traverselist(k);
cout<<"插入一个元素:"<<endl;
cin>>x;
cout<<endl;
if(l、elem==NULL)
{
cout<<"分配空间不成功!"<<endl;
return false;

数据结构实验报告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．掌握用上机调试线性表顺序实现的基本方法。

2．掌握线性表的基本操作，插入、删除、查找等运算在顺序存储结构上的实现。

二、实验要求1．认真阅读和分析实验内容。

2．设计顺序线性表操作的算法。

3．编程实现这些算法。

4．上机调试程序，结合程序进行分析，打印出文件清单和运行结果。

三、实验内容1．线性表顺序存储的物理结构（如图所示）① Elem ：存储存放表元素连续内存空间的首地址；② Length ：存储Elem 所指空间中存放的元素个数；③ ListSize ：存储Elem 空间的大小，该大小值以元素个数为单位来体现；④ 注意，在线性表的逻辑结构中，元素在线性表中的位置次序是从1开始计数的； ⑤ 线性表L 实质是一个具有三个域的结构类型的变量。

2．编程实现如下要求：定义出该线性表物理结构；初始化顺序存储的线性表；销毁线性表；将线性表重新设置为空表；判断线性表是否为空表；返回线性表的长度；在线性表中插入一个元素；在线性表中删除一个元素；取线性表中第i 个元素的值；在线性表中查找参数Elem 值所给定的元素；将线性表中指定位置的元素值修改成指定的值。

3．代码示例// 以下代码书写在SqList.h 文件中。

#include <stdlib.h> // 一般将系统头文件用< >括起来，自定义头文件用" "括起来。

#define LIST_INIT_SIZE 50#define LIST_INCREMENT 50//typedef int ListElemType;// 该类型的定义也可以在该头文件的外部来定义，这样在使用线性表结构时，可以尽可能少地 // 改动该头文件内的代码。

// 顺序线性表数据类型的定义。

该定义是对所设计的物理结构的编程语言描述。

typedef struct{ListElemType *Elem; // 存放一片连续内存空间的首地址，该空间中存放线性表元素值。

数据结构实验一线性表的顺序存储及其操作 - 副本

实验一线性表的顺序存储及其操作一、【实验目的】掌握线性表在顺序存储下的插入与删除等基本运算二、【指导思想】用数组和线性表长存储线性表，实现线性表的基本操作。

三、【实验内容】实现顺序表的建立、输入、输出、查找、插入、删除等功能，每个功能用一个函数实现。

（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点之前发给我，麻烦了，谢谢落实单位姓名性别民族年龄党龄学历职业曾任党内职务与党组织失去联系时间（失联填）失去联系情形（失联填）党组织类别（①国有企业；②非公有制企业：③农村；④党政机关；⑤学校；⑥其他事业单位；⑦街道社区；⑧社会组织；⑨其他。

线性表的顺序存储与基本操作

第2讲线性表的顺序存储与基本操作线性表是1对1的逻辑关系，要存放在计算机中，可采用顺序、链式两种存储结构。

本讲学习线性表的顺序存储结构，包括顺序存储结构定义和其上的基本运算。

一、顺序表的类型定义线性表的顺序存储简称为顺序表：用一组地址连续的存储单元依次存储线性表中的各个元素逻辑上相邻的数据元素在物理上也相邻因此：将顺序表归纳为：关系线性化，结点顺序存。

给出线性表存储的线性公式：假设线性表中有n个元素，每个元素占k个单元，第一个元素的地址为loc(a1)则可通过如下公式计算出第i个元素的地址loc(a i)：loc(a i) =loc(a1)+(i-1)×k(2-1)其中loc(a1) 称为基地址。

借助c语言的数组类型，来表示顺序表：#defineMAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ElemType elem[MAXSIZE]；/* 线性表占用的数组空间*/int last；/*记录线性表中最后一个元素在数组elem[ ]中的位置（下标值），空表置为-1*/} SeqList；二、顺序表基本运算●查找，可以有两种：按序号查找和按内容查找。

⏹按序号查找GetData(L,i)：查找线性表L中第i个数据元素。

根据顺序表L的存储特性，表中元素在L的elem数组中顺序存放，故GetData(L,i)等同于L.elem[i-1]。

⏹ 按内容查找Locate （L,e ）: 要求查找线性表L 中与给定值e 相等的数据元素。

若在表L 中找到与e 相等的元素，则返回该元素在表中的序号；若找不到，则返回一个“空序号”标识如-1。

【算法思想】查找运算可采用顺序查找法实现，即从第一个元素开始，依次将表中元素与e 相比较，若相等，则查找成功，返回该元素在表中的序号；若e 与表中的所有元素都不相等，则查找失败，返回-1。

【算法描述】线性表的查找运算int Locate(SeqList L ，ElemType e)/*在顺序表L 中依次存放着线性表中的元素，在表中查找与e 相等的元素，若 L.elem[i]=e,则找到该元素，并返回i+1，若找不到，则返回“-1”*/{i=0 ; /*i 为扫描计数器，初值为0，即从第一个元素开始比较*/while ((i<=L .last)&&(L .elem[i]!=e) ) /*顺序扫描表，直到找到值为key 的元素,i++; 或扫描到表尾而没找到*/if (i<=L .last)return(i+1); /*若找到值为e 的元素，则返回其序号*/ elsereturn(-1); /*若没找到，则返回空序号*/}算法的时间复杂度为O(n)。

线性表的顺序存储实验

实验一线性表的顺序存储实验一、实验目的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); }。

线性表的顺序存储结构实验报告样例

年南昌航空‎大学实验报‎告（用实验报告‎纸，手写）课程名称：数据结构实验名称：实验一线性表的顺‎序存储结构‎班级： 08061‎ 1 学生姓名：赖凌学号： 08061‎101 指导教师评‎定：签名:题目：有两张非递‎减有序的线‎性学生表A‎，B，采用顺序存‎储结构，两张表合并‎用c表存，要求C仍为‎非递减有序‎的，并删除C中‎值相同的表‎。

一、需求分析⒈本演示程序‎根据已有的‎6位学生的‎信息，实现两张表‎的合并及删‎除值相同元‎素的操作，不需要用户‎重新输入学‎生的信息。

⒉在演示过程‎序中，用户敲击键‎盘，即可观看演‎示结果。

⒊程序执行的‎命令包括：（1）构造线性表‎A（2）构造线性表‎B（3）求两张表的‎并（4）删除C中值‎相同的元素‎二、概要设计⒈为实现上述‎算法，需要线性表‎的抽象数据‎类型：ADT Stack‎{数据对象：D={ai :|ai∈ElemS‎e t,i=1…n,n≥0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D,i=2,…n≥0}基本操作:init(list *L)操作结果：构造一个空‎的线性表L‎。

ListL‎e ngth‎(List *L)初始条件：线性表L已‎经存在操作结果：返回L中数‎据元素的个‎数。

GetEl‎e m(List L, int i, ElemT‎y pe *e)初始条件：线性表L已‎经存在，1≤i≤ListL‎e ngth‎(&L)操作结果：用e返回L‎中第i个数‎据元素的值‎。

Equal‎L ist(ElemT‎y pe *e1,ElemT‎y pe *e2)初始条件：数据元素e‎1,e2存在操作结果：以e1,e2中的姓‎名项作为判‎定e1,e2是否相‎等的依据。

Less_‎E quaL‎i st(ElemT‎y pe *e1,ElemT‎y pe *e2)初始条件：数据元素e‎1,e2存在操作结果：以e1,e2中的姓‎名项(为字符串)的≤来判定e1‎,e2是否有‎≤的关系。

实习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实验所用主要仪器：微型计算机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、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); /*显示学生记录内容*/}上机调试、运行源程序。

线性表的顺序存储及运算实现

2.2 线性表的顺序存储及运算实现2.2.1 顺序表线性表的顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表的各元素，用这种存储形式存储的线性表称其为顺序表。

因为内存中的地址空间是线性的，因此，用物理上的相邻实现数据元素之间的逻辑相邻关系是既简单，又自然的。

如图 2.1 所示。

设 a１的存储地址为Loc(a１)，每个数据元素占d个存储地址，则第i个数据元素的地址为：Loc(ai)=Loc(a１)+(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-线性结构的顺序存储

评定等级为：优秀、良好、中等、及格、不及格
教师签名： 2008 年月日
第2页共2页
2、参照课本，定义一个向量类模板，编写它的成员函数模板，对类模板加以实现；编写向量的并、交运算功能函数；编写主程序，对两个向量进行分别进行合并、交运算。
3、通过阅读课本栈类板代码，理解栈类操作特点；编写一个借助于栈，将二进制数转换为十进制数字串的程序；编写汉诺塔问题程序，理解函数的递归调用。
4、参照课本，定义一个顺序队列类模板，编写它的成员函数模板，对类模板加以实现；编写主程序，对队列进行各种基本操作，理解队列的操作特性。
五、实验总结（包括心得体会、问题回答及实验改进意见，可附页）
通过本次实验，基本上能够理解线性结构的顺序存储方式及各种不同线性结构的操作方式；顺序存储方式主要用于线性的数据结构，它把逻辑上相邻的数据元素存储在物理上相邻的存储单元里结点之间的关系由存储单元的邻接关系来体现。线性表、向量、栈、队列都属于线性结构的顺序存储，各结点的物理地址是相邻的，每一次插入、删除运算会引起相应结点物理地址的重新排列；栈的操作特点是先进后出，而队列的操作特点是先进先出。
2、对两个向量进行合并、交运算，结果如下：输入向量 La 的结点元素：1 2 3 4 5，输入 Lb 的结点元素：1 2 3 4 5 6，则两向量的交集为：1 2 3 4 5；并集为：1 2 3 4 5 6。
3、（1）将二进制数转换为十进制数字串的程序，结果如下：输入要转换的带符号整数 x:+3;则 x 转换成十进制数字串输出为：+3
Байду номын сангаас
第1页共2页
四、实验结果（包括程序或图表、结论陈述、数据记录及分析等，可附页）
1、对线性表进行插入、删除、定位等操作，结果如下：输入线性表元素：1 2 3 4 5，（1）选择插入，输入插入位置 2，插入值 9，则新的线性表为：1 2 9 3 4 5；（2）选择删除，输入删除元素序号 5，则新的线性表为：1 2 9 3 4；（3）选择取值，输入要求值元素序号 2，则屏幕输出：第２个元素的值为 9；（4）选择查找，输入要查找的元素值 9，则屏幕输出：要查找元素的序号为 2。

实验一线性表相关操作

实验一线性表的相关操作班级：13计科4班学号：20132599 姓名：周强飞实验目的：通过实验题的上机实践，帮助学生掌握线性表的基本操作在两种存储结构上算法的实现，特别是链表的操作和应用作为重点。

实验内容：实验1.1 顺序表的操作【问题描述】利用顺序存储方式实现下列功能：根据键盘输入数据建立一个线性表；然后根据屏幕菜单的选择，可以进行数据的插入、删除、查找以及输出线性表的长度，并在插入或删除线性表数据后，再输出线性表；最后在屏幕菜单中选择0，即可结束程序的运行。

【基本要求】试对顺序表编写实现上述操作的算法并上机编写代码，要求算法尽可能高效。

【提示及分析】当我们要在顺序表的第i个位置上插入一个元素时，必须先将先将一个线性表的第i个元素之后的所有元素依次后移一个位置，再把新元素插到该位置。

当要删除第i个元素时，也只需要将第i个元素之后的所有元素前移一个位置。

【算法及算法描述】//顺序表的存储结构#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量Typedef struct{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)}SqList;//初始化顺序表void InitList(SqList &L){ // 操作结果：构造一个空的顺序线性表LL.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}//顺序表的插入操作Status ListInsert(SqList &L,int i,ElemType e){ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1ElemType *newbase,*q,*p;if(i<1||i>L.length+1) // i值不合法return ERROR;if(L.length>=L.listsize) // 当前存储空间已满,增加分配{if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(ElemType)))) exit(OVERFLOW); // 存储分配失败L.elem=newbase; // 新基址L.listsize+=LIST_INCREMENT; // 增加存储容量}q=L.elem+i-1; // q为插入位置for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之后的元素右移*(p+1)=*p;*q=e; // 插入e++L.length; // 表长增1return OK;}//线性表的删除操作Status ListDelete(SqList &L,int i,ElemType &e){ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1ElemType *p,*q;if(i<1||i>L.length) // i值不合法return ERROR;p=L.elem+i-1; // p为被删除元素的位置e=*p; // 被删除元素的值赋给eq=L.elem+L.length-1; // 表尾元素的位置for(++p;p<=q;++p) // 被删除元素之后的元素左移*(p-1)=*p;L.length--; // 表长减1return OK;}//线性表的定位操作int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)){ // 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0) // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。

实验一 线性表的顺序存储及其操作

实验一 线性表的顺序存储结构

数据结构实验报告1线性表的顺序存储结构

实验1：线性表的顺序存储

实验报告 线性表的顺序存储结构

数据结构实验报告1线性表的顺序存储结构

实验一 线性表的顺序实现及操作

数据结构实验一 线性表的顺序存储及其操作 - 副本

线性表的顺序存储与基本操作

线性表的顺序存储实验

线性表的顺序存储结构实验报告样例

实习01_线性表的顺序存储和操作(有序表的合并)

线性表实验

顺序存储线性表的基本运算(实验报告)

线性表的顺序存储及运算实现

数据结构实验报告1-线性结构的顺序存储

实验一 线性表相关操作

实验一线性表的顺序存储及其操作

实验一线性表的顺序存储结构

实验报告线性表的顺序存储结构

实验一线性表的顺序实现及操作

数据结构实验一线性表的顺序存储及其操作 - 副本

实验一线性表相关操作