线性表的插入和删除

合集下载

实验01 线性表的基本操作

实验01 线性表的基本操作

实验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时无需移动)。

数据结构-线性表输入,输出,插入,删除,查找

数据结构-线性表输入,输出,插入,删除,查找

创建一个线性表实现输入,输出,插入,删除,定位。

(注意:不论在调用哪个函数前,都要先使L.elem=a,就是使指针elem回到数组a的首地址。

)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType; //接下来ElemType代表的就是inttypedef int Status; //Status也代表intint i,*p,*q; //p,q都是指针类型ElemType e;typedef struct{ElemType *elem; //定义成指针类型//存储空间基址int length; //当前长度int listsize; //当前分配的存储容量(以sizeof(ElemType)为单位) }SqList;//***********************构建空的线性表*************************// Status InitList_Sq(SqList &L) //构建一个空的线性表L{L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW); //存储分配失败L.length=0; //空表长度为0L.listsize=LIST_INIT_SIZE; //初始存储容量return OK;}//**************************线性表输入函数*********************//void input(SqList &L) //输入函数{scanf("%d",L.elem); //要先输入一个,不然一开始就是0,无法进行循环while(*L.elem) // 加*是因为elem是指针,加之后才代表值{L.elem++; //输入后指针后移L.length++; //表长加1scanf("%d",L.elem); //循环中也要再输入}}//**************************线性表打印函数********************//void print(SqList &L) //输出函数{int n;for(n=0;n<L.length;n++){printf("%d\t",*L.elem);L.elem++; //输出后指针后移}}//***********线性表插入函数(在第i个位置插入一个数据e)*************// Status ListInsert_Sq(SqList &L,int i,ElemType e)//插入函数{//在顺序线性表L中第i个位置之前插入新的元素e//i的合法值为1<=i<=ListLength.Sq(L)+1Status *newbase;指针类型。

实验一 线性表的插入和删除

实验一 线性表的插入和删除

实验一线性表的插入和删除一、实验目的1、掌握用Turbo C上机调试线性表的基本方法;2、掌握线性表的基本操作,插入、删除、查找,以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。

二、实验内容线性表基本操作的实现当我们要在线性表的顺序存储结构上的第i个位置上插入一个元素时,必须先将线性表的第i个元素之后的所有元素依次后移一个位置,以便腾空一个位置,再把新元素插入到该位置。

若要删除第i个元素时,也必须把第i个元素之后的所有元素前移一个位置。

程序实现:typedef Null 0;typedef int datatype;#define maxsize 1024;typedef struct{ datatype data[maxsize];int last;}sequenlist;int insert(L, x, i)sequenlist *L;int i;{ int j;if ((*L).last= =maxsize-1){ printf(“overflow”);return Null;}elseif ((i<1)‖(i>(*L).last+1){ printf(“error”);return Null;}else{ for(j=(*L).last; j>=i-1; j--) (*L).data[j+1]=(*L).data[j]; (*L).data[i-1]=x;(*L).last=(*L).last+1;}return(1);}int delete(L,i)sequenlist *L;int i;{ int j;if ((i<1)‖(i>(*L).last+1)){printf (“error”);return Null;}else{ for(j=i, j<=(*L).last; j++)(*L).data[j-1]=(*L).data[j];(*L).data - -;}return(1);}void creatlist( ){ sequenlist *L;int n, i, j;printf(“请输入n个数据\n”); scanf(“%d”,&n);for(i=0; i<n; i++){ printf(“data[%d]=”, i);scanf (“%d”, (*L).data[i]);}(*L).last=n-1;print f(“\n”);}printout (L)sequenlist *L;{ int i;for(i=0; i<(*L).last; i++){ printf(“data[%d]=”, i);printf(“%d”, (*L).data[i]);}}main( ){ sequenlist *L;char cmd;int i, t;clscr( );printf(“i, I…..插入\n”);printf(“d,D…..删除\n”);printf(“q,Q……退出\n”);do{ do{cmd =getchar( );}while((cmd!=‘d’)‖(cmd!=‘D’)‖(cmd!=‘q’)‖(cmd!=‘Q’)‖(cmd!=‘i’)‖(cmd!=‘I’));switch (cmd){ case ‘i’,‘I’; scanf(&x);scanf(&i);insert(L, x, i);printout(L);break;case ‘d’,‘D’; scanf(&i);delete(L, i);printout(L);break;}}while ((cmd!=‘q’)&&( cmd!=‘Q’));}。

