数据结构顺序表删除(c++)
数据结构(1,2,3章)课后题答案..
西北大学可视化技术研究所
1.3填空题： （1）变量的作用域是指 变量的有效范围 （2）抽象数据类型具有 数据抽象 、 信息隐 蔽 的特点。 （3）一种抽象类型包括 数据对象 、 结构 关系 和 基本操作 。
西北大学可视化技术研究所
（4）当需要用一个形式参数直接改变对应实参 的值时，该形式参数应说明为 指针类型 。 （5）数据结构的逻辑结构分为 集合结构 、 线性结构 、 树形结构 和 图结构 四种。 （6）数据结构的存储结构分为 顺序存储结构 和 链式存储结构 两种。
西北大学可视化技术研究所
（3）顺序表中，逻辑上相邻的元素，其物理位 置 也 相邻。在单链表中，逻辑上相邻的元 素，其物理位置 不一定 相邻。 （4）在带头结点的非空单链表中，头结点的存 储位置由 头指针 指示，首元素结点的存 储位置由 头结点的next域 指示，除首元素 结点外，其它任一元素结点的存储位置由 其 直接前驱的next域 指示。
8.假设两个按元素值递增有序排列的线性 表A和B，均以单链表作为存储结构，请 编写算法，将A表和B表归并成一个按元 素值递减有序排列的线性表C，并要求利 用原表（即A表和B表的）结点空间存放 表C。
西北大学可视化技术研究所
算法描述：要求利用现有的表A和B中的结 点空间来建立新表C，可通过更改结点的next 域来重新建立新的元素之间的线性关系。为保 证新表递减有序可以利用头插法建立单链表的 方法，只是新建表中的结点不用malloc，而只 需要从A和B中选择合适的点插入到新表C中即 可。
i
西北大学可视化技术研究所
第二步:计算结果
n n (1+i)i i2 i 2 i=1 i 1 2 i 1 2 n
1 2 2 1 2 (1 2 ... n ) (1 2 ... n) 2 2
数据结构c语言期末考试题及答案
数据结构c语言期末考试题及答案一、单项选择题（每题2分，共20分）1. 在数据结构中，线性结构和非线性结构的区别在于（）。
A. 结构中元素的个数B. 结构中是否包含子结构C. 结构中元素之间是否有一对一关系D. 结构中元素之间是否有一对多关系答案：C2. 线性表的顺序存储结构和链式存储结构相比，其优点是（）。
A. 存储密度高B. 存储密度低C. 插入和删除操作快D. 存储空间可以动态分配答案：A3. 在一个长度为n的顺序表中，删除第i个元素（1≤i≤n）时，需要移动的元素个数为（）。
A. i-1B. n-iC. n-i+1D. n-i-1答案：B4. 栈的运算遵循（）原则。
A. 先进先出B. 先进后出C. 后进先出D. 后进后出答案：C5. 在二叉树的前序遍历中，访问顺序为（）。
A. 根-左-右B. 左-根-右C. 左-右-根D. 右-左-根答案：A6. 哈希表的冲突解决方法中，链地址法是（）。
A. 将所有元素存储在同一个存储单元B. 将所有元素存储在同一个链表中C. 将所有元素存储在同一个数组中D. 将所有元素存储在同一个链表的同一个位置答案：B7. 在图的遍历中，深度优先搜索（DFS）和广度优先搜索（BFS）的主要区别在于（）。
A. 遍历的顺序不同B. 遍历的起点不同C. 遍历的路径不同D. 遍历使用的存储结构不同答案：D8. 快速排序算法的时间复杂度为（）。
A. O(n)B. O(nlogn)C. O(n^2)D. O(logn)答案：B9. 归并排序算法的时间复杂度为（）。
A. O(n)B. O(nlogn)C. O(n^2)D. O(logn)答案：B10. 在二叉搜索树中，查找一个元素的时间复杂度为（）。
A. O(n)B. O(logn)C. O(n^2)D. O(1)答案：B二、填空题（每题2分，共20分）1. 在数据结构中，一个算法的时间复杂度通常用______来描述。
答案：大O符号2. 线性表的两种基本操作是插入和______。
国开电大2023年春季期末考试《数据结构》试题(试卷代号1252)
国家开放大学2023年春季学期期末统一考试数据结构(本)试题一、单项选择题(把合适的选项编号填写在括号内。
每小题3分,共45分)1.线性结构、树形结构、图形结构都是按数据的( )来分类的。
A.存储结构B.物理和存储结构C.物理结构D.逻辑结构2.在数据结构中,从逻辑上可以把数据结构分为( ).A.动态结构和静态结构B.紧凑结构和非紧凑结构C.内部结构和外部结构D.线性结构和非线性结构3.设有一个长度为n的顺序表,要删除第i个元素,则需移动元素的个数为( )。
A. iB. n-i-1C. n-iD. n-i+14.设有一个长度为10的顺序表,要在第3个元素之后插入一个元素,则需移动元素的个数为( ).A.3B.6C. 7D.85.一个队列的人队序列是10,20 ,30,40。
则队列的输出序列是( ).A.40,30,20,10B.10,20,30,40C.10.40,30,20D.30 ,20,40,106.在一棵二叉树中(其根结点编号为1),若编号为8的结点存在右孩子,则该右孩子的顺序编号为( )。
A.18B.16C.15D.177.队列的出队操作在( )进行。
A.队头B.队尾C.任意位置D.指定位置8.串函数index(a ,b)的功能是进行( )。
A.求子串B.串连接C.模式匹配D.求串长9.一个非空广义表的表头元素( )。
A.不可能是原子B.只能是子表C.只能是原子D.可以是子表或原子10.链表所具备的特点之一是( )。
A.可以随机访问任一结点B.需要占用连续的存储空间.C.插人元素的操作不需要移动元索D.删除元素的操作需要移动元素11.树中所有结点数等于所有结点的度加( )。
A.1B.0C. 2D. -112.在一个无向图G中,所有边数之和等于的所有顶点的度数之和( )倍。
A.1/2B. 1C.2D.413.对于一个具有4个顶点和5条边的无向图,若采用邻接表表示,则所有顶点邻接表中的结点总数为( )。
数据结构习题及答案 (1)
第八章查找一、判断题1.用二分查找法对一个顺序表进行查找，这个顺序表可以是按各键值排好序的，也可以是没有按键值排好序的。
（）2.哈希表的查找不用进行关键字的比较。
（）3.哈希表的定义函数H（key）=key%p(p<=m)这种方法是直接定址法。
（）4.装填因子α的值越大，就越不容易发生冲突。
( )5.选择hash函数的标准为：随机性好、均匀性好和尽量避免冲突。
( )参考答案：1、×2、×3、×4、×5、√二、填空题1.顺序查找法的平均查找长度为__________，二分查找法的平均查找长度为________，分块查找法(以顺序查找确定块)的平均查找长度为__________，分块查找法(以二分查找确定块〉的平均查找长度为_________，哈希表查找法采用链接法处理冲突时的平均查找长度为_________。
(n+1)/2；((n+1)*log2(n+1))/n-1；(s2+2s+n)/2s；log2(n/s+1)+s/2；1+α2.在各种查找方法中,平均查找长度与结点个数n无关的查法方法是_________哈希表查找3.二分查找的存储结构仅限于_________,且是__________。
顺序；有序的4.在分块查找方法中,首先查找__________,然后再查找相应的___________。
索引；块5.长度为255的表,采用分块查找法,每块的最佳长度是____________。
156.在散列函数H(key)=key%p中,p应取_______________。
小于表长的最大素数7.假设在有序线性表A[1..20]上进行二分查找,则比较一次查找成功的结点数为_________,则比较二次查找成功的结点数为__________,则比较三次查找成功的结点数为_________,则比较四次查找成功的结点数为________,则比较五次查找成功的结点数为_________,平均查找长度为_________。
数据结构机考题库汇总
数据结构机考题库汇总1、在下列对顺序表进行的操作中，算法时间复杂度为O(1)的是（A）。
选项A）访问第i个元素的前驱（1i=n）选项B）在第i个元素之后插入一个新元素(1=i=n)选项C）删除第i个元素(1=i=n)选项D）对顺序表中元素进行排序顺序表是随机存取结构，选项A中实质是查找第i个结点和第i一1个结点，因此时间复杂度为O(1)；选项B和C插入和删除都需要移动元素，时间复杂度为O(n)；选项D是排序问题，时间复杂度是O(n)～O(n2)。
2、不带头结点的单链表head为空的判定条件是（A）。
选项A）head==NULL选项B）head-next==NULL选项C）head-next==head选项D）head!=NULL在不带头结点的单链表head中，head指向第一个元素结点，head=NULL表示该链表为空。
3、在一个长度为n的顺序表中，在第i个元素之前插入一个新元素时，需向后移动（B）个元素。
选项A）n-i选项B）n-i+1选项C）n-i-1选项D）ii之前共有(i-1)个元素,所以,需移动(n-(i-1))个元素。
4、某程序的时间复杂度为（3n+nlog2n+n2+8）,其数量级表示为（C）。
选项A）O(n)选项B）O(nlog2n)选项C）O(n2)选项D）O(log2n)5、在以下的叙述中，正确的是（C）。
选项A）线性表的顺序存储结构优于链表存储结构选项B）线性表的顺序存储结构适用于频繁插入删除数据元素的情况选项C）线性表的链表存储结构适用于频繁插入删除数据元素的情况选项D）线性表的链表存储结构优于顺序存储结构6、对一个具有n个元素的线性表，建立其单链表的时间复杂性为（A）。
选项A）O(n)选项B）O(1)选项C）O(n2)选项D）O(log2n)7、线性表链式存储结构的特点，哪个是错误的（C）。
选项A）逻辑上相邻的元素，其物理位置不一定相邻，元素之间的邻接关系由指针域指示选项B）链表是非随机存取存储结构，对链表的存取必须从头指针开始选项C）链表是一种动态存储结构，链表的结点可用free()申请和用malloc()释放。
(完整版)数据结构线性表的主要程序代码
数据结构顺序表的主要代码（LIZHULIN）1．/***有头结点的单链表的初始化、建立（表头插入、表尾插入）、求长度、插入、删除、输出***//***********单链表的初始化、建立、输出*****************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = NULL;}/*************建立一个带头结点的单链表，在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p,*q; int i;Initlist(L); /*单链表初始化*/q=L;printf("input the value\n");for(i = n;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));scanf("%d",&p->data); /*输入元素值*/q->next = p;p->next = NULL;q=p;/*插入到表尾*/}} /* Create_L *//*************建立一个带头结点的单链表，在表头插入**************Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化/*需要注意第一个数据插入时的情况/*Insert the Firset nodep = (LinkList*)malloc(sizeof(struct Lnode));printf("input the value\n");scanf("%d",&p->data); /*输入元素值L->next = p;p->next = NULL;/*将第二个及后面的数据插入for(i = n-1;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));printf("input a value\n");scanf("%d",&p->data); /*输入元素值p->next = L->next;L->next = p;/*插入到表头}} /* Create_L *//*************************求单链表的长度***********************/int Length_LinkList(LinkList *L){LinkList *p;int i=0;p=L->next;while(p!=NULL){i++;p=p->next;}return i;}/*Length_LinkList*//*************************在第i个结点前插入数据x *********************/ Insert_LinkList(LinkList *L, int i, int x){LinkList *p,*s;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i，则无意义*//*插入元素x */s=(LinkList *)malloc(sizeof(struct Lnode));s->data=x;s->next=p->next;p->next=s;}/*********************删除第i个元素，并用y将其值返回************************/ int Delete_LinkList(LinkList *L, int i){LinkList *p,*q;int y;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i，则无意义*/q=p->next;y=q->data;p->next=q->next;free(q) ;return y;} /*Delete_LinkList*//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p!=NULL){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int len;int n=0;int x=15;int y;int i=4;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =NULL;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);Insert_LinkList(L, i, x);/* y=Delete_LinkList(L,i);printf("the delete elment is y=%d\n",y);len=Length_LinkList(L);printf("the length of L is %d",len);*/display(L);getch();}2．/***无头结点的单链表建立、插入、求长度、插入、删除、输出*****/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;while(p!=NULL){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}3．/*********顺序表的建立、查找、插入运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/*******Creat SqList********/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input SqList.data\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Position Error");return;}elsereturn L->data[i-1];}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *L;/*printf("input the length of SqList\n");scanf("%d",&len);*/Create_SqList(L);Display_SqList(L);getch();}4．/*********顺序表的归并运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/************ Creat SqList*************/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input the data of SqList\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Getelem Position Error");return;}return L->data[i-1];}/************ Insert Operation *********/void ListInsert(SqList *L,int i, int x){SqList *q, *p;if(i<1 || i>L->length){printf("the insert position error");return ;}q = &(L->data[i-1]); /*q为插入位置*/for(p=&(L->data[L->length-1]); p>=q; --p)*(p+1) = *p;L->data[i-1] = x;++L->length;}/********* LA and LB Merged LC ***************/ void MergeList(SqList *LA,SqList *LB,SqList *LC) {int La_len,Lb_len,ai,bj;int i,j;int k;i=j=1;InitList(LC);La_len = ListLength(LA);Lb_len = ListLength(LB);LC->length = La_len+Lb_len;/*for(k=0;k<LC->length;k++)LC->data[k] = 0; */k=0;while((i<=La_len)&&(j<=Lb_len)){ai= GetElem(LA, i);bj= GetElem(LB, j);if(ai<bj){++k;ListInsert(LC,k,ai);++i;}elseif(ai==bj){++k;ListInsert(LC,k,ai);++k;ListInsert(LC,k,bj);++i;++j;}else{++k;ListInsert(LC,k,bj);++j;}}while(i<=La_len){/*Append the residual node into LA */ai= GetElem(LA, i);++i;++k;ListInsert(LC,k,ai);}while(j<=Lb_len){/*Append the residual node into LA */bj= GetElem(LB, j);++j;++k;ListInsert(LC,k,bj);}LC->length = La_len+Lb_len;}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *LA , *LB, *LC;Create_SqList(LA);Create_SqList(LB);MergeList(LA,LB,LC);Display_SqList(LC);getch();}5．/**** 用带头结点的循环单链表解决约瑟夫问题***********/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = L;}/*************建立一个带头结点的循环单链表，数据值为1,2,3,...n,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化p=L;for(i = n;i>0;--i){q = (LinkList*)malloc(sizeof(struct Lnode));q->data = i; /*输入元素值p->next =qq->next = L;/*插入到表尾}} /* Create_L *//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p->next!=L){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int n;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =L;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);display(L);getch();}6．/******** 无头结点的循环单链表的建立**************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}p->next = L;/*尾结点指向第一个结点*/}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;printf("%d ",p->data);p=p->next;while(p->next !=L){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/ main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}。
数据结构(C语言版)选择、填空题
数据结构（C语言版）选择、填空题一概论选择1、( B)是数据的基本单位。
A、数据结构B、数据元素C、数据项D、数据类型2、以下说法不正确的是(A )。
A、数据结构就是数据之间的逻辑结构。
B、数据类型可看成是程序设计语言中已实现的数据结构。
C、数据项是组成数据元素的最小标识单位。
D、数据的抽象运算不依赖具体的存储结构。
3、学习数据结构主要目的是(C )。
A、处理数值计算问题B、研究程序设计技巧C、选取合适数据结构，写出更有效的算法。
D、是计算机硬件课程的基础。
4、一般而言，最适合描述算法的语言是( C)。
A、自然语言B、计算机程序语言C、介于自然语言和程序设计语言之间的伪语言D、数学公式5、通常所说的时间复杂度指(B )。
A、语句的频度和B、算法的时间消耗C、渐近时间复杂度D、最坏时间复杂度6、A算法的时间复杂度为O(n^3)，B算法的时间复杂度为O(2^n)，则说明(B )。
A、对于任何数据量，A算法的时间开销都比B算法小B、随着问题规模n的增大，A算法比B算法有效C、随着问题规模n的增大，B算法比A算法有效D、对于任何数据量，B算法的时间开销都比A算法小填空1、数据的(存储)结构依赖于计算机语言.2、数据的逻辑结构可分为线性结构和(非线性)结构。
3、算法的时间复杂度与问题的规模有关外，还与输入实例的(初始状态)有关。
4、常用的四种存储方法是什么？顺序存储方法、链式存储方法、索引存储方法和散列存储方法5、常见的数据的逻辑结构有哪两种？线性结构和逻辑结构6、一般，将算法求解问题的输入量称为(问题的规模)。
二线性表选择题1、以下关于线性表的说法不正确的是( C)。
A、线性表中的数据元素可以是数字、字符、记录等不同类型。
B、线性表中包含的数据元素个数不是任意的。
C、线性表中的每个结点都有且只有一个直接前趋和直接后继。
D、存在这样的线性表：表中各结点都没有直接前趋和直接后继。
2、线性表的顺序存储结构是一种( A)的存储结构。
数据结构期末考试试题（含答案）
数据结构期末考试试题（含答案）2005年－2006学年第⼆学期“数据结构”考试试题（A）姓名学号(序号)_答案隐藏班号要求：所有的题⽬的解答均写在答题纸上（每张答题纸上要写清楚姓名、班号和学号），需写清楚题⽬的序号。
每张答题纸都要写上姓名和序号。
⼀、单项选择题（每⼩题2分，共20分）1．数据的运算a 。
A.效率与采⽤何种存储结构有关B.是根据存储结构来定义的C.有算术运算和关系运算两⼤类D.必须⽤程序设计语⾔来描述答：A。
2.链表不具备的特点是 a 。
A.可随机访问任⼀结点B.插⼊删除不需要移动元素C.不必事先估计存储空间D.所需空间与其长度成正⽐答：参见本节要点3。
本题答案为：A。
3.在顺序表中删除⼀个元素的时间复杂度为 c 。
A.O(1)B.O(log2n)C.O(n)D.O(n2)答：C。
4．以下线性表的存储结构中具有随机存取功能的是d 。
A.不带头结点的单链表B.带头结点的单链表C.循环双链表D.顺序表解D。
5.⼀个栈的进栈序列是a，b，c，d，e，则栈的不可能的输出序列是c 。
A.edcba B.decbaC.dceabD.abcde答：C。
6.循环队列qu的队空条件是 d 。
A. (qu.rear+1)%MaxSize==(qu.front+1)%MaxSizeB. (qu.rear+1)%MaxSize==qu.front+1C.(qu.rear+1)%MaxSize==qu.frontD.qu.rear==qu.front答：D。
7.两个串相等必有串长度相等且 b 。
A.串的各位置字符任意B.串中各位置字符均对应相等C.两个串含有相同的字符D.两个所含字符任意答：B。
8.⽤直接插⼊排序对下⾯四个序列进⾏递增排序，元素⽐较次数最少的是c 。
A.94,32,40,90,80,46,21,69B.32,40,21,46,69,94,90,80C.21,32,46,40,80,69,90,94D.90,69,80,46,21,32,94,40答：C。
数据结构考试含答案
单项选择题：单项选择题共20道题，每题2分第1题：在一个具有n个结点的有序顺序表中插入一个新结点并仍然有序，时间复杂度是（）。
A、O（1）B、O（n）C、O（logn）D、O（nlogn）第2题：n个顶点e条边的图，若采用邻接矩阵存储，则矩阵空间大小为（）。
A、O（1）B、O（n）C、O（n+e）D、O（n^2）第3题：树的后根遍历序列等同于该树对应的二叉树的( )。
A. 先序序列B. 中序序列C. 后序序列D.层次序列第4题：若链队列Q用一带头结点的单链表表示，则元素e(其结点由指针p指向)的入队操作为（）。
A.Q.rear->next=p;Q.rear=p;B.Q.rear=p;Q.rear->next=p;C.Q.front->next=p;Q.front=p;D.Q.front=p;Q.front->next=p;第5题：计算机算法指的是（）。
A、计算方法B、排序方法C、解决问题的有限运算序列D、调度方法第6题：n个顶点e条边的图采用邻接矩阵存储，深度优先遍历算法的时间复杂度为（）。
A、O（1）B、O（n）C、O（n+e）D、O（n^2）第7题：最大容量为n的循环队列，队尾指针是rear，队头是front，则队空的条件是（）。
A. (Q.rear+1)%n=Q.frontB. Q.rear=Q.front C．Q.rear+1=Q.front D. (Q.rear-l)%n=Q.front第8题：算法分析的两个主要方面是（）。
A、空间复杂性和时间复杂性B、正确性和简明性C、可读性和文档性D、数据复杂性和程序复杂性第9题：一棵左子树为空的二叉树在先序线索化后，其中空的链域的个数是：( )A．不确定 B. 0 C. 1 D. 2第10题：线性表Ｌ在（）情况下适用于使用顺序结构实现。
A、经常对Ｌ进行删除B、经常对Ｌ进行插入C、经常访问Ｌ中的结点值D、 ABC第14题：一个无回路的AOV网有n个顶点e条边，拓扑排序的时间复杂度为（）。
数据结构期末考试试卷及答案
数据结构期末考试试卷及答案一、选择题（每题2分，共20分）1. 下列哪一个不是线性结构的特点？A. 有且只有一个根结点B. 每个结点最多有一个前驱和一个后继C. 有多个根结点D. 有且只有一个叶子结点答案：C2. 在单链表中，头结点的作用是（）A. 作为链表的起点B. 作为链表的终点C. 存储链表中的数据元素D. 作为链表中的第一个元素答案：A3. 在顺序表中，插入一个元素的时间复杂度是（）A. O(1)B. O(n)C. O(logn)D. O(n^2)答案：B4. 下列哪种排序算法的平均时间复杂度最高？A. 冒泡排序B. 快速排序C. 直接插入排序D. 希尔排序答案：C5. 在二叉树中，具有3个结点的二叉树有（）种不同的形态。
A. 2B. 3C. 4D. 5答案：C6. 下列哪种情况不适合使用哈希表？A. 查找速度快B. 数据量较大C. 数据量较小D. 数据元素关键字分布均匀答案：C7. 在图的遍历过程中，下列哪种遍历方法属于深度优先遍历？A. 广度优先遍历B. 深度优先遍历C. 混合遍历D. 随机遍历答案：B8. 下列哪种数据结构不适用于实现栈？A. 顺序表B. 链表C. 树D. 图答案：C9. 在双向链表中，删除一个元素的时间复杂度是（）A. O(1)B. O(n)C. O(logn)D. O(n^2)答案：A10. 下列哪种情况不适合使用队列？A. 数据元素先进先出B. 数据元素后进先出C. 数据元素随机进出D. 数据元素按顺序进出答案：B二、填空题（每题2分，共20分）1. 线性表是具有______个数据元素的有限序列。
答案：n2. 在单链表中，每个结点包含两个域：数据域和______域。
答案：指针3. 在顺序表中，插入一个元素的时间复杂度是______。
答案：O(n)4. 快速排序的平均时间复杂度为______。
答案：O(nlogn)5. 哈希表中的冲突指的是______。
答案：不同的关键字对应同一存储位置6. 在图的遍历过程中，深度优先遍历算法使用的数据结构是______。
数据结构1-3习题答案
课堂练习
1、在什么情况下用顺序表比链表好? 、在什么情况下用顺序表比链表好 2、画出执行下列各行语句后各指针及链表的 示意图。 示意图。 、 L=(LinkList) malloc (sizeof(LNode));//等价于 等价于L=new LNode; 等价于 P=L; For(i=1;i<=4;i++) { P->next=(LinkList) malloc (sizeof(LNode)); P=P->next; P->data=i*2-1;} P->next=NULL; For(i=4;i>=1;i--) Ins_LinkList(L,i+1,i*2); For(i=1;i<=3;i++) Del_LinkList(L,i);
在下面两列中，左侧是算法（关于问题规模） 2.8 在下面两列中，左侧是算法（关于问题规模） 的执行时间，右侧是一些时间复杂度。 的执行时间，右侧是一些时间复杂度。请用连 线的方式表示每个算法的时间复杂度。 线的方式表示每个算法的时间复杂度。 100n3 6n2-12n+1 1024 n+2log2n n(n+1)(n+2)/6 2n+1+100n
判断下述计算过程是否是一个算法： 2.4 判断下述计算过程是否是一个算法： Step1: 开始 Step2: n<=0; Step3: n=n+1; 重复步骤3; Step4: 重复步骤3; 结束; Step5: 结束; 该计算过程不是一个算法， 答：该计算过程不是一个算法，因为其不满足算法的 有穷性。 有穷性。
回顾
第一章知识要点： 第一章知识要点： • 基本概论：数据、数据元素、数据项、数据对象 基本概论：数据、数据元素、数据项、 • 数据结构(D,S) 数据结构(D,S)
数据结构c语言版(题目)
分类：编程思想和算法2012-09-15 22:24 1759 人阅读评论（0）收藏举报如果TCPhashlistJuli 采用线性表的顺序存储结构，则可以随机存取表中任一终端，但插入和删除终端时，需要移动大量元素，巧妙地终端离线不进行删除操作。
数组，存储的元素应该是线性表顺序存储结构的数据结构。
线性表题目类型：线性表在顺序结构上各种操作的实现；线性链表的各种操作；两个或多个线性表的各种操作；循环链表和双向链表；稀疏多项式及其运算在线性表的两种存储结构上的实现。
线性表在顺序结构上各种操作的实现题目1：（线性表顺序存储结构上的操作—Delete ）从顺序存储结构的线性表a 中删除第i个元素起的k个元素。
（《数据结构题集C语言版》P16)题目2：（线性表顺序存储结构上的操作_lnsert ）设顺序表va中的数据元素递增有序。
试写一算法，将x插入到循序表的适当位置上，以保持该表的有序性。
（《数据结构题集C语言版》P17）题目3：（线性表顺序存储结构上的操作_逆置）试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表逆置。
（《数据结构题集C语言版》2.21）线性表线性链表的各种操作题目1:( Insert ）试写一算法，在无头结点的动态单链表上实现线性表的Insert(L,i,b), 并和在带头结点的动态单链表上实现同样操作的算法进行比较。
（《数据结构题集C语音版》P17）题目2：（Delete ）同上题要求，实现线性表操作Delete（L,i）.题目3:已知线性表中的元素以值递增有序排序，并以单链表作为存储结构。
试写一高效算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素）同时释放被删除结点空间，并分析你的算法的事件复杂度（注意：mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。
（《数据结构题集C语言版》P17)题目4：同上题条件，试写一高效算法，删除表中所有值相同的多余元素（使得操作后的线性表所有元素的值均不相同），同是释放被删结点空间，并分析你算法的时间复杂度。
顺序表的基本操作【c语言】【创建、插入、删除、输出】
顺序表的基本操作【c语⾔】【创建、插⼊、删除、输出】作为数据结构初学者，上课时对⼀些知识点掌握得不是很透彻，所以利⽤课余时间通过微博平台总结所学知识，加深对知识的见解，记录学习历程便于后需要时参考。
1 #include<stdio.h>2 #include<malloc.h>3#define OK 14#define ERROR 05#define LIST_INIT_SIZE 1006#define LISTINCREMENT 107#define ElemType int顺序表的基本操作之结构体的创建：1 typedef struct2 {3int *elem;//存储空间基址，也就是该数据得到的内存分配的起始地址4int length;//当前长度5int listsize;//当前分配的存储容量6 } SqList;构造⼀个空的线性表：int InitList_Sq(SqList &L) //&此符号不是c语⾔⾥的取地址符号，⽽是C++⾥的引⽤符号，⽤法为为主函数⾥的T，取⼀个别名，这样⼦对L操作即相当于对T操作{// 该线性表预定义⼤⼩为LIST_INIT_SIZEL.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//ElemType即为intif(!L.elem) return0;//malloc返回值为void*,void* 类型可以强制转换为任何其它类型的指针，在这⾥L.elem为⾮零。
L.length=0;L.listsize=LIST_INIT_SIZE;//LIST_INIT_SIZE=100return OK;}在顺序线性表L中第i个位置之前插⼊新的元素e：1int ListInsert_Sq(SqList &L,int i,int e)2 {3int *newbase;//声明整型指针变量4int *q,*p;5if(i<1||i>L.length+1) return ERROR;//判断i值是否合法，1<i<L.length+16if(L.length>=L.listsize)//判断当前长度是否⼤于当前的存储容量，如果⼤于，则增加LISTINCREMENT长度，即107 {8 newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));9if(!newbase) return0;10 L.elem=newbase;11 L.listsize+=LISTINCREMENT;12 }13 q=&(L.elem[i-1]);//把插⼊位置的地址赋值给q14for(p=&(L.elem[L.length-1]); p>=q; p--)15 *(p+1)=*p;//把i后⾯的元素都向后移⼀位16 *q=e;//在i位置插⼊e17 ++L.length;//长度增加18return OK;19 }在顺序线性表L中删除第i个位置的元素，并⽤e返回其值：int ListDelete_Sq(SqList &L,int i, int &e){// i的合法值为1≤i≤L.lengthint *p;int *q;if(i<1||i>L.length) return ERROR;p=&(L.elem[i-1]);//把i位置的地址赋值给pe=*p;//把i位置的值赋值给eq=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;//i后⾯的元素向前移⼀位，直接覆盖i位置的值--L.length;//长度减少return OK;}顺序表基本操作之输出：int Load_Sq(SqList &L){// 输出顺序表中的所有元素int i;if(L.length==0) printf("The List is empty!");else{printf("The List is: ");for( i=0; i<L.length; i++) printf("%d ",L.elem[i]); // 请填空}printf("\n");return OK;}下⾯是主函数：1int main()2 {3 SqList T;4int a, i;5 ElemType e, x;6if(InitList_Sq(T)) // 判断顺序表是否创建成功7 {8 printf("A Sequence List Has Created.\n");9 }10while(1)11 {12 printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");13 scanf("%d",&a);14switch(a)15 {16case1:17 scanf("%d%d",&i,&x);18if(!ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法19else printf("The Element %d is Successfully Inserted!\n", x);20break;21case2:22 scanf("%d",&i);23if(!ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法24else printf("The Element %d is Successfully Deleted!\n", e);25break;26case3:27 Load_Sq(T);28break;29case0:30return1;31 }32 }33 }。
数据结构删除顺序表上指定的值
数据结构删除顺序表上指定的值数据结构是计算机科学中非常重要的一门学科，其中顺序表是最基本的数据结构之一。
在顺序表中，我们可以通过下标来访问其中的元素，但是删除指定值时需要进行一些操作。
下面将介绍如何在顺序表中删除指定的值。
一、顺序表的介绍顺序表是一种线性结构，它的元素存储在一段连续的内存区域中。
这些元素按照顺序排列，可以通过下标来访问。
对于大小为n 的顺序表，每个元素占用 a 个存储单元，总共需要占用 an 个存储单元。
二、顺序表的实现顺序表可以通过数组来实现，数组的下标表示元素在顺序表中的位置。
在插入和删除操作时需要移动其他元素，因此时间复杂度较高，为O(n)。
三、删除顺序表上指定的值删除顺序表上指定的值需要先找到该值所在的位置，然后将后面所有的元素向前移动一位。
具体操作如下：1. 遍历顺序表，找到指定的值 val 所在的位置 i；2. 从位置 i+1 开始，将后面的所有元素向前移动一位；3. 将顺序表的长度减 1。
代码实现如下：``` pythondef delete_value(lst, val):for i in range(len(lst)):if lst[i] == val:for j in range(i+1, len(lst)):lst[j-1] = lst[j]lst.pop()breakreturn lst```四、时间复杂度分析遍历顺序表的时间复杂度为 O(n)，移动元素的时间复杂度也为 O(n)，因此删除指定的值的时间复杂度为 O(n)。
五、总结顺序表是一种基本的数据结构，删除指定值的操作需要自己实现。
虽然时间复杂度比较高，但是在一些小数据集下使用还是比较方便的。
同时也要注意顺序表的元素个数不能太多，否则删除操作的时间复杂度会变得很高。
电子科技大学22春“计算机应用技术”《数据结构》期末考试高频考点版(带答案)试卷号2
电子科技大学22春“计算机应用技术”《数据结构》期末考试高频考点版（带答案）一.综合考核(共50题)1.若一个算法中的语句频度之和为T(n)=3720n+4nlogn，则算法的时间复杂度为 O(n)。
()A.正确B.错误参考答案：B2.假设以S和X分别表示进栈和退栈操作，则对输入序列a，b，c，d，e进行一系列栈操作SSXSXSSXXX 之后，得到的输出序列为 a b b c c d d e d c 。
()A.正确B.错误参考答案：B3.下面的程序段的时间复杂度是多少?()A.O(n)B.O(m+n+1)C.O(m+n)D.O(m*n)参考答案：D4.在线性表的下列运算中，不改变数据元素之间结构关系的运算是()。
A、插入B、删除C、排序D、定位5.从顺序表中删除一个元素时，表中所有在被删元素之后的元素均需()。
A、前移一个位置B、后移一个位置C、不动D、视情况而定参考答案：A6.算法有以下几种特性()。
A、有穷性B、确定性C、可行性D、输入和输出参考答案：ABCD7.在目标串T[0...n-1]=″xwxxyxy″中，对模式串P[0...m-1]=″xy″进行子串定位操作的结果是()。
A、0B、2C、3D、5参考答案：C8.一个含有n个结点的完全二叉树，它的高度是「log2n」+1。
()T、对F、错参考答案：TA.正确B.错误参考答案：B10.已知在一棵度为3的树中，度为2的结点数为4，度为3的结点数为3，则该树中的叶子结点数为()。
A、5B、8C、11D、18参考答案：C11.假设按照12345的进栈顺序，下面哪些是可能的出栈顺序()。
A、12345B、54321C、43215D、14325参考答案：ABCD12.在文本编辑程序中查找某一特定单词在文本中出现的位置，可以利用串的定位操作。
()A、错误B、正确参考答案：B13.若线性表的插入和删除操作频繁地在表头或表尾位置进行，则更适宜采用的存储结构为()。
数据结构——从顺序表中删除重复的元素
数据结构——从顺序表中删除重复的元素问题描述：设计⼀个算法从顺序表中删除重复的元素，并使剩余元素间的相对次序保持不变。
例如：原顺序表为｛4 2 8 4 2 1 2 1 3 5 2｝，执⾏该算法后，顺序表为：｛4 2 8 1 3 5｝。
另外，顺序表的初始值通过调⽤算法initRandomize(int *arr, int n, int min, int max)产⽣。
rand()函数⽤来产⽣随机数，但是，rand()的内部实现是⽤线性同余法实现的，是伪随机数，由于周期较长，因此在⼀定范围内可以看成是随机的。
rand()会返回⼀个范围在0到RAND_MAX（32767）之间的伪随机数（整数）。
在调⽤rand()函数之前，可以使⽤srand()函数设置随机数种⼦，如果没有设置随机数种⼦，rand()函数在调⽤时，⾃动设计随机数种⼦为1。
随机种⼦相同，每次产⽣的随机数也会相同。
rand()函数需要的头⽂件是：<stdlib.h>rand()函数原型：int rand(void);使⽤rand()函数产⽣1-100以内的随机整数：int number1 = rand() % 100+1;⼆、srand()srand()函数需要的头⽂件仍然是：<stdlib.h>srand()函数原型：void srand (usigned int seed);srand()⽤来设置rand()产⽣随机数时的随机数种⼦。
参数seed是整数，通常可以利⽤time(0)或geypid(0)的返回值作为seed。
使⽤rand()和srand()产⽣1-100以内的随机整数:srand(time(0));int number1 = rand() % 100+1;三、使⽤rand()和srand()产⽣指定范围内的随机整数的⽅法“模除+加法”的⽅法因为，对于任意数，0<=rand()%(n-m+1)<=n-m因此，0+m<=rand()%(n-m+1)+m<=n-m+m因此，如要产⽣[m,n]范围内的随机数num，可⽤：int num=rand()%(n-m+1)+m;其中的rand()%(n-m+1)+m算是⼀个公式，记录⼀下⽅便以后查阅。
数据结构(本)-国家开放大学电大学习网形考作业题目答案
数据结构（本）一、单选题1.把数据存储到计算机中，并具体体现数据元素间的逻辑结构称为（）。
A.逻辑结构B.物理结构C.算法的具体实现D.给相关变量分配存储单元正确答案: B2.下列说法中，不正确的是（）。
A.数据元素是数据的基本单位B.数据项是数据中不可分割的最小可标识单位C.数据可有若干个数据元素构成D.数据项可由若干个数据元素构成正确答案: D3.一个存储结点存储一个（）。
A.数据项B.数据元素C.数据结构D.数据类型正确答案: B4.数据结构中，与所使用的计算机无关的是数据的（）。
A.存储结构B.物理结构C.逻辑结构D.物理和存储结构正确答案: C5.在线性表的顺序结构中，以下说法正确的是（）。
A.逻辑上相邻的元素在物理位置上不一定相邻B.数据元素是不能随机访问的C.逻辑上相邻的元素在物理位置上也相邻D.进行数据元素的插入、删除效率较高正确答案: C6.对链表, 以下叙述中正确的是（）。
A.不能随机访问任一结点B.结点占用的存储空间是连续的C.插入删除元素的操作一定要要移动结点D.可以通过下标对链表进行直接访问正确答案: A7.下列的叙述中，不属于算法特性的是（）。
A.有穷性B.输入性C.可行性D.可读性8.算法的时间复杂度与（）有关。
A.所使用的计算机B.计算机的操作系统C.算法本身D.数据结构正确答案: C9.设有一个长度为n的顺序表，要在第i个元素之前（也就是插入元素作为新表的第i个元素），插入一个元素，则移动元素个数为（）。
A.n-i+1B.n-iC.n-i-1D.i正确答案: A10.设有一个长度为n的顺序表，要删除第i个元素移动元素的个数为（）。
A.n-i+1B.n-iC.n-i-1D.i正确答案: B11.在一个单链表中，p、q分别指向表中两个相邻的结点，且q所指结点是p所指结点的直接后继，现要删除q所指结点，可用语句（）。
A.p=q->nextB.p->next=qC.p->next=q->nextD.q->next=NULL正确答案: C12.在一个单链表中p所指结点之后插入一个s所指的结点时，可执行（）。
实验一数据结构顺序表的插入和删除
实验一顺序表的操作1.实验题目：顺序表的操作2.实验目的和要求：1）了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。
2) 通过在Turbo C（WinTc，或visual stdio6）实现以上操作的C语言代码。
3）提前了解实验相关的知识（尤其是C语言）。
3.实验内容：(二选一)1) 顺序表的插入算法,删除算法,顺序表的合并算法2) 与线性表应用相关的实例(自己选择具体实例)4.部分参考实验代码：⑴顺序表结构的定义：#include <stdio.h>#define MAXLEN 255typedef int ElemType;typedef struct{ ElemType elem[MAXLEN];int length;}sqList;⑵顺序表前插（在第i号元素前插入一个新的元素）int ListInsert(sqList *la,int i,int x){ int j;if(i<0||i>la-> length +1){ printf(“\n the value of i is wrong!”);return 0;}if(la-> length +1>=MAXLEN){ printf(“\n overflow!”);return 0;}. for(j=la-> length;j>=i;j--)la->list[j+1]=la->list[j];la->list[i]=x;la-> length ++;return 1;}⑶顺序表删除int ListDelete(sqList *la,int i){ if(i<0||i>la-> length){ printf(“\n the position is wrong!\n”);return 0;}for(i;i<la-> length;i++)la->list[i-1]=la->list[i];la-> length --;return 1;}5.附录：实验预备知识：⑴复习C语言中数组的用法。
数据结构(C语言版)第2版习题答案—严蔚敏(简化版)
第2章线性表1．选择题（1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（）。
A．110 B．108 C．100 D．120答案：B解释：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。
（3）向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动的元素个数为（）。
A．8 B．63.5 C．63 D．7答案：B解释：平均要移动的元素个数为：n/2。
（4）链接存储的存储结构所占存储空间（）。
A．分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针B．只有一部分，存放结点值C．只有一部分，存储表示结点间关系的指针D．分两部分，一部分存放结点值，另一部分存放结点所占单元数答案：A（5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（）。
A．必须是连续的B．部分地址必须是连续的C．一定是不连续的D．连续或不连续都可以答案：D（6）线性表Ｌ在（）情况下适用于使用链式结构实现。
A．需经常修改Ｌ中的结点值Ｂ．需不断对Ｌ进行删除插入C．Ｌ中含有大量的结点Ｄ．Ｌ中结点结构复杂答案：B解释：链表最大的优点在于插入和删除时不需要移动数据，直接修改指针即可。
（7）单链表的存储密度（）。
A．大于1 B．等于1 C．小于1 D．不能确定答案：C解释：存储密度是指一个结点数据本身所占的存储空间和整个结点所占的存储空间之比，假设单链表一个结点本身所占的空间为D，指针域所占的空间为N，则存储密度为：D/(D+N)，一定小于1。
（8）将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是（）。
A．n B．2n-1 C．2n D．n-1答案：A解释：当第一个有序表中所有的元素都小于（或大于）第二个表中的元素，只需要用第二个表中的第一个元素依次与第一个表的元素比较，总计比较n次。
（9）在一个长度为n的顺序表中，在第i个元素（1≤i≤n+1）之前插入一个新元素时须向后移动（）个元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
if(value==alist[i]){
p=i;
return true;
}
cout<<"查不到此数";
return false;
}
bool append(const T value){
int i;
if(curlen==maxsize)
{cout<<"表满"<<endl;
int i;
if(curlen==0)
{
cout<<"空表"<<endl;
return false;
}
if(p<0||p>curlen-1)
{
cout<<"差错位置"<<endl;
return false;}
for(i=p;i<curlen-1;i++)
alist[i]=alist[i+1];
curlen--;
#include<iostream.h>
template<class T>
class arrlist{
private:
T *alist;
int maxsize;
int curlen;
int position;
public:
arrlist(const int size){
maxsize=size;
alist=new T[maxsize];
}
return true;
}
};;int> a(100);
int i,A[10]={0,1,2,3,4,5,6,7,8,9},q=0;
for(i=0;i<=9;i++)
a.append(A[i]);
a.deete(0);
a.getpos(q,9);
cout<<q<<endl;
return false;
}
if(p<0||p>curlen){
cout<<"插错位置"<<endl;
return false;
}
for(i=curlen;i>p;i--)
alist[i]=alist[i-1];
alist[p]=value;
curlen++;
return true;
}
bool deete(const int p){
return false;}
for(i=curlen;i<maxsize;i++)
alist[i]=value;
curlen++;
return true;}
bool insert(const int p,const T value)
{
int i;
if(curlen==maxsize){
cout<<"表已满"<<endl;
curlen=position=0;
}
~arrlist(){
delete[] alist;
}
void clear(){
delete[] alist;
curlen=position=0;
alist=new T[maxsie];
}
bool getpos(int&p,const T value){
int i;