线性表的顺序储存结构
线性表的顺序存储结构是一种什么存储结构
线性表的顺序存储结构是一种什么存储结构线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的(注意,这句话只适用大部分线性表,而不是全部。
比如,循环链表逻辑层次上也是一种线性表(存储层次上属于链式存储),但是把最后一个数据元素的尾指针指向了首位结点)。
我们说“线性”和“非线性”,只在逻辑层次上讨论,而不考虑存储层次,所以双向链表和循环链表依旧是线性表。
在数据结构逻辑层次上细分,线性表可以分成通常线性表和受到限制线性表。
通常线性表也就是我们通常所说的“线性表”,可以民主自由的删掉或嵌入结点。
受到限制线性表主要包含栈和队列,受到限制则表示对结点的操作方式受限制。
线性表的逻辑结构简单,便于实现和操作。
因此,线性表这种数据结构在实际应用中是广泛采用的一种数据结构。
线性表就是一种常用的数据结构,以下了解线性表及其顺序存储,并对栈和队列及它们的顺序同时实现得出了详尽的设计叙述。
在实际应用中,线性表都是以栈、队列、字符串等特殊线性表的形式来使用的。
由于这些特殊线性表都具有各自的特性,因此,掌握这些特殊线性表的特性,对于数据运算的可靠性和提高操作效率都是至关重要的。
线性表就是一个线性结构,它就是一个所含n≥0个结点的非常有限序列,对于其中的结点,存有且仅有一个已经开始结点没前驱但存有一个后继结点,存有且仅有一个终端结点没后继但存有一个前驱结点,其它的结点都存有且仅有一个前驱和一个后继结点。
通常地,一个线性表可以则表示成一个线性序列:k1,k2,…,kn,其中k1就是已经开始结点,kn就是终端结点。
是一个数据元素的有序(次序)集1、子集中必存有唯一的一个“第一元素”;2、集合中必存在唯一的一个“最后元素” ;3、除最后一个元素之外,均存有唯一的后继(后件);4、除第一个元素之外,均有唯一的前驱(前件)。
由n(n≥0)个数据元素(结点)a1,a2,…,an共同组成的非常有限序列。
顺序存储结构的线性表
顺序存储结构的线性表线性表是最常用且比较简单的一种结构,它是由有限个数据元素组成的有序集合,每个数据元素有一个数据项或者含多个数据项。
例如26个英文字母表(A,B,……Z)是一个线性表,表中每一个数据元素由单个字母组成数据项。
又如表5.0.1也是一个线性表,表中含八个数据元素,每一个数据元素由n个选手在该项目的竞赛成绩组成。
线性表具有如下结构特征:(1)均匀性。
即同一线性表的名数据元素的数据类型一致且数据项相同。
(2)有序性。
表中数据元素之间的相对位置是线性的,即存在性一的“第一个”和“最后一个”数据元素。
除第一个和最后一个外,其他元素前面均只有一个数据元素(直接前趋)和后面均只有一个数据元素(直接后继)。
按照表中数据元素的存储方式分顺序存储结构和链式存储结构两类线性表。
1、序存储结构顺序存储结构是指用一组地址连续的存储单元依次线性表的元素,通常用数组实现。
数组的物理实现是一块连续的存储空间,它是按首址(表中第1个元素的地址)+位移来访问每一个元素。
设loc(a[i])-----A数组中元素i的内存地址(c<=i<=d);loc(b[i,j])----Bo数组中(i,j)元素的内存地址(c1<=I<=d1,c2<=j<=d2);loc(a[i])=loc(a[c])+(i-c)*la,la-------atype类型的长度;loc(b[i,j]=loc(b[c1,c2])+((d2-c2+1)*(i-c1)+(j-c2))*lb,lb----atype 类型长度;一维数组按照下标递增的顺序访问表中元素;a[c]->a[c+1]->……->a[d]二维数按照先行后列的顺序访问表中元素:b[c1,c2]->b[c1,c+1]->……b[c1,d2]->……>b[i-1,d2]->b[i,c2]->……->b[d1,d2-1]->b[d1,d2]在数组中,数据元素的下标间接反映了数据据元素的存储地址。
数据结构22 线性表的顺序存储结构
② 按顺序存储方式存储的线性表具有顺序存储结构, 一般称之为顺序表。换言之,在程序中采用定长的 一维数组,按顺序存储方式存储的线性表,被称为 顺序表.
线性表顺序存储结构的缺点 线性表容量不易改变,插入和删除结点较繁琐, 需移动元素调整一批结点的地址。
问题:由于线性表中元素的数目可能改变,因此 定义数组时要做如何的考虑呢? 定义大小合适的数组。
15
A的当前长度为 n, n m; 删除下标为 k 的结点 */
D1.[k合法?] IF (k 0 OR k n1 OR n0) THEN (PRINT“k不合法”. 终止本算法.).
D2.[删除] FOR ik1 TO n1 DO A[i1]A[i]. n n1. ▌
13
时间复杂性分析:
删除操作中与时间关系紧密的基本运算是什么? 元素移动
7
序号 元素
序号 元素
0 12
0 12
1 13
1 13
2 21
2 21
插入25 3 24
3 24
4 28
4 25
5 30
5 28
6 42 7 77
6 30 7 42
8 77
8
//采用ADL算法描述语言描述算法
算法 Insert(A , k , X) /* 设顺序表 A 的最大长度为 m,A
当前长度为 n(A[0], A[1], , A[n1]),且始终有 n m; 在下标为 k 的结点后插入值为 X 的结点 */
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一,它是一种有序的数据元素集合,其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式,其中顺序存储结构是最简单的一种,它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素,但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现,数组的长度应该大于等于线性表的长度,以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时,需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作:________在指定位置插入一个元素时,需要将插入位置之后的元素依次后移,给待插入的元素腾出位置。
●删除操作:________删除指定位置的元素时,需要将删除位置之后的元素依次前移,覆盖删除位置上的元素。
●修改操作:________修改指定位置的元素时,直接对该位置上的元素进行修改即可。
●查找操作:________根据指定的元素值,查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素,可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点:________可以快速地访问任意位置的元素,节省存储空间。
2.缺点:________插入和删除操作需要移动大量的元素,不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中,我们以顺序存储结构为基础,实现了线性表的增删改查操作,并进行了遍历操作。
通过实验,我们发现顺序存储结构在查询操作上有较好的性能,但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
线性表的顺序存储结构
∑
n +1 i =1
p i ( n i + 1)
1 不失一般性,若在线性表的任何位置插入元素都是等概率的,即 p i = 不失一般性,若在线性表的任何位置插入元素都是等概率的, , n + 1 上式可化简为: 上式可化简为: 1 n+1 n
Eis =
∑(n i +1) = 2 n +1
第二章 线性表
2.1 线性表的类型定义 2.2 线性表的顺序表示和实现
2.3 线性表的链式表示和实现
2.4 一元多项式的表示及相加
2.2 线性表的顺序表示和实现 线性表的顺序表示指的 是用一组地址连续的存储单 元依次存储线性表的数据元 素.
£2.2 线性表的顺序存储结构
(1)线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性 ) 表的数据元素.如下图2.1所示 所示: 表的数据元素.如下图 所示: 存储地址 b b+l … b+(i-1)l … b+(n-1)l b+nl … b+(maxlen-1)l 内存状态 a1 a2 … ai … an 空闲 数据元素在线性表中的位序 1 2 … i … n
// 为顺序表分配大小为 maxsize 的数组空间
if (!L.elem) exit(OVERFLOW); L.length = 0; L.listsize = maxsize; return OK; 算法时间复杂度 O(1) 时间复杂度: 时间复杂度 } // InitList_Sq
(4)线性表的插入和删除运算 ) 序号 数据元素 1 2 3 4 5 6 7 8 12 13 21 24 28 30 42 77 (a) 序号 数据元素 1 2 3 4 5 6 7 8 9 12 13 21 24 25 28 30 42 77 (b) 序号 数据元素 1 2 3 4 5 6 7 8 12 13 21 24 28 30 42 77 (a) 序号 数据元素 1 2 3 4 5 6 7 12 13 21 28 30 42 77
线性表的顺序存储结构
相邻两个数据元素的存 储地址之间的关系: 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 所示。
线性表的顺序存储结构
线性表的顺序存储结构线性表的顺序存储结构相关概念举个栗⼦:⼤学的时候,宿舍有⼀个同学,帮⼤家去图书馆占座。
他每次去图书馆,挑⼀个好地⼉,把他书包⾥的书,⼀本⼀本按座位放好,若书不够,再把⽔杯,⽔笔都⽤上,长长⼀排,九个座硬是被他占了。
1. 顺序存储的定义线性表的顺序存储结构,指的是⽤⼀段地址连续的存储单元依次存储线性表的数据元素。
⽰意图:2. 顺序存储⽅式线性表的顺序存储结构,其实就和刚才图书馆占座的例⼦⼀样,就是在内存中找了块地⼉,通过占位的形式,把⼀定内存空间给占了,然后把相同数据类型的数据元素依次存放在这块空地中。
既然线性表的每个数据元素的类型都相同,所以可以⽤⼀维数组来实现顺序存储结构,即把第⼀个数据元素存到数组下标为0的位置中,接着把线性表相邻的元素存储在数组中相邻的位置。
这⾥有⼏个关键的地⽅:1)为了建⽴⼀个线性表,要在内存中找⼀块地,这块地的第⼀位置就⾮常关键,他是存储空间的起始位置2)数组的长度就是这个最⼤存储容量3)线性表的当前长度3. 数据长度与线性表长度区别1)数组的长度是存放线性表的存储空间的长度,存储分配后这个量⼀般是不变的。
当然,⼀般⾼级语⾔是可以通过编程⼿段实现动态分配数组,不过这会带来性能上的损耗。
2)线性表的长度是线性表中数据元素的个数,随着线性表插⼊和删除操作的进⾏,这个量是变化的。
在任意时刻,线性表的长度应该⼩于等于数组的长度。
4. 地址计算⽅法数组是从0开始第⼀个下标的,于是线性表的第i个元素是要存储在数组下标为i-1的位置,即数据元素的序号和存放它的数组下标之间存在对应关系:存储器中的每个存储单元都有⾃⼰的编号,这个编号称为地址。
假设每个数据元素占⽤的都是c个存储单元,那么每个数据元素地址可通过公式计算得到: LOC(ai)=LOC(a1)+(i-1)*c它的存取时间性能为O(1)。
我们通常把具有这⼀特点的存储结构称为随机存取结构。
相关操作1. 获得元素操作(GetElem)获取元素的思路:1)考虑边界问题,顺序线性表L已存在(⾮空表),并且i必须在1<=i<=ListLength(L)范围内,否则抛出异常2)将数值下标为i-1的值返回即可C语⾔的实现如下:1// 获得元素操作2#define OK 13#define ERROR 04#define TRUE 15#define FALSE 06 typedef int Status;7/*Status是函数的类型,其值是函数结果状态代码,如OK等*/8/*初始条件:顺序线性表L已存在,1<=i<=ListLength(L)*/9/*操作结果:⽤e返回L中第i个数据元素的值*/1011 Status GetElem(SqList L, int i, ElemType *e)12 {13if (L.length == 0 || i < 1 || i > L.length)14return ERROR;15 *e = L.data[i-1];16return OK;17 }PHP的实现如下:1 <?php2class Seqlist{34private$seq_list; //顺序表5/**6 * 顺序表初始化7 *8 * @param mixed $seq_list9 * @return void10*/11public function __construct($seq_list=array()){12$this->seq_list = $seq_list;13 }1415/**16 * 返回顺序表元素个数17 *18 * @return int19*/20public function listLength(){21return count($this->seq_list);22 }2324/**25 * 返回顺序表中下标为i的元素值26 *27 * @param int i28 * @return mixed 如找到返回元素值,否则返回false29*/30public function getElem($i){31if ($this->seq_list && $i > 0 && $i <= $this->listLength()) {32return$this->seq_list[$i-1];33 }else{34return false;35 }36 }37 }2. 插⼊操作插⼊算法的思路:1)如果插⼊位置不合理(1<=i<=ListLength(L)+1),抛出异常说明:最好的情况就是,插⼊的位置为末尾:ListLength(L)+1(不是数组下标),这个时候不⽤移动元素,时间复杂度是O(1) 2)如果线性表长度⼤于等于数组长度,则抛出异常或动态增加容量3)从最后⼀个元素开始向前遍历到第i个位置,分别将它们都向后移动⼀个位置4)将要插⼊元素填⼊位置 i 处5)表长加1C语⾔的实现如下:1// 插⼊操作2#define OK 13#define ERROR 04#define TRUE 15#define FALSE6 typedef int Status;7/*初始条件:顺序线性表L已存在,1<=i<=ListLength(L)*/8/*操作结果:在L中第i个位置之前插⼊新的数据元素e,L的长度加1*/910 Status ListInsert(SqList *L, int i, ElemType e)11 {12int k;13if (L->length == MAXSIZE) /*顺序线性表已经满*/14return ERROR;15if (i < 1 || i > L->length + 1) /*当i不在范围内时*/16return ERROR;1718if (i <= L->length) /*若插⼊数据位置不在表尾*/19 {20for (k = L->length - 1; k >= i - 1; k--) /*将要插⼊位置后数据元素向后移动⼀位*/21 {22 L->data[k + 1] = L->data[k];23 }24 }25 L->data[i - 1] = e; /*将新元素插⼊*/26 L->length++;27return OK;28 }PHP的实现如下:1 <?php2class Seqlist{34private$seq_list; //顺序表5/**6 * 顺序表初始化7 *8 * @param mixed $seq_list9 * @return void10*/11public function __construct($seq_list=array()){12$this->seq_list = $seq_list;13 }1415/**16 * 在指定位置 i 插⼊⼀个新元素 $value17 *18 * @param int $i19 * @param mixed $value20 * @return bool 插⼊成功返回 true, 否则返回 false21*/22public function listInsert($i, $value){23// 三种情况:插⼊位置不合理24if ($i > $this->listLength()+1 || $i < 1) {25return false;26 }elseif ($i == $this->listLength()+1) {27// 最好的情况:元素插⼊到最后⼀个位置,不需要移动元素,时间复杂度为O(1)28$this->seq_list[$i-1] = $value;29 }else{30// 从 $i-1 到最后的元素位置向后移动⼀位31for ($k = $this->listLength()-1; $k >= $i-1; $k--) {32$this->seq_list[$k+1] = $this->seq_list[$k];33 }34$this->seq_list[$i-1] = $value;35 }3637return true;38 }39 }这⾥有⼀个疑问,因为前⾯我们提到了:在任意时刻,线性表的长度应该⼩于数组的长度。
线性表的顺序存储
顺序存储定义线性表的顺序存储结构,指的是用一段地址连续的存储单元依次存储线性表的数据元素。
线性表的一些常用操作1 创建线性表2 销毁线性表3 清空线性表4 将元素插入线性表5 将元素从线性表中删除6 获取线性表中某个位置的元素7 获取线性表的长度用如下一个柔性数组来实现顺序存储结构[cpp]1.<span style="font-size:18px">typedef struct tag_seqlist2.{3.int capicity; //最大容量4.int length; //目前该线性表的长度5. Tseqlistnod* node; //线性表存储数据6.} Tseqlist;</span>1 创建线性表[cpp]1.<span style="font-size:18px">SeqList* SeqList_Create(int capacity)2.{3.Tseqlist* ret = NULL;4.if (capacity >= 0)5.{6.ret = (Tseqlist*) malloc(sizeof(Tseqlist) + sizeof(Tseqlistnod) * capacity); //为柔性数组分配内存空间7.}</span>//如果分配成功则建立一个线性表i[cpp]1.<span style="font-size:18px">f (ret != NULL)2.{3.ret->capicity = capacity ;4.ret->length = 0;5.ret->node = (Tseqlistnod*)(ret + 1);6.}7.return ret;8.}</span>2 销毁线性表销毁线性表需要释放分配的内存[cpp]1.void SeqList_Destroy(SeqList* list)2.{3.free(list) ;4.list = NULL ;5.}3 清空线性表//在这里,只是把线性表的实际长度变为了0,但是没有对已经存储的数据进行清除[cpp]1.void SeqList_Clear(SeqList* list)2.{3. //创建一个新的线性表指针指向要清除的线性表的第一个元素4.Tseqlist* slist = (Tseqlist*) list;5.if (slist != NULL)6.{7.slist->length = 0;8.}9.10.}4获取线性表的长度[cpp]1.int SeqList_Length(SeqList* list)2.{3.Tseqlist* slist = (Tseqlist*) list;4.int ret = -1;5.if (slist != NULL)6.{7.ret = slist->length;8.}9.return ret;10.}5获取线性表的容量[cpp]1.int SeqList_Capacity(SeqList* list)2.{3.Tseqlist* slist = (Tseqlist*) list;4.int ret = -1;5.if (slist != NULL)6.{7.ret = slist->capicity;8.}9.return ret;10.11.12.13.}4 将元素插入线性表插入元素算法1 判断线性表是否合法2 判断插入位置是否合法3 把最后一个元素到插入位置的元素后移一个位置4 将新元素插入5 线性表长度加1[cpp]1.<span style="font-size:18px">int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)2.{3.Tseqlist* slist = (Tseqlist*) list;4.int ret = -1;5.int i = 0;6. //判断线性表是否合法7.ret = (slist != NULL) && (slist->capicity >= slist->length + 1) && (pos >= 0);8.if (ret)9. {10. //判断插入位置是否合法11.if (pos >= slist->length)12.{13.pos = slist->length;14.}15.for ( i = slist->length; i > pos; i--)16.{17.slist->node[i] = slist->node[i-1];18.}19.slist->node[i] = (Tseqlistnod) node;20.slist->length++;21. }22.return ret;23.}</span>6.获取线性表中某个位置的元素[cpp]1.SeqListNode* SeqList_Get(SeqList* list, int pos)2.{3.Tseqlist* slist = (Tseqlist*) list;4.SeqListNode* ret = NULL;5.if ((slist != NULL) && (pos >= 0))6.{7.if (slist->length >= pos)8.{9.ret = (SeqListNode*) slist->node[pos];10.}11.}12.return ret;13.}将元素从线性表中删除[cpp]1.<span style="font-size:18px">删除元素算法2. 1 判断线性表是否合法3. 2 判断删除位置是否合法4. 3 将元素取出5. 4 将删除位置后的元素分别向前移动一个位置6. 5 线性表长度减1</span>7.<span style="font-size:18px">SeqListNode* SeqList_Delete(SeqList* list, int pos)8.{9.Tseqlist* slist = (Tseqlist*) list;10.SeqListNode* ret = SeqList_Get(list, pos);11.int i = 0;12.if (slist != NULL)13. {14.for (i = pos+1; i < slist->length; i++)15. {16. slist->node[i-1] = slist->node[i];17. }18. slist->length--;19. }20.return ret;21.}22.</span>。
第2章线性表第2讲-线性表的顺序存储结构
a1 a2
e 插入完成
1ห้องสมุดไป่ตู้/23
插入算法如下:
15/23
对于本算法来说,元素移动的次数不仅与表长L->length=n
有关,而且与插入位置i有关:
当i=n+1时,移动次数为0; 当i=1时,移动次数为n,达到最大值。
其中data成员存放元素,length成员存放线性表的实际 长度。
说明:注意逻辑位序和物理位序相差1。
3/23
1、建立顺序表
a[0..n-1] 顺序表L ─ 整体创建顺序表。
传递顺序表 指针
4/23
算法参数说明
顺序表指针的含义
SqList *L; L=(SqList *)malloc(sizeof(SqList)); 顺序表的空间
算法最好时间复杂度为O(1)
算法最坏时间复杂度为O(n)
16/23
平均情况分析:
a1 a2 … ai ai+1 … an
在线性表L中共有n+1个可以插入元素的地方
1 在插入元素ai时,若为等概率情况,则pi = n 1
此时需要将ai~an的元素均后移一个位置,共移动n-i+1个 元素。 所以在长度为n的线性表中插入一个元素时所需移动元 素的平均次数为:
20/23
平均情况分析: a1 a2 … ai ai+1 … an
在线性表L中共有n个可以删除元素的地方
在删除元素ai时,若为等概率情况,则pi = n 此时需要将ai+1~an的元素均前移一个位置,共移动 n-(i+1)+1=n-i个元素。 所以在长度为n的线性表中删除一个元素时所需移动元 素的平均次数为:
线性表的顺序存储结构
线性表的顺序存储结构顺序存储结构封装需要三个属性:1.存储空间的起始位置,数组data,它的存储位置就是线性表存储空间的存储位置2.线性表的最⼤存储容量,数组的长度MaxSize3.线性表的当前长度:length当前长度与数组长度区别:数组长度就是该顺序表的总长度,如果不进⾏扩容的话,就是不变的。
⽽当前长度在数据的变化中,就会发⽣相应的变化。
PS:线性表是正常的读数⽅法,⼀下标1开始的。
存储时间性能:O(1)性能:存取以及读取不管是在哪个位置,其时间复杂度都是O(1),⽽在插⼊还是删除其时间复杂度都是O(n)结论:⽐较适合数据的存取⽽不适合经常性增删的情况。
顺序存储结构的优缺点1.优点:- ⽆须为表⽰表中元素之间的逻辑关系⽽增加额外的存储空间- 可以快速的存取表中任意位置的元素。
2.缺点:- 插⼊以及删除操作需要移动⼤量的元素。
- 当线性表长度变化较⼤时,难以确定存储空间的容量。
- 容易造成存储空间的碎⽚。
具体代码的实现:// 头⽂件部分,进⾏常量参数初始化#define LIST_INT_SIZE 10 //线性顺序表初始动态分配内存⼤⼩#define INCREAMENT 2 //线性表扩容⼀次性增量#define OK 1#define ERROW -1#define OVERFLOW -2#include<stdio.h>#include <stdlib.h>//malloc函数包含在其中typedef int Elemtype; //线性表的数据类型typedef int Status; // 状态数据类型// 顺序表存储结构定义typedef struct {Elemtype *elem; //定义线性表内数据元素的数据类型int length; //表当前长度int listsize; //表当前空间容量⼤⼩} SqList; //表名// 初始化⼀个顺序表Status InitList(SqList &L) {L.elem = (Elemtype *)malloc(LIST_INT_SIZE * sizeof(Elemtype)) ;//动态分配内存,分配后可以将l.elem作为数组使⽤if(!L.elem) { //对内存分配的结果判断exit(OVERFLOW);} //这个地⽅可以去查⼀下资料// if(L.elem == NULL) {// printf("分配内存失败")// exit(1);// }//关于内存分配结果的判断,⼜该如何去进⾏判断//这种⽅法进⾏判断⼜是否正确L.length = 0; //对表长初始化归0L.listsize = LIST_INT_SIZE;return OK;}// 创建⼀个顺序表Status CreateList(SqList &L) {int i;InitList(L);printf("请输⼊元素个数:\n");scanf("%d",&L.length);printf("\n请输⼊您要输⼊的元素\n");for(i=0; i<L.length; i++) {scanf("%d",&L.elem[i]);}printf("顺序表已创建成功,打印表请选择功能 *3\n");return OK;}// 顺序表的遍历Status TraverseList(SqList &L) {int i;printf("表中元素为:\n");for(i=0; i<L.length; i++)printf("%d ",L.elem[i]);printf("\n\n顺序表输出完毕!\n");}//顺序表的插⼊// 表L 位置 i Elemtype 要插⼊的元素Status InsertList(SqList &L,int i,Elemtype e) {int* newbase;int j;if(i < 1 ||i > L.length+1) { // 判断所要插⼊的位置return ERROW;}if(L.length>=L.listsize) {newbase = (Elemtype*)realloc(L.elem,(L.listsize+INCREAMENT)*sizeof(Elemtype)); if(!newbase) {exit(OVERFLOW);}L.elem = newbase;L.listsize += INCREAMENT;}for(j = L.length-1; j>i-1; j--) {L.elem[j+1]=L.elem[j];}L.elem[i-1] = e;L.length++;return OK;}//删除指定位置元素并返回出来Status deleteListElem(SqList &L,int i) {Elemtype e;int j;if(i<1 || i>L.length) {return ERROW;}e = L.elem[i-1];for(j = i-1 ; j<=L.length; j++) {L.elem[j] = L.elem[j+1];}L.length--;return e;}//判断⼀个值是不是线性表中的元素并返回第⼏个元素Status ifElemExit(SqList &L,Elemtype e) {int i = 0;for(; i<L.length; i++) {if(e==L.elem[i])break;}if(i>=L.length) {return ERROW;} else {return i;}}//输出⼀个位置的数据元素Status GetElem(SqList &L,int i) {if(i<1||i>L.length) {return ERROW;}return L.elem[i-1];}//根据元素的值来进⾏删除Status deleteElemByR(SqList &L,Elemtype e) {int i = 0;i = ifElemExit(L,e);if(i==-1) {printf("该值不再线性表中:");return ERROW;} else {deleteListElem(L,i+1);printf("删除成功!删除的是位置为%d,值为%d",i,e);return OK;}}//将线性表进⾏递减排序操作Status SortByMao(SqList &L) {Elemtype e;for(int j=0; j<L.length; j++) {for(int i=0; i<L.length-i-j; i++) {if(L.elem[i]<L.elem[i+1]) {e = L.elem[i];L.elem[i] = L.elem[i+1];L.elem[i+1]=e;}}}}void UnionTwo(SqList &la,SqList &lb) {int la_length = la.length;int lb_length = lb.length;for(int i=1;i<=lb.length;i++){Elemtype e= GetElem(Lb,i);if(ifElemExit(La,e)==-1){InsertList(La,la_length,e);la_length++;la.length++;}}}/***主提⽰输出函数***/void printlin() {printf("\n");printf("\t\t\t线性顺序表基本操作学习系统\n");printf("\t\t\t ***主菜单***\n\n");printf("\t\t\t *1 创建⼀个顺序表\n");printf("\t\t\t *2 定位输出⼀个数据元素\n");printf("\t\t\t *3 输出顺序表中所有元素\n");printf("\t\t\t *4 定位插⼊⼀个数据元素\n");printf("\t\t\t *5 定位删除⼀个数据元素\n");printf("\t\t\t *6 定值删除⼀个数据元素\n");printf("\t\t\t *7 清空顺序表\n");printf("\t\t\t *8 销毁顺序表\n");printf("\t\t\t *9 对表内数据元素进⾏⾮递减排序\n");printf("\t\t\t *0 结束程序\n");}//清空线性表void clearList(SqList &L) {if(L.length!=0) {L.length = 0; //由于顺序表的⽤得是与数组⼀样的内存空间,//所以标的清空只要将表长归零即可,由此可见,表长是线性表⾮常重要的部分 }}//销毁线性表void destoryList(SqList &L) {if(L.length!=0) {free(L.elem);L.elem = NULL;//使⽤free后就需要对元素进⾏赋空操作}}int main() {int i,j,k;Elemtype e;SqList L;L.length=0;printf("编写此程序⽬的是⾃我学习线性表顺序表\n");printlin();while(1) {int t;scanf("%d",&t);if(t!=0)if(t==1||L.length!=0) {switch(t) {case 1:if(L.length!=0) {printf("顺序表已存在,是否重新创建顺序表?\n");printf("*1 是 *2 否\n");scanf("%d",&i);if(i==1)CreateList(L);} elseCreateList(L);break;case 0:break;case 3:TraverseList(L);break;case 7:clearList(L);printf("清空完毕,返回主菜单\n\n");break;case 4:printf("输⼊要插⼊的位置\n");scanf("%d",&i);printf("请输⼊要插⼊的数据\n");scanf("%d",&j);k=InsertList(L,i,j);if(k==-1) {printf("插⼊位置不合法,插⼊数据操作失败!\n\n");} elseprintf("插⼊数据成功\n\n");break;case 5:printf("请输⼊要删除数据位置\n");scanf("%d",&i);e = deleteListElem(L,i);printf("删除掉的元素是第%d个位置,它的值是%d",i,e); break;case 2:printf("请输⼊要需要得到数据位置:");scanf("%d",&i);e = GetElem(L,i);printf("第%d个位置上的元素值为:%d",i,e);break;case 6:printf("请输⼊需要删除的值:");scanf("%d",&e);deleteElemByR(L,e);break;case 8:destoryList(L);printf("销毁成功!");break;case 9:SortByMao(L);break;default: {printf("输⼊有误,可以重新选择,退出按0!\n");}}} elseprintf("顺序表未创建或已清空或销毁,请先创建顺序表\n"); system("pause");system("CLS");printlin();if(t==0)break;}return 0;}。
线性表之顺序存储结构
线性表之顺序存储结构数据结构和算法是程序设计的灵魂。
坦诚的说,我在这方面是弱的可以。
虽然工作这么多年了,因为种种借口,这块知识一直是我的痛处。
曾经在面试时大言不惭的说,这些知识在工作中很少用到,所以当年学习的东西早就还给学校了。
其实不然,失去了灵魂的程序员如我,总是要逆袭的。
所以以后的学习中会有一些如孩童笔记般的文章出现在我的blog中,请大师们不要嘲笑,要提携。
定义线性表可以说是最简单的数据结构,它的描述为:n个数据元素的有限序列。
记为:L=(a1,a2,...,an)按照存储结构它又可以分为顺序存储结构和链式存储结构。
而其中线性表的顺序存储结构是最简单最常用的数据结构:用一段连续地址依次存储表中的数据元素。
看到这里,我们会自然的联想到C语言中的数组。
下面我要实现的是线性表中的元素为整型的顺序存储结构,及它的主要运算:增删查。
先来简单的定义一下这个线性表的顺序存储结构:#define MAXLENGTH 20struct sequencelist{int data[MAXLENGTH];int length;};其中data数组为这个线性表的主要部分,数据元素就存在于此数组中,而对这个线性表的操作都是基于这个数组。
length是这个线性表的一个属性,表示这个线性表包含元素的个数。
增:线性表的插入操作对线性表的插入就是对data数组的插入,然后将其length增加。
//insert oprationint insert(struct sequencelist *list,int index,int element){int length = list->length;if(length ==0 || index < 0 || index > length || length >= MAXLENGTH) return ERROR;list->data[index] = element;for(int i = length - 1;i>index;i--){list->data[i+1] = list->data[i];}list->length++;return OK;}删:线性表的删除操作类似增的相反操作。
线性表的顺序存储结构中,逻辑上相邻
线性表的顺序存储结构中,逻辑上相邻顺序存储结构的线性表称作顺序表。
在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表的顺序存储结构。
顺序存储结构是存储结构类型中的一种,该结构是把逻辑上相邻的结点存储在物理位置上相邻的存储单元中,结点之间的逻辑关系由存储单元的邻接关系来体现。
实现顺序存储结构的方法是使用数组。
数组把线性表的数据元素存储在一块连续地址空间的内存单元中,这样线性表中逻辑上相邻的数据元素在物理存储地址上也相邻。
数据元素间的逻辑上的前驱、后继逻辑关系就表现在数据元素的存储单元的物理前后位置上。
顺序存储结构的主要优点是节省存储空间,因为分配给数据的存储单元全用存放结点的数据(不考虑c/c++语言中数组需指定大小的情况),结点之间的逻辑关系没有占用额外的存储空间。
采用这种方法时,可实现对结点的随机存取,即每一个结点对应一个序号,由该序号可以直接计算出来结点的存储地址。
但顺序存储方法的主要缺点是不便于修改,对结点的插入、删除运算时,可能要移动一系列的结点。
2.2 线性表的顺序存储结构
(2)在访问线性表时,可以利用上述给出 的数学公式,快速地计算出任何一个数据元素的存 储地址。因此,我们可以粗略地认为,访问每个数 据元素所花费的时间相等。这种存取元素的方法被 称为随机存取法,使用这种存取方法的存储结构被 称为随机存储结构。 在C语言中,实现线性表的顺序存储结构的 类型定义 #define LIST_MAX_LENGTH 100 // 线性表的最大长度 typedef struct { EntryType *item; //指向存放线性表 中数据元素的基地址 int length; //线性表的当前长度 }SQ_LIST;
//数组中第i-1的单元存储着线性表中第i个数据元素
return OK;
}
7. 在线性表L中检索值为e的数据元素
int LocateELem(SQ_LIST L,EntryType e) { for (i=0;i< L.length;i++) if (L.item[i]==e) return i+1;
插入算法的分析
假设线性表中含有n个数据元素,在进行 插入操作时,若假定在n+1个位置上插入元素的 可能性均等,则平均移动元素的个数为:
删除算法的分析 在进行删除操作时,若假定删除每个元素的可能性 均等,则平均移动元素的个数为:
时,平均需要移动大约一半的数据元素。当线性表的数据元 素量较大,并且经常要对其做插入或删除操作时,这一点需 要值得考虑。
9. 将线性表L中第i个数据元素删除 int ListDelete(SQ_LIST *L,int i,EntryType *e) { if (IsEmpty(L)) return ERROR; //检测线性 表是否空 if (i<1||i>L->length) return ERROR; //检查i 值是否合理 *e=L->item[i-1]; //将欲删除的数据元素内 容保留在e所指示的存储单元中 for ( j=i;j<=L->length-1;j++) // 将线性表第 i+1个元素之后的所有元素向前移动 L->item[ j-1]=L->item[ j]; L->length--; return OK; }
线性表及其顺序存储结构
线性表及其顺序存储结构清点人数,组织教学。
复习:IP 地址与域名系统授新:一、数据结构的主要研究内容数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
数据结构作为计算机的一门学科,主要研究和讨论以下三个方面的问题:1.数据集合中各数据元素之间所固有的逻辑关系,即数据的逻辑结构。
数据的逻辑结构是从逻辑关系上描述数据,与数据的存储无关,是独立于计算机的。
数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。
数据的逻辑结构包含:(1)表示数据元素的信息;(2)表示各数据元素之间的前后件关系。
2.各数据元素在计算机中存储关系,即数据的存储结构。
数据的存储结构有顺序、链接、索引等。
数据的存储结构是逻辑结构用计算机语言的实现(亦称为映象),它依赖于计算机语言。
对机器语言而言,存储结构是具体的。
一般只在高级语言的层次上讨论存储结构。
对各种数据结构进行的运算。
3.数据的运算定义在数据的逻辑结构上,每种逻辑结构都有一个运算的集合。
最常用的检索、插入、删除、更新、排序等运算实际上只是在抽象的数据上所施加的一系列抽象的操作。
所谓抽象的操作,是指只知道这些操作是“做什么”,而无须考虑“如何做”。
只有确定了存储结构之后,才考虑如何具体实现这些运算。
二、数据结构基本概念1、数据数据是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据是信息的载体,它能够被计算机识别、存储和加工处理,是计算机程序加工的“原料”。
随着计算机应用领域的扩大,数据可以分为两大类:一类是整数、实数等数值数据;另一类是图形、图像、声音、文 字等非数值数据。
这里要注意数据并不等于数字,数字是隶属于数据的。
2、 数据元素与数据项数据元素也称为元素、结点、顶点或记录,是数据的基本单位,在计算机程序中通常作为 一个整体进行考虑和处理。
一个数据元素可由若干个数据项组成,数据项是数据的最小单位。
数据元素具有广泛的含义,一般来说,现实世界中客观存在的一切个体都可以是数据元素。
线性表的顺序存储结构--数组(顺序表)、栈、队列
线性表的顺序存储结构--数组(顺序表)、栈、队列
线性表
顺序存储结构--数组(顺序表)
优点: ①可以随机存取
②空间利⽤率⾼
③结构简单
缺点:①需要⼀⽚连续的存储空间
②插⼊删除会引起⼤量的元素移动,操作不便
③预分配空间可能不⾜也可能浪费
解决⽅法:限定⼀定条件下线性表--插⼊删除在固定的位置--栈和队列
栈[先进后出,后进先出]
特征:①在⼀端(栈顶)进⾏插⼊、删除操作
②⼀般⽤来容纳已经接受但不处理的信息
栈的实现:增设⼀指针top指向当前栈顶位置
栈的应⽤:①⼗进制转⼋进制
②矩阵连乘计算量
③⽅法的调⽤过程:a,保存返回地址b.局部变量值得保存
队列[先进先出]
特征:①总是在⼀端插⼊元素,另⼀端删除元素
队列的实现:
增设第⼀个元素的前⾯的指针front
增设指向最后⼀个元素的指针rear‘
循环队列:通过模运算,成为循环队列
队空:front==rear
队满:(rear+1)%m==front(正常情况下,应是front==rear,但是front==rear已经是判断队空的条件,⽆法区分队空还是队满,需要再去使⽤变量标识,在操作时需要判断造成时间上的浪费,不如浪费⼀个空间,即若rear+1==front时,⼜因为是循环数组所以(rear+1)%m==front,有种⽤空间换取时间的感觉)
队满时的元素个数:m-1
计算元素个数:(rear-front+m)%m(+-⼀个m时不改变求余的,但是如果rear-front<0时,可以通过+m得到余数)。
2.2 线性表及其顺序存储结构
一般情况下,要删除第i (1≤i≤n )个 元素,需要从第i+1 个元素开始,直到第n 个元素之间,共有n-i 个元素依次向前移动 了一个位置。删除结束后,顺序表的长度就 缩小了1。在平均情况下,要在顺序表中删 除一个元素,需要移动表中一半的元素。
在顺序表L中删除第i个元素并用x 返回其 值的算法DeleteList描述如下:
void DeleteList(SeqList *L,int i, ElemType *x) {
int j,n=L->length; if(i<1||i>n) {
printf(" \n i值不合法!"); exit(1); }
在顺序表中删除一个元素,平均约移动表 中一半的元素。平均时间复杂度为O(n)。最 好的情况是当i=n,即在表尾删除时,不需要 移动元素;最坏的情况是当i=1,即在表头删 除时,需要移动表中n-1个元素。
栈和队列是两种特殊的线性表,它们的逻 辑结构和线性表相同,只是运算规则较线 性表有更多的限制 。
在表中插入一个元素,平均要移动一半的元 素,平均时间复杂度为O(n)。最好的情况是
在表尾插入时,不需要移动元素;最坏的情况 是在表头插入时,需要移动表中n个元素。
假设,在长度为n的顺序表的任意位置i (1≤i≤n)删除该位置元素的概率为qi=1/n, 所需移动元素的次数为n-i,那么,每删除一 个元素,所需移动元素的次数的平均值为: Ade = (n-1)/2
ElemType GetElem(SeqList *L,int i) {/*取表中第i个数据元素*/
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解线性表的顺序存储结构,并通过编程实现其基本操作,包括创建线性表、插入元素、删除元素、查找元素以及输出线性表等。
通过实际操作,掌握顺序存储结构的特点和优势,同时也了解其在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为C++,编译环境为Visual Studio 2019。
三、实验原理1、线性表的定义线性表是由 n(n≥0)个数据元素组成的有限序列。
在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,通过数组来实现。
2、顺序存储结构的特点存储密度高,无需额外的指针来表示元素之间的关系。
可以随机访问表中的任意元素,时间复杂度为 O(1)。
插入和删除操作需要移动大量元素,平均时间复杂度为 O(n)。
四、实验内容及步骤1、定义线性表的数据结构```cppdefine MAX_SIZE 100 //定义线性表的最大长度typedef struct {int dataMAX_SIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cppvoid InitList(SeqList L) {L>length = 0; //初始时线性表长度为 0}```3、判断线性表是否为空```cppbool ListEmpty(SeqList L) {return (Llength == 0);}```4、求线性表的长度```cppint ListLength(SeqList L) {return Llength;}```5、按位查找操作```cppint GetElem(SeqList L, int i) {if (i < 1 || i > Llength) {printf("查找位置不合法!\n");return -1;}return Ldatai 1;}```6、按值查找操作```cppint LocateElem(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0; //未找到返回 0}```7、插入操作```cppbool ListInsert(SeqList L, int i, int e) {if (L>length == MAX_SIZE) {//表已满printf("表已满,无法插入!\n");return false;}if (i < 1 || i > L>length + 1) {//插入位置不合法printf("插入位置不合法!\n");return false;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;//表长加 1return true;}```8、删除操作```cppbool ListDelete(SeqList L, int i) {if (L>length == 0) {//表为空printf("表为空,无法删除!\n");return false;}if (i < 1 || i > L>length) {//删除位置不合法printf("删除位置不合法!\n");return false;}for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length; //表长减 1return true;}```9、输出线性表```cppvoid PrintList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```10、测试用例```cppint main(){SeqList L;InitList(&L);ListInsert(&L, 1, 10);ListInsert(&L, 2, 20);ListInsert(&L, 3, 30);ListInsert(&L, 4, 40);ListInsert(&L, 5, 50);printf("线性表的长度为:%d\n", ListLength(L));printf("查找第 3 个元素:%d\n", GetElem(L, 3));int loc = LocateElem(L, 30);if (loc) {printf("元素 30 的位置为:%d\n", loc);} else {printf("未找到元素 30\n");}ListDelete(&L, 3);printf("删除第 3 个元素后的线性表:");PrintList(L);return 0;}```五、实验结果及分析1、实验结果成功创建并初始化了线性表。
2-1-线性表的顺序存储结构
线性表的基本操作Status List_Init(SqListPtr L);void List_Destory(SqListPtr L);void List_Clear(SqListPtr L);bool List_Empty(SqListPtr L);int List_Size(SqListPtr L);Status List_Retrival(SqListPtr L, int pos, ElemType*elem);Status List_Locate(SqListPtr L, ElemType elem, int*pos);Status List_Insert(SqListPtr L, int pos, ElemType elem);Status List_delete(SqListPtr L, int pos);Status List_Prior(SqListPtr L, int pos, ElemType* elem);Status List_Next(SqListPtr L, int pos, ElemType*elem);合并线性表算法Status List_Union(SqListPtr La, SqListPtr Lb){ElemType elem; /* 存放从Lb中取出的元素*/Status status; /*状态代码*/int i, j, len= List_Size(Lb); /*len存放Lb的元素个数*/for(i=1; i<=len; i++){List_Retrieve(Lb, i, &elem); /*取出Lb中第i个数据元素*/status = List_Locate(La,elem,&j); /*判它是否在La中*/if(status!= success){ /*如果不在*/status = List_Insert(La,1,elem); /*插入到第一个位置*/if(status!= success) break; /*插入失败则退出*/}}return status;}目录C O N T E N T S线性表的顺序存储结构用一组地址连续的存储单元依次存放线性表中的数据元素数据元素a i 的存储位置为:LOC(a i ) = LOC(a 1) + (i-1)×d 以“存储位置相邻”表示有序对<a i-1,a i >即:LOC(a i ) = LOC(a i-1) +d一个数据元素所占存储单元↑↑基地址s s s+d s+(i-1)d s+(n-1)d讨论:题目:如果线性表有n个元素L=(a1,a2,…,an),如何用某种程序设计语言,比如C语言存储这n个数据并实现建立线性表、查找线性表的某个数据,在某个位置插入或者删除一个数据等基本操作?这些基本操作实现之后,更复杂的操作,比如合并线性表是不是就能够通过直接调用这些基本操作实现?并说明理由。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
重庆交通大学《算法与数据结构》课程实验报告班级:计算机科学与技术2014级2班实验项目名称:线性表的顺序储存结构实验项目性质:实验所属课程:算法与数据结构实验室(中心): B01407指导教师:鲁云平实验完成时间:2016 年 3 月21 日一、实验目的1、实现线性表的顺序存储结构2、熟悉C++程序的基本结构,掌握程序中的头文件、实现文件和主文件之间的相互关系及各自的作用3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现二、实验内容及要求对顺序存储的线性表进行一些基本操作。
主要包括:(1)插入:操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入(2)删除:操作方式可分为删除指定元素、删除指定位置的元素等,尝试实现逻辑删除操作。
(3)显示数据(4)查找:查询指定的元素(可根据某个数据成员完成查询操作)(5)定位操作:定位指定元素的序号(6)更新:修改指定元素的数据(7)数据文件的读写操作等。
其它操作可根据具体需要自行补充。
要求线性表采用类的定义,数据对象的类型自行定义。
三、实验设备及软件VC6.0四、设计方案㈠题目线性表的顺序存储结构㈡设计的主要思路1、新建SeqList.h头文件,定义SeqList模板类2、设计类数据成员,包括:T *data(用于存放数组)、int maxSize(最大可容表项的项数)、int last(当前已存表项的最后位置)3、设计类成员函数,主要包括:int search(T& x)const;//搜索x在表中位置,函数返回表项序号int Locate(int i)const;//定位第i个表项,函数返回表项序号bool getData(int i,T& x)const;//去第i个表项的值void setData(int i,T& x)//用x修改第i个表项的值bool Insert(int i,T& x);//插入x在第i个表项之后bool Remove(int i,T& x); //删除第i个表项,通过x返回表项的值bool IsEmpty();//判表空否,空则返回true;否则返回falsebool IsFull();//判表满否,满则返回true;否则返回falsevoid input(); //输入void output();//输出void ofile();/存储在文件中void ifile();//读取文件并显示㈢主要功能1、建立新表2、对表进行插入(指定元素前、后以及指定位置插入)、删除(指定元素删除及指定位置删除)、修改等操作3、显示当前操作表的全部内容4、存储在文件中5、从文件中读取表五、主要代码㈠SeqList.h中的主要代码:1、类成员声明部分:protected:T *data; //存放数组int maxSize; //最大可容纳表项的项数int last; //当前已存表项的最后位置(从0开始)void reSize(int newSize); //改变data数组空间大小public:SeqList(int sz = defaultSize); //构造函数SeqList(SeqList<T>& L); //复制构造函数~SeqList(){delete[] data;} //析构函数int Size()const{return maxSize;} //计算表最大可容纳表项个数int Length()const{return last+1;} //计算表长度int search(T& x)const; //搜索x 在表中位置,函数返回表项序号int Locate(int i)const; //定位第i个表项,函数返回表项序号bool getData(int i,T& x)const //去第i 个表项的值{if(i>0&&i<=last+1){x=data[i-1];return true;}else return false;}void setData(int i,T& x) //用x修改第i个表项的值{if(i>0&&i<=last+1) data[i-1]=x;}bool Insert(int i,T& x); //插入x 在第i个表项之后bool Remove(int i,T& x); //删除第i个表项,通过x返回表项的值bool IsEmpty(){return (last == -1)?true:false;} //判表空否,空则返回true;否则返回falsebool IsFull(){return (last == maxSize-1)?true:false;} //判表满否,满则返回true;否则返回falsevoid input(); //输入void output(); //输出SeqList<T>operator=(SeqList<T>& L); //表整体赋值void ofile(); //存储在文件中void ifile(); //读取文件并显示2、部分成员函数//搜索函数:在表中顺序搜索与给定值x匹配的表项,找到则函数返回该表项是第几个元素//否则函数返回0,表示搜索失败template<class T>int SeqList<T>::search(T& x)const{for(int i = 0;i <= last; i++)if(data[i] == x) return i+1; //顺序搜索return 0; //搜索失败}//定位函数:template<class T>int SeqList<T>::Locate(int i)const{if(i >= i&&i <= last+1) return i ;else return 0;}//插入函数//将新元素x插入到表中第i(i>=0&&i<=last+1)个表项之后,函数返回插入成功的信息,若//插入成功,则返回true;否则返回false.i=0是虚拟的,实际上是插入的第1个元素位置template<class T>bool SeqList<T>::Insert(int i,T& x){if(last == maxSize-1) return false; //表满,不能插入if(i<0 || i>last+1) return false; //参数i不合理,不能插入for(int j = last ;j >=i;j--) //依次后移,空出第i号位置data[j+1] = data[j];data[i] = x; //插入last++; //最后位置+1return true; //插入成功}//删除函数//从表中删除第i个表项,通过应用型参数x返回删除的元素值,函数//返回删除成功的信息,如删除成功则返回true,否则返回false template<class T>bool SeqList<T>::Remove(int i,T& x){if(last == -1 )return false;if(i<1 || i>last+1)return false;x = data[i-1];for(int j = i;j <= last;j++)data[j-1] = data[j];last--;return true;}//输入函数//从标准输入逐个数据输入,建立顺序表template<class T>void SeqList<T>::input(){cout<<"开始建立顺序表,请输入表中的元素个数:";while(1){cin>>last;if(last<=maxSize-1) break;cout<<"表元素个数有误,范围不能超过"<<maxSize<<":";}for(int i = 0;i < last;i++){cout<<"#"<<i+1<<":";cin>>data[i];}}//输出函数template<class T>void SeqList<T>::output(){cout<<"顺序表当前元素最后的位置为:"<<last<<endl;for(int i = 0;i < last;i++)cout<<"#"<<i+1<<":"<<data[i]<<endl;}//存储在文件中template<class T>void SeqList<T>::ofile(){ofstream f1("Test1.txt",ios::out);if(!f1){cout<<"存储文件失败!"<<endl;exit(1);}for(int i = 1;i < last+1;i++)f1.write((char*) &data[i-1],sizeof(data[i-1]));cout<<"存储成功!"<<endl;f1.close();}//读取文件并打印出文件内容template<class T>void SeqList<T>::ifile(){ifstream f2("Test1.txt",ios::binary);if(!f2){cout<<"打开文件失败!"<<endl;exit(1);}cout<<"文件内容如下:"<<endl;for(int i = 1;!f2.eof();i++){f2.read((char*)&data[i-1],sizeof(data[i-1]));}for(int j = 1;j < i-1;j++)cout<<"#"<<j<<":"<<data[j-1]<<endl;f2.close();}㈡测试主函数1、插入功能,对不同位置的插入通过修改函数Insert(int i,x)第一形参实现,位置可通过成员函数search(x)确定case 3:{//指定元素后插入int x,y;cout<<"请输入指定元素:";cin>>x;cout<<"请输入要插入的元素:";cin>>y;Seq.Insert(Seq.search(x),y);break;}case 4:{//指定位置插入int i,x;cout<<"请输入插入的位置:";cin>>i;cout<<"请输入要插入的元素:";cin>>x;Seq.Insert(i,x);break;}case 5:{//按内容删除指定元素int i,x;cout<<"请输入要删除的元素内容:";cin>>x;i = Seq.search(x); //指定元素位置if(Seq.Remove(i,x)) cout<<"删除成功!"<<endl;else cout<<"删除失败!"<<endl;break;}2、删除功能,指定序号删除直接调用Remove(i,x)即可实现,指定表项的内容删除可通过search(x)函数返回得到该表项的序号,再通过Remove(i,x)实现case 5:{//按内容删除指定元素int i,x;cout<<"请输入要删除的元素内容:";cin>>x;i = Seq.search(x); //指定元素位置if(Seq.Remove(i,x)) cout<<"删除成功!"<<endl;else cout<<"删除失败!"<<endl;break;}case 6:{//按位置删除指定元素int i,x;cout<<"请输入要删除的元素序号:";cin>>i;if(Seq.Remove(i,x)) cout<<"删除成功,删除的元素是:"<<x<<endl;else cout<<"删除失败!"<<endl;break;}3、显示功能,直接调用成员函数output()即可实现。