线性表PPT.

线性表PPT.

条件(i<1 || i>pslist->length)也包括对表空的检查。
检查要删除位置的有效性,1≤i≤n 。
删除ai后,该数据已不存在。
顺序表的基本运算
⒋ 按值查找 线性表中的按值查找是指在线性表中查找与给
定值x相等的数据元素,并返回查找成功与否标志。 算法分析
从第一个元素a1起依次和x比较,直到找到一个 与x相等的数据元素,则返回它在顺序表中的存储下 标或序号(二者差一);如果没有找到,返回-1。
return i; /*返回存储位置,即序号*/ }
顺序表的基本运算
时间复杂度分析: 本算法的主要运算是比较,比较次数与x的位置有
关,也与表长有关,当a1=x时,比较一次成功,当 an=x时,比较n次成功,平均比较次数为(n+1)/2,时间 复杂度为O(n)。
顺序表的基本运算
⒌ 查找操作
查找顺序表中第i个位置上的元素值ai,并将该 元素的值返回。
面的值均比a1小,a1后面的值都比a1大。。
划分前 12 26 8 11 19 10 …
划分后 10 11 8 12 26 19 …
顺序表的应用
算法分析
从第二个元素开始
第三课时 水上安全
31.、需请⑴求有咨骑询自当(行分车前析经)验数的学据生交比流。a1大时,不改变其位置,继续比较下一个。
8.交车服务
return(pslist->length); /*求pslist所指向顺序表的长度*/ }
1 完善SeqList_yanshi_1.c,熟悉顺序表的存 储结构及运算。
选:完善SeqList_yanshi_2.c ,体会 typedef及抽象数据类型Elemtype的作用。

数据结构第一次作业

数据结构第一次作业
【输入形式】
第一行为第一个链表的各结点值,以空格分隔。
第二行为第二个链表的各结点值,以空格分隔。
【输出形式】
合并好的链表,以非降序排列,值与值之间以空格分隔。
【样例输入】
4 7 10 34
1 4 6 29 34 34 52
【样例输出】
1 4 6 7 10 29 34 52
【评分标准】
要使用链表实现,否则不能得分。
3.设n为大于1的正整数,计算机执行下面的语句时,带#语句的执行次数为n。
i=1;
j=0;
while(i+j<=n){
# if(i>j)
j++;
else
i++;
}
4.在具有n个链结点的链表中查找一个链结点的时间复杂度为O(n)。
5.下面程序段的时间复杂度为O(mn)。
for ( i = 0; i < n; i++ )
D.每个链结点有多少个直接后继结点,它就应该设置多少个指针域
8.将长度为m的线性链表链接在长度为n的线性链表之后的过程的时间复杂度若采用大O形式表示,则应该是B。
A.O(m) B.O(n) C.O(m+n) D.O(m-n)
9.在一个单链表中,若要在p所指向的结点之后插入一个新结点,则需要相继修改__个指针域
int time (int n) {
int count=0, x=2;
while ( x < n/2 ) {
x=2x;
count++;
}
return (count);
}
时间复杂度:O(logn)
count值:logn-2

栈是限制在表尾进行插入和删除操作的线性表

栈是限制在表尾进行插入和删除操作的线性表

栈是限制在表尾进⾏插⼊和删除操作的线性表栈是限制在表尾进⾏插⼊和删除操作的线性表。

栈的主要特点是“后进先出”。

允许插⼊、删除的这⼀端称为栈顶(Top),另⼀端称为栈底(Bottom)。

栈的运算包含1.进栈2.出栈3.读栈顶元素4. 判栈空5. 判栈满6. 显⽰栈元素下⾯⽤Java实现⼀个简单的栈:异步代码,更快。

