C++线性表的元素插入和删除
C语言——线性表及其应用
![C语言——线性表及其应用](https://img.taocdn.com/s3/m/c3189c90d5d8d15abe23482fb4daa58da0111c7b.png)
C语⾔——线性表及其应⽤程序要求1.建⽴含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利⽤前⾯的实验先建⽴⼀个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插⼊元素68。
3.建⽴⼀个带头结点的单链表,结点的值域为整型数据。
要求将⽤户输⼊的数据按尾插⼊法来建⽴相应单链表。
输⼊和输出的格式1.顺序线性表的建⽴、插⼊及删除顺序表#include<stdio.h>#include<stdlib.h>#define ListSize 50typedef int DataType;//线性表的顺序存储⽅式typedef struct {DataType data[ListSize];int l;}SeqList;//创建顺序线性表void CreateList(SeqList *A,int n){int i;for(i=0;i<n;i++){scanf("%d",&(A->data[i]));}A->l=n;}//在顺序线性表中插⼊某个元素void InsertList(SeqList *A,DataType x,int i){int j;if(i<1 || i>A->l) //插⼊时的条件{printf("插⼊位置错误!\n");exit(0);}else{printf("插⼊成功!\n");}if(A->l >= ListSize){printf("列表溢出!\n");exit(0);}for(j=A->l-1;j>=i-1;j--){A->data[j+1]=A->data[j]; //插⼊时,把各个元素向后移动后,然后在进⾏插⼊}A->data[i-1]=x;A->l++;}//在顺序线性表中删除某个元素void DeleteList(SeqList *A,int i){int j;if(A->l==0) //删除时的条件{printf("列表为空!\n");exit(0);}if(i<1 || i>A->l){printf("删除位置错误!\n\n");exit(0);}for(j=i;j<=A->l-1;j++) //删除时,把各个元素向前移动,覆盖掉要删除的元素{A->data[j-1]=A->data[j];}A->l--;}//输出线性表void DisList(SeqList *L){int i;for(i=0;i<L->l;i++)printf("%d ",L->data[i]);printf("\n");}void main(){SeqList *A=(SeqList*)malloc(sizeof(SeqList));int a=7;printf("请输⼊7个整型元素:\n");CreateList(A,a);printf("输出SeqList的长度: \n");printf("长度=%d\n",A->l);printf("表内元素为");DisList(A);DataType x;printf("请输⼊需要插⼊的元素的位置!\n");int i;scanf("%d",&i);printf("请输⼊需要插⼊的元素!\n");scanf("%d",&x);InsertList(A,x,i);printf("长度=%d\n",A->l);printf("表内元素为");DisList(A);printf("请输⼊需要删除的元素的位置!\n");scanf("%d",&i);DeleteList(A,i);printf("表内元素为");DisList(A);printf("长度=%d\n",A->l);}输⼊和输出的格式顺序表输⼊输出:定义输⼊7个整型元素,回车进⾏插⼊和删除,输出线性表2.链式线性表的建⽴、插⼊及删除单链表#include <stdio.h>#include <stdlib.h>typedef int ElemType;//定义结点类型typedef struct Node{ElemType data; //单链表中的数据域struct Node *next; //单链表的指针域}Node,*LinkedList;//单链表的初始化LinkedList LinkedListInit(){Node *A;A = (Node *)malloc(sizeof(Node)); //申请结点空间if(A == NULL) //判断是否有⾜够的内存空间printf("申请内存空间失败\n");A->next = NULL; //将next设置为NULL,初始长度为0的单链表return A;}//单链表的建⽴LinkedList LinkedListCreat(){Node *A;A = (Node *)malloc(sizeof(Node)); //申请头结点空间A->next = NULL; //初始化⼀个空链表Node *r;r = A;ElemType x;while(scanf("%d",&x) != EOF){Node *p;p = (Node *)malloc(sizeof(Node));p->data = x;r->next = p;r = p;}r->next = NULL;return A;}//单链表的插⼊,在链表的第i个位置插⼊x的元素LinkedList LinkedListInsert(LinkedList A,int i,ElemType x){Node *pre; //pre为前驱结点pre = A;int tempi = 0;for (tempi = 1; tempi < i; tempi++)pre = pre->next; //查找第i个位置的前驱结点Node *p; //插⼊的结点为pp = (Node *)malloc(sizeof(Node));p->data = x;p->next = pre->next;pre->next = p;return A;}//单链表的删除,在链表中删除数据值为x的元素LinkedList LinkedListDelete(LinkedList A,ElemType x){Node *p,*pre; //pre为前驱结点,p为查找的结点。
线性表 知识点总结
![线性表 知识点总结](https://img.taocdn.com/s3/m/413aa4247f21af45b307e87101f69e314332fa9b.png)
线性表知识点总结线性表的特点:1. 有序性:线性表中的元素是有序排列的,每个元素都有唯一的前驱和后继。
2. 可变性:线性表的长度是可变的,可以进行插入、删除操作来改变表的元素数量。
3. 线性关系:线性表中的元素之间存在明确的前驱和后继关系。
4. 存储结构:线性表的存储结构有顺序存储和链式存储两种方式。
线性表的操作:1. 查找操作:根据元素的位置或值来查找线性表中的元素。
2. 插入操作:将一个新元素插入到线性表中的指定位置。
3. 删除操作:将线性表中的某个元素删除。
4. 更新操作:将线性表中的某个元素更新为新的值。
线性表的顺序存储结构:顺序存储结构是将线性表的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
线性表的顺序存储结构通常采用数组来实现。
数组中的每个元素都可以通过下标来访问,因此可以快速的进行查找操作。
但是插入和删除操作会导致元素位置的变动,需要进行大量数据搬移,效率较低。
线性表的链式存储结构:链式存储结构是将线性表的元素通过指针相连,形成一个链式结构。
每个元素包含数据和指向下一个元素的指针。
链式存储结构不需要连续的存储空间,可以动态分配内存,适合插入和删除频繁的场景。
但是链式结构的元素访问不如顺序结构高效,需要通过指针来逐个访问元素。
线性表的应用场景:1. 线性表适用于数据元素之间存在明确的前后关系,有序排列的场景。
2. 顺序存储结构适用于元素的插入和删除操作较少,对元素的随机访问较频繁的场景。
3. 链式存储结构适用于插入和删除操作较频繁的场景,对元素的随机访问较少。
线性表的操作的时间复杂度:1. 查找操作:顺序存储结构的时间复杂度为O(1),链式存储结构的时间复杂度为O(n)。
2. 插入和删除操作:顺序存储结构的时间复杂度为O(n),链式存储结构的时间复杂度为O(1)。
线性表的实现:1. 顺序存储结构的实现:使用数组来存储元素,通过下标来访问元素。
2. 链式存储结构的实现:使用链表来实现,每个元素包含数据和指向下一个元素的指针。
实验01 线性表的基本操作
![实验01 线性表的基本操作](https://img.taocdn.com/s3/m/e799801e0c22590103029d73.png)
实验01 线性表的基本操作一、实验目的1. 了解线性表的结构特点及有关概念;2. 理解线性表的存储结构;3. 掌握顺序表及单链表的基本操作算法。
二、实验内容1、编写程序实现顺序表的各种基本运算:初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计一个主程序完成如下功能:(1)初始化顺序表L;(2)依次在表尾插入a,b,c,d,e五个元素;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插入元素f,之后输出顺序表L;(9)删除L的第2个元素,之后输出顺序表L;(10)销毁顺序表L。
2、编写程序实现单链表的各种基本运算:初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计一个主程序完成如下功能:(1)初始化单链表L;(2)依次在表尾插入a,b,c,d,e五个元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插入元素f,之后输出单链表L;(9)删除L的第2个元素,之后输出单链表L;(10)销毁单链表L。
三、实验要点及说明一.顺序表1.顺序表初始化:(1)为顺序表L动态分配一个预定大小的数组空间,使elem 指向这段空间的基地址。
(2)将表的当前长度设为0.2.顺序表的取值:(1)判断指定的位置序号i值是否合理(1<=i<=L.length),若不合理则返回ERROR.(2)若i值合理,则将i个数据元素L.elem[i]赋给参数e,通过e返回第i个数据元素的传值。
3.顺序表的查找:(1)从第一个元素起,依次和e相比较,若找到与e相等的元素L.elem[i],则查找成功,返回该元素的序号i+1.(2)若查遍整个顺序表都没要找到,则查找失败,返回0.4.顺序表的插入:(1)判断插入位置i是否合法(i值的合法范围是1<=i<=n+1),若不合法则返回值ERROR.(2)判断顺序表的存储空间是否已满,若满则返回值ERROR(3)将第n个至第i个位置的元素依次向后移动一个位置,空出第i个位置(i=n+1时无需移动)。
线性顺序表的插入与删除(实验报告)
![线性顺序表的插入与删除(实验报告)](https://img.taocdn.com/s3/m/a79a2b17227916888486d757.png)
一、实验目的和要求通过对顺序表的编程练习,加强对顺序表的特点、顺序存储结构及其基本运算的理解和掌握。
提前了解实验相关的c语言的知识。
使用C语言根据相应算法编写一个程序,实现建立线性顺序表、插入和删除等基本操作。
要求仔细阅读下面的内容,编写一个C程序,上机调试通过,并观察其结果,写出实验报告书。
二、实验内容和原理内容:建立一个容量10的顺序表,在其中插入3个元素,然后作删除运算。
原理:在第i个元素前插入元素,从第i个元素开始到最后一个元素均向后移动一个位置,然后将新元素插入到第i个位置,将线性表的长度加1。
删除第i个元素,从第i+1个元素开始到最后一个元素均向前移动一个位置,然后将线性表的长度减1。
三、主要仪器设备计算机一台四、实验主程序#include<stdio.h>#include<stdlib.h>struct List{int size;int n;int *head;};void init(struct List *pl,int size){pl->size=size;pl->n=0;pl->head=malloc(size*sizeof(int)); }void in(int i,int val,struct List *pl){int k;if(pl->n==pl->size){printf("list is full.\n");return;}if(i>pl->n)i=pl->n+1;if(i<1)i=1;for(k=pl->n-1;k>=i-1;--k)pl->head[k+1]=pl->head[k];pl->head[i-1]=val;++pl->n;}void out(int i,struct List *pl){int k;if(pl->n==0){printf("list is empty.\n");return;}if(i<1||i>pl->n){printf("this element is not in the list.\n");return;}for(k=i;k<=pl->n;++k)pl->head[k-1]=pl->head[k];--pl->n;return;}void print(const struct List *pl) {int i;for(i=0;i!=pl->n;++i)printf("%d ",pl->head[i]);printf("\n");}int main(void){int i;struct List list;init(&list,10);for(i=0;i!=5;++i)in(i+1,i,&list);print(&list);in(1,5,&list);print(&list);in(10,4,&list);print(&list);in(5,50,&list);print(&list);out(1,&list);print(&list);out(list.n,&list);print(&list);out(3,&list);print(&list);getchar();return 0;}实验结果五、实验心得通过实验学习,我理解了线性顺序表的插入与删除的算法,了解到线性顺序表的插入与删除得效率低下,感到受益匪浅。
数据结构习题与答案
![数据结构习题与答案](https://img.taocdn.com/s3/m/2cf5a00e76c66137ee061902.png)
C、便于插入和删除D、便于利用零散的存储器空间
3.若长度为n的线性表采用顺序存储结构,在其第i个位置插入一个新元素算法的时间复杂度为C。
A、O(log2n) B、O(1)
C、O(n) D、O(n2)
4.(1)静态链表既有顺序存储的特点,又有动态链表的优点。所以,它存取表中第i个元素的时间与i无关;
4、线性结构的特征:逻辑上满足有且仅有一个开始结点和一个终端结点,且其余结点有且仅有唯一的一个直接前趋和一个直接后继。
5.数据的存储结构被分为顺序、链接、索引和散列4种。
6.存储结构是逻辑结构的存储实现,其基本目标是建立数据的机内表示。
7.数据表示任务是逐步完成的,即数据表示形式的变化过程是:机外表示→
A、带尾指针的非循环链表B、带尾指针的循环链表
C、带头指针的非循环链表D、带头指针的循环链表
2、若用一个大小为6的数组来实现循环队列,且当rear和front的值分别为0和3。当从队列中删除一个元素,再加入两个元素后,rear和front的值分别是B。
A、1和5 B、2和4
C、4和2 D、5和1
3、设栈的输入序列为1、2、3、4,则C不可能是其出栈序列。
push (s,x); }
push (s,x); printf(x)
push(s,y); }
push(s,x);
push(s,'E');
push(s,x);
此题的输出结果是HELOLLL。
5、以下为单链表删除运算,分析算法,请在处填上正确的语句。
void delete_lkist(lklist head,int i)
D、q->next=p->next;q->prior=p;p->next=q;p->next=q;
数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)
![数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)](https://img.taocdn.com/s3/m/962a7eee534de518964bcf84b9d528ea81c72fad.png)
数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)数据结构基础及深入及考试习题及实验参考答案见附录结论1、数据的逻辑结构是指数据元素之间的逻辑关系。
即从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。
2、数据的物理结构亦称存储结构,是数据的逻辑结构在计算机存储器内的表示(或映像)。
它依赖于计算机。
存储结构可分为4大类:顺序、链式、索引、散列3、抽象数据类型:由用户定义,用以表示应用问题的数据模型。
它由基本的数据类型构成,并包括一组相关的服务(或称操作)。
它与数据类型实质上是一个概念,但其特征是使用与实现分离,实行封装和信息隐蔽(独立于计算机)。
4、算法:是对特定问题求解步骤的一种描述,它是指令的有限序列,是一系列输入转换为输出的计算步骤。
5、在数据结构中,从逻辑上可以把数据结构分成(C)A、动态结构和表态结构B、紧凑结构和非紧凑结构C、线性结构和非线性结构D、内部结构和外部结构6、算法的时间复杂度取决于(A)A、问题的规模B、待处理数据的初态C、问题的规模和待处理数据的初态线性表1、线性表的存储结构包括顺序存储结构和链式存储结构两种。
2、表长为n的顺序存储的线性表,当在任何位置上插入或删除一个元素的概率相等时,插入一个元素所需移动元素的平均次数为(E),删除一个元素需要移动的元素的个数为(A)。
A、(n-1)/2B、nC、n+1D、n-1E、n/2F、(n+1)/2G、(n-2)/23、“线性表的逻辑顺序与存储顺序总是一致的。
”这个结论是(B)A、正确的B、错误的C、不一定,与具体的结构有关4、线性表采用链式存储结构时,要求内存中可用存储单元的地址(D)A、必须是连续的B、部分地址必须是连续的C一定是不连续的D连续或不连续都可以5、带头结点的单链表为空的判定条件是(B)A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL6、不带头结点的单链表head为空的判定条件是(A)A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL7、非空的循环单链表head的尾结点P满足(C)A、p->ne某t==NULLB、p==NULLC、p->ne某t==headD、p==head8、在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是(B)A、O(1)B、O(n)C、O(n2)D、O(nlog2n)数据结构(第4版)习题及实验参考答案9、在一个单链表中,若删除p所指结点的后继结点,则执行(A)A、p->ne某t=p->ne某t->ne某t;B、p=p->ne某t;p->ne某t=p->ne某t->ne某t;C、p->ne某t=p->ne某t;D、p=p->ne某t->ne某t;10、在一个单链表中,若在p所指结点之后插入所指结点,则执行(B)A、->ne某t=p;p->ne某t=;B、->ne某t=p->ne某t;p->ne某t=;C、->ne某t=p->ne某t;p=;D、p->ne某t=;->ne某t=p;11、在一个单链表中,已知q是p的前趋结点,若在q和p之间插入结点,则执行(C)A、->ne某t=p->ne某t;p->ne某t=;B、p->ne某t=->ne某t;->ne某t=p;C、q->ne某t=;->ne某t=p;D、p->ne某t=;->ne某t=q;12、在线性结构中,第一个结点没有前趋结点,其余每个结点有且只有1个前趋结点。
《数据结构》习题及答案:第2章 线性表(第1次更新2012-3)
![《数据结构》习题及答案:第2章 线性表(第1次更新2012-3)](https://img.taocdn.com/s3/m/d033959769dc5022aaea00f5.png)
第2章线性表一、选择题1.表长为N 的顺序表,当在任何位置上插入或删除一个元素的概率相等时,插入一个元素所需移动元素的平均次数为(),删除一个元素需要移动的元素个数为()。
【**,★】A. (N-1)/2B. NC. N+1D. N-1E. N/2F. (N+1)/2G. (N-2)/22.线性表是具有N 个()的有限序列。
【*】A、表元素B、字符C、数据元素D、数据项E、信息3.“线性表的逻辑顺序和物理顺序总是一致的。
”这个结论是()。
【*】A、正确的B、错误的C、不一定,与具体结构有关。
4.线性表采用链式存储结构时,要求内存中可用存储单元的地址()。
【*,★】A、必须是连续的B、部分地址必须是连续的C、一定是不连续的D、连续或不连续都可以。
5.带头结点的单链表为空的判定条件是()。
【*】A、head==NULLB、head->next==NULLC、head->next==headD、head!=NULL6.不带头结点的单链表head 为空的判定条件是()。
【*】A、head==NULLB、head->next==NULLC、head->next==headD、head!=NULL7.非空的循环单链表head 的尾结点P 满足()。
(注:带头结点)【*】A、P->NEXT=NULLB、p=NULLC、p->next==headD、p==head8.在一个具有n 个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是()。
【*,★】A、O(1)B、O(n)C、O(n2)D、O(nlog2n)9.在一个单链表中,若删除P 所指结点的后继结点,则执行()。
【*,★】A、p->next=p->next->nextB、p=p->next;p->next=p->next->nextC、p->next=p->next;D、p=p->next->next;10.在一个单链表中,若在P所指结点之后插入S所指结点,则执行()。
数据结构(C++版)课后答案 (王红梅)第2章 线性表
![数据结构(C++版)课后答案 (王红梅)第2章 线性表](https://img.taocdn.com/s3/m/5ad19f1655270722192ef7d3.png)
第 2 章线性表课后习题讲解1. 填空⑴在顺序表中,等概率情况下,插入和删除一个元素平均需移动()个元素,具体移动元素的个数与()和()有关。
【解答】表长的一半,表长,该元素在表中的位置⑵顺序表中第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的存储地址是()。
【解答】108【分析】第5个元素的存储地址=第1个元素的存储地址+(5-1)×2=108⑶设单链表中指针p 指向结点A,若要删除A的后继结点(假设A存在后继结点),则需修改指针的操作为()。
【解答】p->next=(p->next)->next⑷单链表中设置头结点的作用是()。
【解答】为了运算方便【分析】例如在插入和删除操作时不必对表头的情况进行特殊处理。
⑸非空的单循环链表由头指针head指示,则其尾结点(由指针p所指)满足()。
【解答】p->next=head【分析】如图2-8所示。
⑹在由尾指针rear指示的单循环链表中,在表尾插入一个结点s的操作序列是();删除开始结点的操作序列为()。
【解答】s->next =rear->next; rear->next =s; rear =s;q=rear->next->next; rear->next->next=q->next; delete q;【分析】操作示意图如图2-9所示:⑺一个具有n个结点的单链表,在指针p所指结点后插入一个新结点的时间复杂度为();在给定值为x的结点后插入一个新结点的时间复杂度为()。
【解答】Ο(1),Ο(n)【分析】在p所指结点后插入一个新结点只需修改指针,所以时间复杂度为Ο(1);而在给定值为x的结点后插入一个新结点需要先查找值为x的结点,所以时间复杂度为Ο(n)。
⑻可由一个尾指针唯一确定的链表有()、()、()。
【解答】循环链表,循环双链表,双链表2. 选择题⑴线性表的顺序存储结构是一种()的存储结构,线性表的链接存储结构是一种()的存储结构。
数据结构(C语言描述)(第2版 李学刚 参考答案 (9)[1页]
![数据结构(C语言描述)(第2版 李学刚 参考答案 (9)[1页]](https://img.taocdn.com/s3/m/b0664d83ed3a87c24028915f804d2b160b4e8620.png)
同步训练2-1参考答案
一、单项选择题
1.线性表是(C )的有限序列。
A.数据B.数据项C.数据元素D.整型数据2.以下关于线性表叙述不正确的是(C )。
A.线性表中的数据元素可以是数字、字符、记录等不同类型
B.线性表中包含的数据元素个数不是任意的
C.线性表中的每个结点都有且只有一个直接前驱和直接后继
D.存在这样的线性表:表中各结点都没有直接前驱和直接后继
3.线性表的长度是指(B )。
A.初始时线性表中包含数据元素的个数
B.线性表中当前包含数据元素的个数
C.对线性表进行操作后线性表中包含数据元素的个数
D.线性表中可以包含数据元素的最大个数
4.线性表的容量是指(D )。
A.初始时线性表中包含数据元素的个数
B.线性表中当前包含数据元素的个数
C.对线性表进行操作后线性表中包含数据元素的个数
D.线性表中可以包含数据元素的最大个数
5.以下关于线性表叙述正确的是(C )。
A.数据元素在线性表中可以是不连续的
B.线性表是一种存储结构
C.线性表是一种逻辑结构
D.对线性表做插入或删除操作可使线性表中的数据元素不连续
6.在线性表的下列运算中,不改变数据元素之间结构关系的运算是(D )。
A.插入B.删除C.排序D.查找。
2020年国家开放大学《程序设计基础》形考任务试题题与答案
![2020年国家开放大学《程序设计基础》形考任务试题题与答案](https://img.taocdn.com/s3/m/c2312c41a216147917112867.png)
《程序设计基础》形考任务一(20分)计算机应用领域:科学计算,数据处理,过程控制,计算机辅助系统,计算机网通信。
1.总线是连接CPU、存储器、外部设备的公共信息通道。
通常由三部分组成:数据总线、地址总线、控制总线。
2.计算机是一类智能机器,这是因为它除了完成算术运算外,还能完成某些逻辑运算。
3.世界上第一台计算机取名为:ENIAC.4.目前制造计算机所采用的电子器件是:大规模集电路。
5.CPU是Central Processing Unit 的英文缩写,它主要运算器、控制器和寄存器3个部分组成。
6.完整的计算机系统是由硬件系统和软件系统两大部分组成的。
7.计算机的硬件系统一般可分为存储器、中央处理器、输入设备、输出设备等几个部分。
8.计算机的存储器分为内存和外存两级。
9.随机存储器和只读存储器的英文缩写分别为RAM 和ROM。
10.系统软件是为有效利用计算机的资源、充分发挥计算机的工作潜力、保证正常运行、尽可能方便用户使用计算机而编制的软件。
11.程序是为实现一定功能,用计算机程序设计语言所编制的语句的有序集合。
文趟是描述程序设计的过程及程序的使用方法的有关资料。
12.图灵机是计算机的概念模型,奠定了现代计算机的理论基础;冯﹡诺依曼是计算机的结构模型,奠定了现代计算机的设计基础。
13.高级语言源程序的翻译成机器语言程序一般有两种做法: 编译方式和解释方式。
14.按照使用方式,程序设计语言分为交互式语言和非交互语言;按照应用范围则分为通用语言和专用语言。
15.编译程序的核心部分,叫__语法分析器_____,其任务就是检查源程序在语法上是否有误。
二、选择题(每题2分,合计20分)1.当代计算机的最主要的体系结构称为是______。
A. 图灵机B. 冯·诺依曼机C. PASCAL机D. 非冯·诺依曼机2. 计算机软件是指______ 。
A. 源程序和目标程序B. 计算机程序C. 源程序D. 计算机程序及其有关文挡3.计算机能直接执行的语言是______。
线性表的插入和删除C++程序
![线性表的插入和删除C++程序](https://img.taocdn.com/s3/m/8e7200170b4e767f5acfce45.png)
修改内容:重新排版《数据结构》试验报告-------------线性表的插入和删除康一飞地理信息系统08-208014208一,实验目的掌握线性表的顺序存储结构的定义及C语言实现插入,删除操作掌握线性表的链式存储结构的定义及C语言实现插入,删除操作二,实验内容1定义数据元素之间的关系在计算机中又两种不同的表示方式:顺序映像和非顺序映像,由此得到两种不同的存储结构:顺序存储结构和链式存储结构。
顺序映像的特点是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系非顺序映像的特点是借助指针元素存储地址的指针表示数据元素之间的逻辑关系2顺序表的插入#include<stdio.h>#include<malloc.h>typedef struct{int elem;int length;int listsize;}SqList,* SqL;SqL CreateList_S(){int n;SqList *p,*S;S=(SqL) malloc (sizeof(SqList));S->listsize=100;printf("input the length of the list:");scanf("%d",&(S->length));printf("input the element of the list:");for(n=1,p=S;n<=(S->length);n++,p+=sizeof(SqList)) scanf("%d",&p->elem);return(S);}SqL ListInsert_S(SqL S){int e,i,m,n;loop: printf("input the place you want to insert:");scanf("%d",&i);if(i<1||i>S->length+1){printf("ERROR input again\n");goto loop;}printf("iuput the element you want to insert:");scanf("%d",&e);m=S->length;for(n=i;n<=S->length;n++){(S+m*sizeof(SqList))->elem=(S+(m-1)*sizeof(SqList))->elem;m=m-1;}(S+(i-1)*sizeof(SqList))->elem=e;S->length++;return(S);}void main(){SqList *Sa,*p;int n,i,e;Sa=CreateList_S();printf("the list is:");for(n=1,p=Sa;n<=(Sa->length);n++,p+=sizeof(SqList))prin tf("%d ",p->elem);printf("\n\n");Sa= ListInsert_S(Sa);printf("the list is:");for(n=1,p=Sa;n<=(Sa->length);n++,p+=sizeof(SqList))prin tf("%d ",p->elem);printf("\n");}3单链表的删除#include<stdio.h>#include<malloc.h>#define NULL 0typedef struct LNode{int data;struct LNode *next;}LNode,*LiL;LiL CreatList_L(){int i,n;LNode *p,*L;L=(LiL)malloc(sizeof(LNode));L->next=NULL;printf("please input the length of the list:");scanf("%d",&n);printf("input the element of the list:");for(i=0;i<n;i++){p=(LiL)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next,L->next=p;}return(L);}LiL ListDelete_L(LiL L){LNode *p;int j,e,i;loop:printf("input the place you want to delited:");scanf("%d",&i);for(j=0, p=L;j<i-1&&p->next!=NULL;j++) p=p->next;if(p->next==NULL){printf("ERROR input again\n");goto loop;}e=p->next->data;p->next=p->next->next;printf("the element you want to delited is:%d\n",e);return(L);}void main(){LNode *La,*p;int n,i,e;La=CreatList_L();printf("the list is:");for(p=La->next;p!=NULL;p=p->next)printf("%d ",p->data);printf("\n\n");La= ListDelete_L(La);printf("the list is:");for(p=La->next;p!=NULL;p=p->next)printf("%d ",p->data);printf("\n");}三、实验体会1,由于《数据结构》课本上给出的示例函数并不是完全由C语言写出,包含了一些伪代码,所以不可以直接拿来使用,一定要结合具体的程序设计实际例题用严格的C语言编写出才能通过编译2. 程序中用了大量的指针,在定义和使用它时要分清楚哪些是代表指针,哪些是代表指针所指向的地址,以及哪些是其他的类型,我在编程中就因为没有把握好这几种类型,耗费了许多时间来检查错误3. 在调用和创建函数时,注意函数使用的各种规则,注意函数类型和返回值,参见C语言课本4. 编写两个程序时,要注意两种存储结构的线性表的不同,不要把二者的一些东西混淆5 一些小细节,比如:单链表输出时令p=La->next,而不是p=La;以及程序中作为计数器使用的一些int型变量的起始值,可能以为一个数的差别导致程序运行错误,要反复检查实验才能得到正确结果6 由于能力有限,除了“插入/删除位置有误”外,没有对其他复杂情况分析,值编写了简单的数字线性表的操作康一飞地理信息系统08-2班 08014208。
数据结构--实验报告 线性表的基本操作
![数据结构--实验报告 线性表的基本操作](https://img.taocdn.com/s3/m/8fd4de0c6c85ec3a87c2c5e2.png)
一、实验目的二、实验内容和要求三、源代码1)顺序表的代码2)单链表的代码四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现。
4、掌握顺序表的存储结构形式及其描述和基本运算的实现。
5、熟练掌握动态链表结构及有关算法的设计二、实验内容题目一:顺序表的基本操作[问题描述]实现顺序表的建立、求长度,取元素、修改元素、插入、删除等顺序表的基本操作。
[基本要求](1)依次从键盘读入数据,建立带头结点的顺序表;(2)输出顺序表中的数据元素(3)求顺序表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法,将两个有序的顺序表合并成一个有序顺序表。
[测试数据] 由学生任意指定。
题目二:单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求](1)依次从键盘读入数据,建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法,将两个有序的单链表合并成一个有序单链表。
[测试数据]由学生任意指定。
三、源代码(一)顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for (p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}Status Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++)L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q;if(i<1 || i>L.length) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p) *(p-1)=*p;--L.length;return OK;}Status Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度:";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度:"; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度:"; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下:"; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break; case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误,请重新选择"<<endl;break; }}}(二)单链表的基本操作#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在 e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点 if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点,并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) { //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个):"<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个):"<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);default : cout<<"输入有误,请重新输入"<<endl;break;}}}四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时,我有点惊讶,才学了不到一个月,就要写实验报告。
数据结构课程实验报告
![数据结构课程实验报告](https://img.taocdn.com/s3/m/2ea204020a4c2e3f5727a5e9856a561252d321a3.png)
数据结构课程实验报告一、实验目的本次数据结构课程实验的主要目的是通过实践掌握常见数据结构的基本操作,包括线性结构、树形结构和图形结构。
同时,也要求学生能够熟练运用C++语言编写程序,并且能够正确地使用各种算法和数据结构解决具体问题。
二、实验内容本次实验涉及到以下几个方面:1. 线性表:设计一个线性表类,并且实现线性表中元素的插入、删除、查找等基本操作。
2. 栈和队列:设计一个栈类和队列类,并且分别利用这两种数据结构解决具体问题。
3. 二叉树:设计一个二叉树类,并且实现二叉树的遍历(前序遍历、中序遍历和后序遍历)。
4. 图论:设计一个图类,并且利用图论算法解决具体问题(如最短路径问题)。
三、实验过程1. 线性表首先,我们需要设计一个线性表类。
在这个类中,我们需要定义一些成员变量(如线性表大小、元素类型等),并且定义一些成员函数(如插入元素函数、删除元素函数等)。
在编写代码时,我们需要注意一些细节问题,如边界条件、异常处理等。
2. 栈和队列接下来,我们需要设计一个栈类和队列类。
在这两个类中,我们需要定义一些成员变量(如栈顶指针、队头指针等),并且定义一些成员函数(如入栈函数、出栈函数、入队函数、出队函数等)。
在编写代码时,我们需要注意一些细节问题,如空间不足的情况、空栈或空队列的情况等。
3. 二叉树然后,我们需要设计一个二叉树类,并且实现二叉树的遍历。
在这个类中,我们需要定义一个节点结构体,并且定义一些成员变量(如根节点指针、节点数量等),并且定义一些成员函数(如插入节点函数、删除节点函数、遍历函数等)。
在编写代码时,我们需要注意一些细节问题,如递归调用的情况、空节点的情况等。
4. 图论最后,我们需要设计一个图类,并且利用图论算法解决具体问题。
在这个类中,我们需要定义一个邻接矩阵或邻接表来表示图形结构,并且定义一些成员变量(如顶点数量、边的数量等),并且定义一些成员函数(如添加边函数、删除边函数、最短路径算法等)。
数据库系统l试题库及答案第3章栈与队列
![数据库系统l试题库及答案第3章栈与队列](https://img.taocdn.com/s3/m/14d03afba300a6c30d229f9a.png)
第3章栈和队列3.1栈一、填空题1. 线性表、栈和队列都是________ 结构,可以在线性表的__________ 位置插入和删除元素;对于栈只能___________插入和删除元素;对于队列只在 ____________ 插入元素,并且只在____________ 删除元素。
2. 栈是一种特殊的线性表,允许插入和删除运算的一端称为____________ 。
不允许插入和删除运算的一端称为_________ 。
3. 向栈中压入元素的操作是先____________ ,后 _______ 。
4. 从栈中弹出元素的操作是先____________ ,后 ________ 。
二、选择题:1. ()栈中元素的进出原则是()。
A.先进先出 B .后进先出C .栈空则进D .栈满则出2. ()若已知一个栈的入栈序列是1 , 2, 3,…,n,其输出序列为pl, p2, p3,…,pn,若p仁n,贝U pi为()。
A. i B . n=i C . n-i+1 D .不确定3. ()判定一个栈ST (最多元素个数为m0)为空的条件是()。
A. ST->top<>0 B . ST->top=0 C . ST->top<>mO D . ST->top=mO4. ()有六个元素1,2,3,4,5,6 的顺序进栈,问下列哪一个不是合法的出栈序列?()A. 1,2,3,4,5,6B. 5,4,3,2,1,6C. 4,3,2,1,5,6D. 6,5,4,3,1,25. ()将递归算法转换成非递归算法时,通常要借助的数据结构是()。
A.线性表B. 栈C. 队列D. 树6. ()若栈采用顺序存储方式存储,现两栈共享空间V[1..m] , top[i]代表第i个栈(i =1,2)栈顶,栈1的底在v[1],栈2的底在V[m],则栈满的条件是()。
A. |top[2]-top[1]|=0B. top[1]+1=top[2]C. top[1]+top[2]=mD. top[1]=top[2]7. ()一个递归算法必须包括()。
线性表的创建和操作
![线性表的创建和操作](https://img.taocdn.com/s3/m/d226d0da29ea81c758f5f61fb7360b4c2e3f2ae0.png)
线性表的创建和操作//对顺序表的操作#include<stdio.h>#include <stdlib.h>#include<malloc.h>#define MAXSIZE 1000typedef char ElemType;typedef struct{ElemType data[MAXSIZE];int length;}SqList;//初始化线性表void InitList(SqList*&L){L=(SqList*)malloc(sizeof(SqList));L->length=0;}//销毁线性表void DestoryList(SqList*&L){free(L);}//判断线性表是否为空int ListEmpty(SqList*L){return(L->length==0);}//插⼊数据元素,起始位置为1int ListInsert(SqList*&L,int Position,ElemType item){int j;if(Position<1||Position>L->length+1){printf("元素插⼊失败,请检查输⼊的位置是否有错!\n");return 0;}Position--;for(j=L->length;j>Position;j--){L->data[j]=L->data[j-1];}L->data[Position]=item;L->length++;printf("元素插⼊成功\n");return 1;}//替换第Position个元素的值int ListReplace(SqList*&L,int Position,ElemType item){if(Position<1||Position>L->length){printf("元素位序号错误! \n");return 0;}Position--;L->data[Position]=item;printf("元素存放成功!\n");return 1;}//删除数据元素int ListDelete(SqList*&L,int Position,ElemType &item){int j;if(Position<1||Position>L->length){printf("输⼊的位号有误!\n");return 0;}Position --;item=L->data[Position];for(j=Position;j<L->length-1;j++){L->data[j]=L->data[j+1];}L->length--;return 1;}//输出线性表void DispList(SqList *L){int i;if(ListEmpty(L)){printf("表空!\n");return;}for(i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}//求线性表中某个数据元素值int GetElem(SqList*L,int Position,ElemType&item) {if(Position<1||Position>L->length){return 0;}item=L->data[Position-1];return 1;}//求线性表的长度int ListLength (SqList*L){return(L->length);}//按元素值查找int LocateElem(SqList*L,ElemType item){int i=0;while(i<L->length&&L->data[i]!=item)i++;if(i>=L->length)return 0;elsereturn i+1;}void clear(){system("pause");system("cls");}void showmenu(){printf("\n\n\n");printf(" --线性表的基本运算-- \n");printf("********************************************\n"); printf("* 1---插⼊⼀个新元素到第i个位置 *\n"); printf("* 2---删除第i个位置的元素 *\n");printf("* 3---存⼀个新元素到第i个位置 *\n"); printf("* 4---显⽰顺序表中所有元素的值 *\n"); printf("* 5---检索表中第i个元素 *\n");printf("* 6---求表的长度 *\n");printf("* *\n");printf("* 0---退出 *\n");printf("********************************************"); printf("\n请选择菜单号(0--6):");}void Charu(){SqList*L;InitList(L);//创建⼀个顺序表char choice='N';ElemType item;int Position;printf("请输⼊⼀个新元素的值:");flushall();scanf("%c",&item);printf("请输⼊插⼊的位置:");scanf("%d",&Position);ListInsert(L,Position,item);}void Shanchu(){char choice='N';ElemType item;int Position;SqList*L;InitList(L);//创建⼀个顺序表printf("请输⼊要删除的元素的位置序号:");scanf("%d",&Position);if(ListDelete(L,Position,item)){printf("删除的元素为%c\n",item);}}void Xiugai(){char choice='N';ElemType item;int Position;SqList*L;InitList(L);//创建⼀个顺序表printf("请输⼊⼀个新元素的值:");flushall();scanf("%c",&item);printf("请输⼊该元素的存放位置:");scanf("%d",&Position);ListReplace(L,Position,item);}void Jiansuo(){char choice='N';ElemType item;int Position;SqList*L;InitList(L);//创建⼀个顺序表printf("请输⼊元素的位序号:");scanf("%d",&Position);if(GetElem(L,Position,item)){printf("第%d个元素为:%c\n",Position,item); }else{printf("输⼊的位序号有误!\n");}}void LineOP(){char choice='N';ElemType item;int Position;SqList*L;InitList(L);//创建⼀个顺序表while(choice!='0'){showmenu();flushall();scanf("%c",&choice);switch(choice){case'1':Charu();clear();break;case'2':Shanchu();clear();break;case'3':Xiugai();clear();break;case'4':DispList(L);clear();break;case'5':Jiansuo();clear();break;case'6':printf("线性表的长度为%d",ListLength(L)); clear();break;case'0':printf("\n\t程序结束!\n");DestoryList(L);break;default:printf("\n\t选择错误,请重新输⼊!\n"); break;}}}int main(){LineOP();return 0;}。
使用C语言编写程序,实现顺序表的基本运算——插入和删除
![使用C语言编写程序,实现顺序表的基本运算——插入和删除](https://img.taocdn.com/s3/m/524f7f65f242336c1eb95e78.png)
1.编写一个程序,使用一维数组来表示线性表;
2.实现元素x的插入i位置操作。
3.实现元素ai元素的删除操作。
typedef struct
{
int *elem;
int length;
int listsize;
if(Create_sq(&L1,n)==1)
{
scanf("%d%d",&i,&e);
a=Listinsert_sq(&L1,i,e);
if(a==1)
printf("insert success\n");
else printf("insert false\n");
printf("the list elements are:\n");
for(i=1;i<=L1.length;i++)Fra bibliotek {
printf("%d\t",L1.elem[i-1]);
}
}
return 0;
}
{
newbase=(int*)realloc(L->elem,(L->listsize+10)*sizeof(int));
if(!newbase) exit(-2);
L->elem=newbase;
L->listsize+=10;
}
q=&(L->elem[i-1]);
for(p=&(L->elem[L->length-1]);p>=q;--p)
数据结构C语言版期末考试试题(有答案)
![数据结构C语言版期末考试试题(有答案)](https://img.taocdn.com/s3/m/2ea94fe1541810a6f524ccbff121dd36a32dc4e3.png)
抽出时间去学习,凡事从小做起,不怕单调和重复,长期的积累坚持,想不成功,也难。
"数据结构”期末考试试题一、单选题(每小题2分共12分)1.在一个单链表HL中若要向表头插入一个由指针p指向的结点则执行()A. HL=ps p一〉next=HLB. p一>next=HL;HL=p3C. p一>next=Hl;p=HL;D. p一〉next=HL一>next;HL一〉next=p;2.n个顶点的强连通图中至少含有()A。
n—l条有向边 B.n条有向边C.n(n—1)/2条有向边D.n(n一1)条有向边3.从一棵二叉搜索树中查找一个元素时其时间复杂度大致为( )A.O(1) B。
O(n)C.O(1Ogzn)D.O(n2)4.由权值分别为38625的叶子结点生成一棵哈夫曼树它的带权路径长度为( )A.24 B.48C. 72 D. 535.当一个作为实际传递的对象占用的存储空间较大并可能需要修改时应最好把它说明为( )参数以节省参数值的传输时间和存储参数的空间A.整形 B。
引用型C。
指针型 D。
常值引用型·6.向一个长度为n的顺序表中插人一个新元素的平均时间复杂度为( )A.O(n) B.O(1)C.O(n2) D.O(10g2n)二、填空题(每空1分共28分)1.数据的存储结构被分为——、——、——和--四种2.在广义表的存储结构中单元素结点与表元素结点有一个域对应不同各自分别为-—域和——域3.——中缀表达式 3十x*(2。
4/5—6)所对应的后缀表达式为—-——4.在一棵高度为h的3叉树中最多含有—-结点5.假定一棵二叉树的结点数为18则它的最小深度为-—最大深度为--·6.在一棵二叉搜索树中每个分支结点的左子树上所有结点的值一定-—该结点的值右子树上所有结点的值一定-—该结点的值7.当向一个小根堆插入一个具有最小值的元素时该元素需要逐层-—调整直到被调整到--位置为止8.表示图的三种存储结构为——、——和---9.对用邻接矩阵表示的具有n个顶点和e条边的图进行任一种遍历时其时间复杂度为—-对用邻接表表示的图进行任一种遍历时其时间复杂度为—-10.从有序表(1218304356788295)中依次二分查找43和56元素时其查找长度分别为—-和-—·11.假定对长度n=144的线性表进行索引顺序查找并假定每个子表的长度均为则进行索引顺序查找的平均查找长度为——时间复杂度为——·12.一棵B-树中的所有叶子结点均处在——上13.每次从无序表中顺序取出一个元素把这插入到有序表中的适当位置此种排序方法叫做——排序;每次从无序表中挑选出一个最小或最大元素把它交换到有序表的一端此种排序方法叫做-—排序14.快速排序在乎均情况下的时间复杂度为——最坏情况下的时间复杂度为—-三、运算题(每小题6分共24分)1.假定一棵二叉树广义表表示为a(b(cd)c(((8)))分别写出对它进行先序、中序、后序和后序遍历的结果先序:中序;后序:2.已知一个带权图的顶点集V和边集G分别为: V={012345};E={(01)8(02)5(03)2(15)6(23)25(24)13(35)9(45)10}则求出该图的最小生成树的权最小生成树的权;3.假定一组记录的排序码为(4679563840845042)则利用堆排序方法建立的初始堆为—-4.有7个带权结点其权值分别为378261014试以它们为叶子结点生成一棵哈夫曼树求出该树的带权路径长度、高度、双分支结点数带权路径长度:-—高度:-—双分支结点数:-—四、阅读算法回答问题(每小题8分共16分)1.VOldAC(List&L){InitList(L);InsertRear(L;25);InsertFront(L50);IntaL4]={58121536};for(inti=0; i〈5; i++)if (a[i]%2==0)InsertFront(La[i]);elselnsertRear(La[i]);}该算法被调用执行后得到的线性表L为:2.void AG(Queue&Q){InitQueue(Q);inta[5]={6125158};for(int i=0;i〈5; i++)QInsert(Qa[i]);QInsert(QQDelete(Q));QInsert(Q20);QInsert(QQDelete(Q)十16);while(!QueueEmpty(Q))cout〈<QDelete(Q)〈〈”; }该算法被调用后得到的输出结果为:五、算法填空在画有横线的地方填写合适的内容(每小题6分共12分)1.从一维数组A[n)中二分查找关键字为K的元素的递归算法若查找成功则返回对应元素的下标否则返回一1IntBinsch(ElemTypeA[]Intlowint highKeyTypeK){if(low〈=high){int mid=(low+high)/2;if(K==A[mid].key)—-;else if (K<A[mid].key)-—;else ;}else return—l;}2.已知二叉树中的结点类型BinTreeNode定义为:structBinTreeNode{ElemType data;BinTreeNode*left*right};其中data为结点值域left和right分别为指向左、右子女结点的指针域下面函数的功能是返回二叉树BT中值为x的结点所在的层号请在划有横线的地方填写合适内容Int NodeLevel(BinTreeNode * BTElemType X){if(BT:=NULL)return 0;//空树的层号为0else if(BT一>data==X)return 1; //根结点的层号为1 //向子树中查找x结点else{int cl=NodeLevel(BT一>leftX);if(cl>=1)return cl+1;int c2=;if-—;//若树中不存在X结点则返回oelse return 0;}}六、编写算法(8分)按所给函数声明编写一个算法从表头指针为HL的单链表中查找出具有最大值的结点该最大值由函数返回若单链表为空则中止运行EIemType MaxValue(LNOde*HL);”数据结构”期末考试试题答案一、单选题(每小题2分共12分)评分标准;选对者得2分否则不得分1.B 2.B 3.C 4.D 5.B 6.A二、填空题(每空1分共28分)1.顺序结构链接结构索引结构散列结构(次序无先后) 2.值(或data) 子表指针(或sublist)3.3 x 2.4 5/6一*十4.(3h一1)/25. 5 186.小于大于(或大于等于)7.向上堆顶8.邻接矩阵邻接表边集数组(次序无先后)9.O(n2) O(e)10. 1 311.13 O()12.同一层13.插人选择14.O(nlog2n) O(n2)三、运算题(每小题6分共24分)1.先序:abcdefe //2分中序:cbdaf8e //2分后序:cdbefea //2分2.最小生成树的权:31 //6分3.(8479564240465038)//6分4.带权路径长度:131 //3分高度:5 //2分双分支结点数:6 //1分四、阅读算法回答问题(每小题8分共16分)评分标准:每小题正确得8分出现一处错误扣4分两处及以上错误不得分1.(361285025515)2.5 15 8 6 20 28五、算法填空在画有横线的地方填写合适的内容(每小题6分共12分)1.feturn mid //2分returnBinsch(Alowmid一1K) //2分returnBmsch(Amid+1highK)//2分2.NodeLevel(BT一>rightX) //3分(c2〉=1)returnc2十1 //3分六、编写算法(8分)评分标准:请参考语句后的注释或根据情况酌情给分ElemType MaxValue(LNodeO* HL){if (HL==NUlL){//2分cerr〈<”Linked llst is empty!"<〈endl;exit(1);}ElemTypemax:HL一〉data;//3分LNOde*p=HI一>next; //4分while(P!:NULL){ //7分if(max<p一>data)max=p一〉data;p=p一〉next;}returnmax;//8分}数据结构复习资料一、填空题1. 数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和运算等的学科2. 数据结构被形式地定义为(DR)其中D是数据元素的有限集合R是D上的关系有限集合3。
线性表的插入与删除实验报告
![线性表的插入与删除实验报告](https://img.taocdn.com/s3/m/1c22ef0ea6c30c2259019e49.png)
void main()
{
clock_t start,finish;
int a[1000],out[N],i,j,k;
for(i=0;i<1000;i++)
a[i]=-1;
double duration;
start=clock();
ifstream infile("integer.dat");
for(k=0;a[k]!=-1;k++)
{
cout<<a[k]<<'\t';
}
}
finish=clock();
duration=(double)(finish-start)/CLOCKS_PER_SEC;
cout<<endl<<"所用时间"<<duration<<"秒"<<endl;
}
(3)、
#include<iostream.h>
其中mod(*)是模运算,INT(*)是取整函数。
2、线性表的插入与删除:
在本实验中线性表是动态增长的。插入一个新元素后,为了使线性表仍保持有序,必须要找到新元素应插入的位置。实际上这是一个插入排序的问题。为了要将新元素插入到一个有序的线性表中,可以从原有序表的最后一个元素开始,往前逐个与新元素比较,并将大于新元素的所有元素都往后移动一个位置,直到找到新元素应插入的位置为止。显然,插入一个新元素后,表的长度也增加了1。现假设用一个数组L(1:m)来存储线性表,其中m为最大容量(在本实验中为m=1000);用一个变量n表示线性表的长度(在本实验中,其初值为n=0)。则可以得到将新元素插入到有序线性表的算法如下。
线性表的插入和删除数据结构
![线性表的插入和删除数据结构](https://img.taocdn.com/s3/m/4c3ea862492fb4daa58da0116c175f0e7cd119f4.png)
线性表的插入和删除(数据结构) 线性表是一种基本的数据结构,它由一组有序的元素构成,每个元素最多只有一个前驱和一个后继。
在数据结构中,线性表可以通过链式存储和顺序存储两种方式来实现。
其中,链式存储使用节点来存储数据和地址,顺序存储则使用数组来存储数据。
下面就以链式存储为例,介绍一下线性表的插入和删除操作。
一、线性表的插入在线性表中插入一个元素,需要遵循以下步骤:1.申请一个新节点,并将要插入的元素存储在新节点中。
2.如果该元素要插入到链表的头部,直接将该节点插入到头节点的位置,并更新头节点指针;否则,遍历链表直到找到要插入的位置。
3.将新节点插入到要插入的位置,并修改该节点的前驱和后继节点的指针,使其指向新节点。
4.更新头节点指针,使其指向新的头节点。
struct Node {int data;struct Node *next;};void insert(struct Node **head_ref, int new_data){struct Node *temp, *new_node;new_node = (struct Node *)malloc(sizeof(struct Node));new_node->data = new_data;new_node->next = (*head_ref);(*head_ref) = new_node;}在以上示例代码中,insert函数使用了传引用技术的指针来操作头节点指针head_ref。
通过传递头节点的地址,该函数可以修改头节点指针。
函数先将头节点指针所指向的头节点保存到temp节点中,然后将新节点的data域设置为new_data,将新节点的next域设置为头节点原先指向的节点,最后将头节点指针指向新节点。
这样就完成了在链表头部插入一个节点的操作。
二、线性表的删除在线性表中删除一个元素,需要遵循以下步骤:1.遍历链表,找到要删除的元素所在的节点。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#include <iostream>
using namespace std;
struct node
{
node(int i,char *item2):data(i),data2(item2),left(NULL),right(NULL){}
int data;
char *data2;
node *left; //左孩子结点
node *right; //右孩子结点
void inorder(node *&root) //中序遍历,符合升序输出
{
if(root!=NULL)
{
inorder(root->left);
cout<<root->data<<' '<<root->data2<<endl;
inorder(root->right);
}
}
void insert(node *&ptr,int item,char item2[10]) //在查找树中插入元素
{
if(ptr==NULL)
ptr=new node(item,item2);
else if(item<ptr->data)
insert(ptr->left,item,item2);
else insert(ptr->right,item,item2);
}
node *&findy(node *&ptr,int item) //在查找树中查找肯定存在的元素,并返回其引用
{
if(ptr->data==item)
return ptr;
else if(item<ptr->data)
findy(ptr->left,item);
else findy(ptr->right,item);
}
void dele(node *&ptr) //删除值为item所在结点
{
if(ptr->left==NULL&&ptr->right==NULL)
ptr=NULL;
else if(ptr->right==NULL)
ptr=ptr->left;
else if(ptr->left==NULL)
ptr=ptr->right;
else
{
node *temp=ptr->left;
ptr=ptr->right;
node *temp2=ptr;
while(temp2->left!=NULL)
temp2=temp2->left;
temp2->left=temp;
}
}
node *find(node *&ptr,int item) //在查找树中查找元素,找到返回所在结点指针,找不到返回空指针。
{
if(ptr==NULL)
return NULL;
if(ptr->data==item)
return ptr;
else if(item<ptr->data)
find(ptr->left,item);
else find(ptr->right,item);
}
};
int main()
{
char a,b[100][10];
int t,i=0,j;
cout<<"输入结点个数:";
cin>>t;
cout<<"输入"<<t<<"个结点,结点之间用回车隔开(结点格式例子1,li):"<<endl; cin>>j>>a>>b[0];
node *x=new node(j,b[0]);
for(;i<t-1;i++)
{
cin>>j>>a>>b[i+1];
x->insert(x,j,b[i+1]);
}
cout<<"中序遍历为:"<<endl;
x->inorder(x); //作中序遍历
cout<<"\n输入要删除的结点元素关键值(输入-1程序结束):";
cin>>j;
while(j!=-1)
{
node *t=x->find(x,j); //定位结点
if(t!=NULL)
{
node *&y=x->findy(x,j);
x->dele(y);
cout<<"中序遍历为:"<<endl;
x->inorder(x);
}
else
cout<<"无"<<j;
cout<<"\n输入要删除的结点元素关键值(输入-1程序结束):";
cin>>j;
}
return 0;
}。