package zieckey.datastructure.study.stack;/*** Demonstrates stacks** @author*/public class StackX{private int maxSize;// size of stack arrayprivate double[] stackArray;private int top;// top of stackpublic StackX(int maxSize ){this.maxSize = maxSize;// 设置数组⼤⼩stackArray =new double[maxSize];// 创建数组top =-1;// 还没有任何元素}public void push(double j ){// ⼊栈if( isFull()){System.out.println("Cannot insert item "+ j +"! The stack is full.");}else{top++;stackArray[top]= j;}}public double pop(){// 出栈if(isEmpty()){System.out.println("The stack is empty.");return 0.0;}else{return stackArray[top--];}}public double peek()public double peek(){// 返回栈顶元素return stackArray[top];}public boolean isEmpty(){return(-1 == top );}public boolean isFull(){return( maxSize - 1 == top ); }}。

线性表的插入和删除(数据结构)

线性表的插入和删除(数据结构)

电子信息工程学系实验报告——适用于计算机课程课程名称:Array实验项目名称:线性表的插入和删除实验时间: 2012、3、班级:计应102 姓名:学号:实验目的:熟悉掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现,并熟悉其各自的优缺点及适用性。

实验环境:C—Free5.0实验内容及过程:题目1:编写程序实现下列的要求:(1) 设数据元素为整数,实现这样的线性表的顺序存储表示。

(2) 键盘输入10个数据元素,利用顺序表的基本操作,建立该表。

(3) 利用顺序表的基本操作,找出表中的最大的和最小的数据元素(用于比较的数据元素为整数)。

(4) * 若数据元素为学生成绩(含姓名、成绩等字段),重新编程,实现上面的要求。

要求尽可能少地修改前面的程序来得到新程序。

(这里用于比较的字段为分数)题目2:编写程序实现下列的要求:(1) 设学生成绩表中的数据元素为学生成绩(含姓名、成绩字段),实现这样的线性表的链式存储表示。

(2) 键盘输入若干个数据元素(用特殊数据来标记输入数据的结束),利用链表的基本操作(前插或后插算法),建立学生成绩单链表。

(3) 键盘输入关键字值x,打印出表中所有关键字值<=x的结点数据。

(用于比较的关键字字段为分数)。

(4) 输入关键字值x,删除表中所有关键字值<=x的结点。

(用于比较的关键字字段为分数)。

实验结果及分析:题目一:(4):题目二:实验心得:通过这次的实验,对线性表和单链表的创建和修改有了初步的认识,和同学的讨论互相弥补了不足,相信在未来的学习中会有更大的收获。

附录:题目一代码:#include "stdio.h"#include "conio.h"typedef int datatype;struct seqlist{int maxnum;int n;datatype *element;};typedef struct seqlist *Pseqlist;Pseqlist creatnulllist_seq(int m) /* 建立空的顺序表*/{Pseqlist p=(Pseqlist)malloc(sizeof(struct seqlist));if(p!=NULL){p->element=(datatype *)malloc(sizeof(datatype)*m);if(p->element!=NULL){p->maxnum=m;p->n=0;}else free(p);}printf("out of space");return NULL;}Pseqlist init_seq(Pseqlist p,int n) /* 初始化空的顺序表,即填充数据,顺序表的实际元素个数n 由参数提供*/{int i;printf("input the element of seqlist:");for(i=0;i<n;i++)scanf("%d",&p->element[i]);p->n=n;return(p);}int insertpost_seq(Pseqlist p,int i,datatype x) /* 在i之后插入一个元素x */{int j;if(p->n>=p->maxnum){printf("overflow");return(0);}if(i<0 || i>p->n ){printf("not exist");return(0);}for(j=p->n-1; j>=i+1; j--)p->element[j+1]=p->element[j];p->element[i+1]=x;p->n++;return(1);}void print(Pseqlist p) /* 打印顺序表中的元素*/{int i;for(i=0;i<p->n;i++)int FinMax(Pseqlist p){int max=p->element[0];int i;for(i=1;i<p->n;++i){if(max<p->element[i])max=p->element[i];}return max;}int FinMin(Pseqlist p){int min=p->element[0];int i;for(i=1;i<p->n;++i){if(min>p->element[i])min=p->element[i];}return min;}main(){Pseqlist p;int m,n,i,x,k;printf("input the size of seqlist m:"); /* 输入顺序表的最大空间m,建立空的顺序表*/ scanf("%d",&m);p=creatnulllist_seq(m);printf("input the real number of seqlist n(n<m):"); /* 输入顺序表的实际长度n,初始化顺序表*/ scanf("%d",&n);p=init_seq(p,n);/* 输出插入之前顺序表的元素*/ print(p);printf("\n");printf("input i,x:");scanf("%d%d",&i,&x); /* k的值用来表示是否插入成功*/k=insertpost_seq(p,i,x);if(k==1) print(p); /* 如果插入成功,输出插入之后顺序表的元素*/ printf("\nmax:%d,min:%d\n",FinMax(p),FinMin(p));}题目一的(4)的代码:#include "stdio.h"#include "conio.h"//typedef int datatype;typedef struct student{int score;char name[30];}datatype;struct seqlist{int maxnum;int n;datatype *element;};typedef struct seqlist *Pseqlist;Pseqlist creatnulllist_seq(int m) /* 建立空的顺序表*/{Pseqlist p=(Pseqlist)malloc(sizeof(struct seqlist));if(p!=NULL){p->element=(datatype *)malloc(sizeof(datatype)*m);if(p->element!=NULL){p->maxnum=m;p->n=0;return(p);}else free(p);}printf("out of space");return NULL;}Pseqlist init_seq(Pseqlist p,int n) /* 初始化空的顺序表,即填充数据,顺序表的实际元素个数n 由参数提供*/{int i;printf("输入10个分数:输入10个名字:");for(i=0;i<n;i++)scanf("%d%s",&p->element[i].score,p->element[i].name);return(p);}int insertpost_seq(Pseqlist p,int i,datatype x) /* 在i之后插入一个元素x */ {int j;if(p->n>=p->maxnum){printf("overflow");return(0);}if(i<0 || i>p->n ){printf("not exist");return(0);}i-=2;for(j=p->n-1; j>=i+1; j--)p->element[j+1]=p->element[j];p->element[i+1]=x;p->n++;return(1);}int FinMax(Pseqlist p){int max=p->element[0].score;int i;for(i=1;i<p->n;++i){if(max<p->element[i].score)max=p->element[i].score;}return max;}int FinMin(Pseqlist p){int min=p->element[0].score;int i;for(i=1;i<p->n;++i){if(min>p->element[i].score)min=p->element[i].score;}return min;void print(Pseqlist p) /* 打印顺序表中的元素*/{int i;for(i=0;i<p->n;i++)printf("姓名:%s 分数:%d",p->element[i].name,p->element[i].score);}main(){Pseqlist p;int m,n,i,x,k;datatype aa;printf("input the size of seqlist m:"); /* 输入顺序表的最大空间m,建立空的顺序表*/scanf("%d",&m);p=creatnulllist_seq(m);printf("input the real number of seqlist n(n<m):"); /* 输入顺序表的实际长度n,初始化顺序表*/ scanf("%d",&n);p=init_seq(p,n);/* 输出插入之前顺序表的元素*/ print(p);printf("\n");printf("input i,x.score,:");scanf("%d%d%s",&i,&aa.score,); /* k的值用来表示是否插入成功*/ k=insertpost_seq(p,i,aa);if(k==1) print(p);/* 如果插入成功,输出插入之后顺序表的元素*/printf("\n%d %d",FinMax(p),FinMin(p));printf("分别是最大的和最小的数据");getch();}题目二代码:/* 线性表的单链表表示:类型和界面函数定义*/#include <stdio.h>/* 定义链接表元素类型。

《数据结构》习题及答案:第2章 线性表(第1次更新2012-3)

《数据结构》习题及答案:第2章 线性表(第1次更新2012-3)

第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++程序

线性表的插入和删除C++程序

修改内容:重新排版《数据结构》试验报告-------------线性表的插入和删除康一飞地理信息系统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。

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
2.上机输入、调试实验程序;
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法,1为插入,2为删除,3为查询!4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);

数据库系统l试题库及答案第3章栈与队列

数据库系统l试题库及答案第3章栈与队列

第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. ()一个递归算法必须包括()。

数据结构导论 第2章 线性表

数据结构导论 第2章 线性表
线性表(linear list) 第二章 线性表
线性表是一种线性结构,线性结构的特点是数据元 素之间是一种线性关系,数据元素“一个接一个的 排列”。 线性结构是n(n>=0)个结点的有穷序列。对于 n>0的线性结构表示成: (a1,a2,… ai-1,ai,ai+1,…an) a1称为起始结点 an称为终端结点 起始结点, 终端结点; 起始结点 终端结点 ai-1 称为 ai 的直接前趋 i+1 称为 ai 的直接后继 直接前趋,a 直接后继。 直接前趋 直接后继
4.查找(定位) locate(L,x): .查找(定位) :
依次将顺序表L中的每个元素与给定的值x进行比 较。若找到则返回其序号(下标+1),否则返回0。 int locate (sqlist L, datatype x) { int i; for ( i=0; i<st; i++) if (L.data[i]==x) return (i+1); return(0); }
void insert (sqlist *L, datatype x, int i ) { if (i<1 || i>L->last+1) error (“插入位置错误”); else if (L->last==maxsize) error (“溢出”); else { for (j=L->last-1; j>=i-1; j--) //往后移动元素 //往后移动元素 L->data[j+1]=L->data[j]; L->data[i-1]=x; //插入x L->last++; //修改表长 } }
常见的线性表的基本运算有以下几个: 常见的线性表的基本运算有以下几个:

线性表的建立,插入与删除

线性表的建立,插入与删除

一、实验目的1、掌握使用VC++上机调试线性表的基本方法;2、掌握线性表的基本操作:插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。

二、实验要求1、设计对线性表进行链式存储操作的内容;2、写出相应程序;3、保存和打印出程序的运行结果,并结合程序进行分析。

三、实验内容线性表的建立,插入与删除算法:Status InitList_ Sq(SqList &L)Status ListInsert_ Sq(SqList &L, int i, Elemtype e){if(i<1||i>L.length+1) return ERROR;q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]); p>=q; --p)*(p+1)=*p;*q=e;++l.length;return OK;}//ListInsert_ Sq;Status ListDelete_ Sq(SqList &L, int i, Elemtype e){if(i<1||i>L.length+1) return ERROR;p=&(L.elem[i-1]);e=*pq=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return OK;}//ListDelete_ Sq;四、程序代码#include<stdlib.h>#include<stdio.h>typedef struct{int *elem;int length;}sqlist;void init(sqlist *L){L->elem=(int*)malloc(100*sizeof(int));L->length=0;}void read1(sqlist *L,int n){int i;printf("input n shu:");for(i=0;i<n;++i)scanf("%d",&L->elem[i]);L->length=n;}void print(sqlist L){int i;for(i=0;i<=L.length-1;++i)printf("%5d",L.elem[i]);printf("\n");}void insert(sqlist *L,int i,int e){int *p,*q;if(i<1||i>L->length+1)printf("error");else{q=&L->elem[i-1];for(p=&L->elem[L->length-1];p>=q;--p)*(p+1)=*p;*q=e;++L->length;}}void delist(sqlist *L,int i ,int *e){ int *p,*q;if(i<1||i>L->length)printf("error\n");else{q=&L->elem[i-1]; *e=*q;for(p=q;p<=&L->elem[L->length-1];++p)*(p)=*(p+1);--L->length;}}main(){sqlist L; int e;int i,n;init(&L);printf("input n;");scanf("%d",&n);read1(&L,n);print(L);printf("input i,e;"); printf("input i,e;");scanf("%d%d",&i,&e);insert(&L,i,e);printf("insert:");print(L);printf("input i;");scanf("%d",&i);delist(&L,i,&e); printf("delete:");print(L);getch();}五、结果及分析。

线性表的插入和删除数据结构

线性表的插入和删除数据结构

线性表的插入和删除(数据结构) 线性表是一种基本的数据结构,它由一组有序的元素构成,每个元素最多只有一个前驱和一个后继。

在数据结构中,线性表可以通过链式存储和顺序存储两种方式来实现。

其中,链式存储使用节点来存储数据和地址,顺序存储则使用数组来存储数据。

下面就以链式存储为例,介绍一下线性表的插入和删除操作。

一、线性表的插入在线性表中插入一个元素,需要遵循以下步骤: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.遍历链表,找到要删除的元素所在的节点。

线性表的实现及操作(二)

线性表的实现及操作(二)
typedef int DataType;
typedef struct
{
DataType list[MaxSize];
int size;
} SeqList;
void ListInitiate(SeqList *L)/*初始化顺序表L*/
{
L->size = 0;/*定义初始数据元素个数*/
}
int ListLength(SeqList L)/*返回顺序表L的当前数据元素个数*/
ListDelete(&myList, 4, &x);
for(i = 0; i < ListLength(myList); i++)
{
ListGet(myList, i, &x);//此段程序有一处错误
printf("%d ", x);
}
}
测试结果:
线性表的实现及操作(二)
一、实验目的
了解和掌握线性表的链式存储结构;掌握用C语言上机调试线性表的基本方法;掌握线性表的基本操作:插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算,以及对相应算法的性能分析。
p = p->next;
free(p1);
}
*head = NULL;
}
void main(void)
{
SLNode *head;
int i , x;
ListInitiate(&head);/*初始化*/
for(i = 0; i < 10; i++)
{
if(ListInsert(head, i, i+1) == 0)/*插入10个数据元素*/

【数据结构】线性表的基本操作

【数据结构】线性表的基本操作

【数据结构】线性表的基本操作【数据结构】线性表的基本操作【一、概述】线性表是一种常见的数据结构,它是由一组具有相同特性的数据元素组成的有序序列。

线性表的基本操作包括插入、删除、查找和修改等操作,本文将对这些操作进行详细介绍。

【二、插入操作】插入操作是向线性表中某个位置插入一个新元素的操作。

插入操作包括头部插入、尾部插入和中间插入三种情况。

首先需要确定插入的位置,然后将插入位置后的元素依次向后移动一位,最后在插入位置处放入新元素。

1.头部插入:将新元素插入线性表的头部位置。

2.尾部插入:将新元素插入线性表的尾部位置。

3.中间插入:将新元素插入线性表的任意中间位置。

【三、删除操作】删除操作是从线性表中删除某个元素的操作。

删除操作包括删除头部元素、删除尾部元素和删除中间元素三种情况。

首先需要确定删除的位置,然后将删除位置后的元素依次向前移动一位,最后删除最后一个元素位置上的元素。

1.删除头部元素:删除线性表的头部元素。

2.删除尾部元素:删除线性表的尾部元素。

3.删除中间元素:删除线性表的任意中间位置的元素。

【四、查找操作】查找操作是在线性表中搜索某个元素的操作。

查找操作包括按值查找和按位置查找两种情况。

1.按值查找:根据给定的元素值,在线性表中搜索并返回该元素的位置。

2.按位置查找:根据给定的位置,返回该位置上的元素值。

【五、修改操作】修改操作是修改线性表中某个元素的值的操作。

需要先找到要修改的元素位置,然后将其值修改为新的值。

【附件】本文档涉及附件略。

【法律名词及注释】本文档所涉及的法律名词及注释略。

《数据结构》习题集:第2章_线性表

《数据结构》习题集:第2章_线性表

第2章线性表一、选择题1.表长为N 的顺序表,当在任何位置上插入或删除一个元素的概率相等时,插入一个元素所需移动元素的平均次数为(E ),删除一个元素需要移动的元素个数为(A )。

A. (N-1)/2B. NC. N+1D. N-1E. N/2F. (N+1)/2G. (N-2)/22.线性表是具有N 个(C )的有限序列。

A、表元素B、字符C、数据元素D、数据项E、信息3.“线性表的逻辑顺序和物理顺序总是一致的。

”这个结论是(B )。

A、正确的B、错误的C、不一定,与具体结构有关。

4.线性表采用链式存储结构时,要求内存中可用存储单元的地址(D )。

A、必须是连续的B、部分地址必须是连续的C、一定是不连续的D、连续或不连续都可以。

5.带头结点的单链表为空的判定条件是(B )。

A、head==NULLB、head->next==NULLC、head->next==headD、head!=NULL6.不带头结点的单链表head 为空的判定条件是(A )。

A、head==NULLB、head->next==NULLC、head->next==headD、head!=NULL7.非空的循环单链表head 的尾结点P 满足( C )。

A、P->NEXT=NULLB、p=NULLC、p->next==headD、p==head8.在一个具有n 个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是(B )。

A、O(1)B、O(n)C、O(n2)D、O(nlog2n)9.在一个单链表中,若删除P 所指结点的后继结点,则执行( A )。

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所指结点,则执行(B )。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验一线性表的基本操作
一、实验目的
掌握线性表的基本操作,插入、删除、查找,以及线性表合并等运算在顺序存储结构上的运算。

二、实验要求
1、认真阅读和掌握本实验的程序。

2、上机运行本程序。

3、保存和打印出程序的运行结果,并结合程序进行分析。

4、按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单
和运行结果
三、实验内容
线性表基本操作的实现。

算法描述:对每一个算法,要写出算法的中文描述。

本实验中要求写出在第i 个结点前插入数据为x的结点、删除指定结点、创建一个线性表、打印线性表的算法描述。

四、程序清单
1、sqlist.h文件清单:
#include "stdio.h"
#include "malloc.h"
#define null 0
#define maxsize 1024
typedef char datatype;
typedef struct
{
datatype data[maxsize];
int last;
}sequenlist;
/*在第i个结点前插入元素x(note:元素从0始计数)*/
int insert(sequenlist *L, datatype x,int i)
{
int j;
if (L->last==maxsize-1)/*如果原线性表已经满了*/
{
printf("overflow");
return 0;
}
else if ((i<0)||(i>L->last)) /*如果输入的i值超出范围*/
{
printf("error,please input the right 'i'");
return 0;
}
else
{
for(j=L->last; j>=i; j--) /*从第i个元素起,每个元素后移一位*/
L->data[j+1]=L->data[j];
L->data[i]=x;
L->last=L->last+1;
}
return(1);
}
/*删除第i个结点,note:元素从0始计数*/
int dellist(sequenlist *L,int i)
{
if ((i<0)||(i>L->last)) /*如果输入的i值超出范围*/
{
printf ("error,please input the right i");
return 0;
}
else
{
for(;i<L->last; i++) /*从第i+1个元素起,每个元素前移一位*/ L->data[i]=L->data[i+1];
L->last=L->last-1;
return(1);
}
}
/*创建顺序表*/
void creatlist(sequenlist *L)
{
int n , i;
char tmp;
printf("请输入数据的个数:\n");
scanf("%d",&n);
for(i=0; i<n; i++)
{
printf("data[%d]=", i);
fflush(stdin); /*清除掉键盘缓冲区*/
scanf ("%c", &tmp);
L->data[i] = tmp;
}
L->last=n-1;
printf("\n");
}
/*打印顺序表*/
void printout(sequenlist *L)
{
int i;
for(i=0; i<=L->last; i++)
{
printf("data[%d]=", i);
printf("%c\n", L->data[i]);
}
}
2、main.c文件清单
#include "sqlist.h"
main()
{
sequenlist *L;
char cmd, x;
int i;
L=(sequenlist *)malloc(sizeof(sequenlist)); /*指针在使用前一定要初始化*/ creatlist(L); /*创建线性表*/
do
{
printf("i,I......插入\n");
printf("d,D......删除\n");
printf("q,Q......退出\n");
do
{
fflush(stdin); /*清除掉键盘缓冲区*/
scanf("%c",&cmd);
}
while((cmd!='d')&&(cmd!='D')&&(cmd!='q')
&&(cmd!='Q')&&(cmd!='i')&&(cmd!='I'));
switch (cmd)
{
case 'i':
case 'I':
printf("请输入你要插入的数据:");
fflush(stdin); /*清除掉键盘缓冲区*/
scanf("%c",&x);
printf("请输入你要插入的位置:");
scanf("%d",&i);
insert(L, x, i);
printout(L);
break;
case 'd':
case 'D':
printf("请输入你要删除元素的位置:");
fflush(stdin); /*清除掉键盘缓冲区*/
scanf("%d",&i);
dellist(L, i);
printout(L);
break;
}
}while ((cmd!='q')&&( cmd!='Q'));
}。

相关文档
最新文档