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

合集下载

数据结构线性表习题1

数据结构线性表习题1

数据结构练习题1 指导老师:***姓名:***学校:滨州学院院系:信息工程学院软件技术填空题1.对于一个n个结点的单链表,在表头插入元素的时间复杂度为_____O(1)_____,在表尾插入元素的时间复杂度为_____O(n)_____。

2.删除非空线性链表中由q所指的链结点(其直接前驱结点由r指出)的动作时执行语句___r->link=q->link_______和______free(q)____。

结点结构为typedef struct Node{int value;node * link;}node;3.非空线性链表中,若要在由p所指的链结点后面插入新结点q,则应执行语句____ q->link=p->link;______和_____ p->link=q;_____。

结点结构为typedef struct Node{int value;node* link;}node;4.线性表L=(a1,a2,…,an)用数组表示,假定删除表中任一元素的概率相同,则删除一个元素平均需要移动元素的个数是_____(n-1)/2_____。

5.在一个长度为n的顺序表中第i个元素(1≤i≤n)之前插入一个元素时,需向后移动_____ n-i+1_____ 个元素。

6.在具有n个链结点的链表中查找一个链结点的时间复杂度为O(_______n___)。

7.线性表中的插入、删除操作,在顺序存储方式下平均移动近一半的元素,时间复杂度为_____O(n)_____;而在链式存储方式下,插入和删除操作的时间复杂度都是____O(1)______ 。

8.若某线性表采用顺序存储结构,每个元素占4个存储单元,首地址为100,则第10个元素的存储地址为____136______。

选择题1.对于一个带头结点的单链表,头指针为head,判定该表为空的条件是________B__。

A. head==NULLB. head->next==NULLC. head->next==headD. head!=NULL2.将长度为m的线性链表链接在长度为n的线性链表之后的过程的时间复杂度若采用大O形式表示,则应该是______B____。

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

数据结构实验报告-线性表(顺序表实现)

数据结构实验报告-线性表(顺序表实现)

实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。

三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。

顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。

实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1:初始化------------------" << endl;cout << "--------------2:插入元素----------------" << endl;cout << "--------------3:查询元素----------------" << endl;cout << "--------------4:删除元素----------------" << endl;cout << "--------------5:销毁线性表--------------" << endl;cout << "--------------6:清空线性表--------------" << endl;cout << "--------------7:线性表长度--------------" << endl;cout << "--------------8:线性表是否为空----------" << endl;cout << "--------------9:定位满足大小关系的元素--" << endl;cout << "--------------10:查询前驱---------------" << endl;cout << "--------------11:查询后继---------------" << endl;cout << "--------------12:输出线性表-------------" << endl;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。

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

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

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

(注意:不论在调用哪个函数前,都要先使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;指针类型。

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

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

电子信息工程学系实验报告——适用于计算机课程课程名称: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>/* 定义链接表元素类型。

数据结构实验题目

数据结构实验题目

实验题目一一、单链表基本运算【问题描述】设计并实现线性表的单链表存储和运算。

【基本要求】实现单链表的插入、删除和遍历运算,每种操作用一个函数实现。

插入操作:将一个新元素插入表中指定序号的位置。

删除操作:将指定序号的元素从表中删除。

遍历操作:从表头按次序输入所有元素的值,若是空表,则输出信息“empty list!”。

【实现提示】程序运行时,首先在main函数中创建空的、带头结点的单链表。

然后多次调用实现插入操作的函数(每次都将元素在序号1位置上插入),将元素依次插入表中,最后调用实现遍历操作的函数输出所有元素。

之后再多次调用实现删除操作的函数将表还原为空表(每次都删除第1个元素,每删除一个元素后,将表中剩余元素都输出一次)。

【测试数据】输入数据:1 2 3 4 5 0(为0时结束,0不存入链表)第一次输出:5 4 3 2 1第二次输出:4 3 2 1第三次输出:3 2 1第四次输出:2 1第五次输出:1第六次输出:empty list!二、约瑟夫环问题【问题描述】编号为1,2,...,n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。

现在给定一个随机数m>0,从编号为1的人开始,按顺时针方向1开始顺序报数,报到m时停止。

报m的人出圈,同时留下他的密码作为新的m值,从他在顺时针方向上的下一个人开始,重新从1开始报数,如此下去,直至所有的人全部出列为止。

【基本要求】利用单向循环链表存储结构模拟此过程,按照出列的顺序印出各人的编号。

【测试数据】M的初始值为20;n等于7,7个人的密码依次为:3,1,7,2,4,8,4。

输出为:6,1,4,7,2,3,5【实现提示】程序运行时,首先要求用户指定初始报数上限值,然后读取各人的密码。

可设n≤30。

此题所用的循环链表中不需要“头结点”,请注意空表和非空表的界限。

【选作内容】用顺序存储结构实现该题目。

三、一元多项式相加、减运算器【问题描述】设计一个一元稀疏多项式简单计算器。

《数据结构及其应用》笔记含答案 第二章_线性表

《数据结构及其应用》笔记含答案 第二章_线性表

第2章线性表一、填空题1、线性结构反映结点间的逻辑关系是一对一的。

2、线性结构的特点:1)只有一个首结点和尾结点2)除首尾结点外,其他结点只有一个直接前驱和一个直接后继3、线性表的顺序表示又称为顺序存储结构。

4、结点只有一个指针域的链表,称为单链表。

5、首尾相接的链表称为循环链表。

6、线性表的链式表示又称为非顺序映像。

7、指向链表中第一个结点的指针称为头指针。

8、链表中存储第一个数据元素的结点称为首元结点。

二、判断题1、线性表的逻辑顺序与存储顺序总是一致的。

(╳)2、顺序存储的线性表可以按序号随机存取。

(√)3、顺序表的插入和删除操作不需要付出很大的时间代价,因为每次操作平均只有近一半的元素需要移动。

(╳)4、线性表中的元素可以是各种各样的,但同一线性表中的数据元素具有相同的特性,因此属于同一数据对象。

(√)5、在线性表的顺序存储结构中,逻辑上相邻的两个元素在物理位置上并不一定相邻。

(╳)6、在线性表的链式存储结构中,逻辑上相邻的元素在物理位置上不一定相邻。

(√)7、线性表的链式存储结构优于顺序存储结构。

(╳)8、在线性表的顺序存储结构中,插入和删除时移动元素的个数与该元素的位置有关。

(√)9、线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。

(√)10、在单链表中,要取得某个元素,只要知道该元素的指针即可,因此,单链表是随机存取的存储结构。

(╳)11、线性表的特点是每个元素都有一个前驱和一个后继。

(╳)三、单项选择题1、顺序表中第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是(B)。

A.110 B.108 C.100 D.120解释:顺序表中的数据连续存储,所以第5个元素的地址为:100+2*4=108。

2、在n个结点的顺序表中,算法的时间复杂度是O(1)的操作是(A)。

A.访问第i个结点(1≤i≤n)和求第i个结点的直接前驱(2≤i≤n)B.在第i个结点后插入一个新结点(1≤i≤n)C.删除第i个结点(1≤i≤n)D.将n个结点从小到大排序解释:在顺序表中插入一个结点的时间复杂度都是O(n2),排序的时间复杂度为O(n2)或O(nlog2n)。

线性表的插入和删除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);

数据结构 第2章线性表 习题 答案

数据结构 第2章线性表  习题  答案

第2章线性表参考答案一、填空1. 【严题集2.2①】在顺序表中插入或删除一个元素,需要平均移动表中一半元素,具体移动的元素个数与表长和该元素在表中的位置有关。

2. 线性表中结点的集合是有限的,结点间的关系是一对一的。

3. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时,需向后移动n-i+1 个元素。

4. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时,需向前移动n-i 个元素。

5. 在顺序表中访问任意一结点的时间复杂度均为 O(1),因此,顺序表也称为随机存取的数据结构。

6. 【严题集2.2①】顺序表中逻辑上相邻的元素的物理位置必定相邻。

单链表中逻辑上相邻的元素的物理位置不一定相邻。

7. 【严题集2.2①】在单链表中,除了首元结点外,任一结点的存储位置由其直接前驱结点的链域的值指示。

8.在n个结点的单链表中要删除已知结点*p,需找到它的前驱结点的地址,其时间复杂度为O(n)。

二、判断正误(在正确的说法后面打勾,反之打叉)( × )1. 链表的每个结点中都恰好包含一个指针。

答:错误。

链表中的结点可含多个指针域,分别存放多个指针。

例如,双向链表中的结点可以含有两个指针域,分别存放指向其直接前趋和直接后继结点的指针。

( × )2. 链表的物理存储结构具有同链表一样的顺序。

错,链表的存储结构特点是无序,而链表的示意图有序。

( × )3. 链表的删除算法很简单,因为当删除链中某个结点后,计算机会自动地将后续的各个单元向前移动。

错,链表的结点不会移动,只是指针内容改变。

( × )4. 线性表的每个结点只能是一个简单类型,而链表的每个结点可以是一个复杂类型。

错,混淆了逻辑结构与物理结构,链表也是线性表!且即使是顺序表,也能存放记录型数据。

( × )5. 顺序表结构适宜于进行顺序存取,而链表适宜于进行随机存取。

错,正好说反了。

顺序表才适合随机存取,链表恰恰适于“顺藤摸瓜”( × )6. 顺序存储方式的优点是存储密度大,且插入、删除运算效率高。

数据结构的线性表实验体会

数据结构的线性表实验体会

数据结构的线性表实验体会在数据结构课程中,线性表一直是一个重要的概念。

实验环节则是课程中提高学生实践能力,巩固知识的重要环节。

在这次实验中,我学到了很多关于线性表的知识和实际应用,同时也收获了一些宝贵的体会。

首先,我对线性表的基本概念和操作有了更深入的理解。

线性表是一种数据结构,由若干个数据元素组成,其元素之间具有一定的顺序关系。

线性表的操作主要分为插入、删除、查找等,这些操作都有着不同的复杂度和性能。

在实验中,我们主要学习了顺序表和链表两种实现方式。

顺序表是一种基于数组的实现,其特点是元素在内存中是连续存储的,可以直接访问下标来操作元素。

而链表则是通过指针来维护元素之间的联系,可以灵活地进行插入和删除操作。

其次,在实验中我体验到了实际应用中线性表的重要性。

线性表可以用于解决很多实际问题,例如顺序表可以用于表示数组、矩阵等,链表可以用于表示链式存储的数据结构。

在实验中,我编写了一个简单的实现电话簿的程序,利用链表机制来存储联系人信息,实现增删改查等功能。

这个程序不仅让我了解到了链表的实际应用,更让我理解到了数据结构在实际应用中的重要性。

最后,我认为这次实验让我深刻地体会到了实践的重要性。

在实验中,我不仅学到了理论知识,更锻炼了编程能力。

通过实验,我了解了编程中很多细节,例如内存分配、指针操作等。

这些知识点只有在实践中才能真正掌握,而实验则是非常好的教育方式。

总的来说,这次实验让我对线性表有了更深入的理解。

除了学习理论知识外,更锻炼了实践能力,提高了编程能力。

学习和掌握数据结构是编程领域的重要基础,相信这次实验也会对我的编程生涯有着深远的影响。

数据结构——线性表(选择题)

数据结构——线性表(选择题)

1.线性表是()。

简单,线性表的概念与性质,02702001 [单选题]A、一个有限序列,可以为空(正确答案)B、一个无限序列,不可以为空C、一个无限序列,可以为空D、一个无限序列,不可以为空2.在一个长度为n 的顺序表中删除第i 个元素(0<=i<=n)时,需向前挪移()个元素。

简单,线性表顺序存储实现,02702003 [单选题]A 、n-i(正确答案)B 、n-i+1C 、n-i-1D 、i3.线性表采用链式存储时,其地址()。

简单,线性表的链式存储原理,02702004 [单选题]A、必须是连续的B、一定是不连续的C、部份地址必须是连续的D、连续与否均可以(正确答案)4.从一个具有n 个结点的单链表中查找其值等于x 的结点时,在查找成功的情况下,需平均比较()个元素结点。

普通,链式存储的实现,02702005 [单选题]A 、n/2B 、nC 、(n+1)/2(正确答案)D 、(n-1)/25.在双向循环链表中p 所指的结点之后插入s 指针所指向的结点,其操作是()。

普通,循环链表实现,02702022 [单选题]A 、p->next=s; s->prior=p; p->next->prior=s; s->next=p->next;B 、s->prior=p; s->next=p->next; p->next=s; p->next->prior=s;C 、p->next=s; p->next->prior=s; s->prior=p; s->next=p->next;D 、s->prior=p; s->next=p->next; p->next->prior=s; p->next=s; (正确答案)6.设单链表中指针p 指向结点m,若要删除m 之后的结点(若存在),则需修改指针的操作为()。

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

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

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

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

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

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

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

数据结构 第二章__线性表(本)

数据结构 第二章__线性表(本)

数据结构与算法华东师范大学计算机系杨沛第二章线性表2.1 线性表的基本概念线性表是具有相同数据类型的数据元素的有限序列。

由n(n≥0)个数据元素k0,k1,…,kn-1组成的线性表记为(k0 ,k1 ,…,kn-1),线性表中包含的数据元素的个数n称为线性表的长度(length),称长度为零的线性表为空的线性表(简称为空表)。

相关概念:表头、表尾、前驱、后继有序线性表:数据元素的相对位置与它们的值有联系。

无序线性表:数据元素的相对位置与它们的值没有联系。

第二章线性表例小于20的质数组成的线性表(2,3,5,7,11,13, 17,19);英文字母表也是线性表,表中每个字母是一个数据元素:(A,B,C,……,Z);2.2 顺序表2.2.1 线性表顺序表(sequential list)就是顺序存贮的线性表,即用一组连续的存贮单元依次、连续地存贮线性表中的结点。

如果每个结点占用s个存贮单元,并假设存放结点ki(0≤i≤n-1)的开始地址为loc(k0),则结点ki的地址loc(ki)可表示成Loc(ki) =loc(k0) + i*s。

2.2 顺序表在C 语言中,可用数组表示线性表:#define MAXN 100int list[MAXN];int n;线性表的结点k 0,k 1,…,k n-1依次存放在数组单元list[0],list[1],…,list[n-1]。

2.2.1 线性表最大表长实际表长线性表2.2 顺序表2.2.1 线性表假设s=sizeof(int),则可得到计算ki的地址的公式,因loc(ki)=&list[i],而&list[i]=&list[0]+i·s,故loc(ki)=&list[0]+i·s。

2.2 顺序表2.2.2 顺序表的操作(1)初始化:初始长度置为0即可(n=0;),数组空间在编译时分配。

(2)顺序表的插入:插入算法的C函数SqListInsert():若插入位置i不在可以插入的位置上,即i<0或i>n,则返回0;若n=MAXN,即线性表已满,此时数组list[]没有多余的存贮单元可以存放新结点,则返回-1;若插入成功,则返回12.2 顺序表实际表长(2)顺序表的插入:int SqListInsert(int list[],int*p_n,int i,int x) {int j;if(i<0||i>*p_n)return(0);//i不是合法的插入位置if(*p_len==MAXN)return(-1);//线性表已满2.2 顺序表for(j=*p_n;j>i;j--)list[j]=list[j-1];//结点右移list[i]=x;(*p_n)++;//表长加1return(1);}2.2 顺序表(2)顺序表的插入:对于存放在数组list[]中的、具有n个结点的顺序表,为了把值为x的结点插在表的位置i(0≤i≤n)上,可调用如下的语句:k=SqListInsert(list, &n, i, x);注:结点移动是本算法的关键操作2.2 顺序表(3)顺序表的删除:删除算法的C函数SqListDelete():在具有n个结点的顺序表中,删除第i(0≤i≤n-1)个位置上的结点,使线性表长度减1,若删除位置不合法,即i<0或i≥n,则返回0;若删除位置合法,即0≤i≤n-1,则删除成功,返回1。

数据结构(Java版)线性表的实现和应用[完整版]

数据结构(Java版)线性表的实现和应用[完整版]

实验报告
课程名称数据结构
实验项目线性表的实现及应用
实验仪器PC机一台
学院_____ 专业
班级/学号
姓名
实验日期
成绩
指导教师
北京信息科技大学
信息管理学院
(数据结构课程上机)实验报告
3.
1.实验名称、实验目的、实验内容、实验要求由教师确定,实验前由教师事先填好,然后作为实验报告模
版供学生使用;
2.实验准备由学生在实验或上机之前填写,教师应该在实验前检查;
3.实验过程由学生记录实验的过程,包括操作过程、遇到哪些问题以及如何解决等;
4.实验总结由学生在实验后填写,总结本次实验的收获、未解决的问题以及体会和建议等;
5.源程序、代码、具体语句等,若表格空间不足时可作为附录另外附页。

数据结构考试题库

数据结构考试题库

绪论一、填空题1.数据的逻辑结构被分为集合、(线性结构)、(树形结构)和(图状结构)四种。

2.物理结构是数据结构在计算机中的表示,又称为(存储结构)。

3.数据元素的逻辑结构包括( 线性)、(树)和图状结构3种类型,树形结构和图状结构合称为(非线性结构)。

4.(数据元素)是数据的基本单位,(数据项)是数据不可分割的最小单位。

5.线性结构中元素之间存在(一个对一个)关系,树形结构中元素之间存在(一个对多个)关系,图状结构中元素之间存在(多个对多个)关系。

6.数据结构是一门研究非数值计算的程序设计问题中:计算机的(数据元素)以及它们之间的(关系)和(运筹)等的学科。

7.算法的五个重要特性为有穷性、确定性、(输入)、(输出)和(可行性)。

二、选择题1.数据的不可分割的基本单位是(D)。

A.元素B.结点C.数据类型D.数据项*2.线性表的逻辑顺序与存储顺序总是一致的,这种说法(B)。

A.正确B.不正确C.不确定D.无法选择3.线性结构是指数据元素之间存在一种(D)。

A.一对多关系B.多对多关系C.多对一关系D.一对一关系4.在数据结构中,从逻辑上可以把数据结构分成(A)。

A.动态结构和静态结构B.紧凑结构和非紧凑结构C.线性结构和非线性结构D.内部结构和外部结构5.线性表若采用链式存储结构时,要求内存中可用存储单元的地址( D)。

A.必须是连续的B.部分地址必须是连续的C.一定是不连续的D.连续不连续都可以三、简答题1.算法的特性是什么。

答:有穷性确定性可行性有0或多个输入有1或多个输出线性结构一、填空题1.在一个长度为n的线性表中删除第i个元素(1≤i≤n)时,需向前移动(n-i)个元素。

2.从循环队列中删除一个元素时,其操作是(先移动队首指针,后取出元素)。

3.在线性表的单链接存储中,若一个元素所在结点的地址为p,则其后继结点的地址为(p->next)。

4.在一个单链表中指针p所指向结点的后面插入一个指针q所指向的结点时,首先把(p->next)的值赋给q->next,然后(q->date)的值赋给p->next。

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

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

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

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

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

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

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

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)。

// 操作结果:返回 L 中第 1 个与 e 满足关系 compare()的数据元素的位序。
// 若这样的数据元素不存在,则返回值为 0。算法 2.6
ElemType *p;
int i=0; // i 的初值为第 1 个元素的位序
p=L.elem; // p 的初值为第 1 个元素的存储位置
while(i&lt;=L.Length&amp;&amp;!equal(*p++,e))
}//InitList
void visit(ElemType aa) { cout&lt;&lt;aa; } void ListTraverse(SqList &amp;L, void visit(ElemType aa) ) { int i;
ElemType e; for( i=1;i&lt;=(L.Length);i++) { GetElem(L,i,e); visit(e); } } int equal(ElemType &amp;a,ElemType &amp;b) { if(a==b) return 1; else return 0; }
++i;
if(i&lt;=L.Length)
return i;
else
return 0;
}
void Bing(SqList &amp;La,SqList &amp;Lb) {//将所有在线性表中 Lb 中但不在 La 中的数据元素插入到 La 中
int i; ElemType e; int La_len=La.Length; int Lb_len=Lb.Length;//求线性表的长度
} void InitList(SqList &amp;L)//定义
{ L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配空间 if(!L.elem)exit(0);//空间存储失败 L.Length=0; //空间长度为 0 L.Listsize=LIST_INIT_SIZE;//初始空间长度
int LocateElem(SqList &amp;L, ElemType &amp;e, int equal(ElemType &amp;,
ElemType &amp;))
//算法 2.6
{ // 初始条件:顺序线性表 L 已存在,compare()是数据元素判定函数(满足为 1,否则
为 0)
if (!newbase)
cout&lt;&lt;&quot;overflow&quot;;
L.elem=newbase;
L.Listsize+= LISTINCREMENT;
}
q=&amp;(L.elem[n-1]);
for(p=&amp;(L.elem[L.Length-1]);p&gt;=q;p--)
Eபைடு நூலகம்emType g;
if (n&lt;1||n&gt;L.Length+1)
return (0);
if (L.Length&gt;=L.Listsize)
{
int
*
newbase=(ElemType
*)realloc(L.elem,(L.Listsize+LISTINCREMENT )*sizeof(ElemType));
数据结构线性表的插入删除
#include&lt;iostream&gt; using namespace std; #define LIST_INIT_SIZE 50 #define LISTINCREMENT 50 #define ERROR typedef int ElemType; struct SqList { ElemType *elem; int Length; int Listsize; };
void GetElem(SqList &amp;L,int &amp;n,ElemType &amp;e) { int *q=&amp;(L.elem[n-1]); e=*q; } int ListInsert(SqList &amp;L,int &amp;n,ElemType &amp;e) //定义插入函数 { int *p,*q,*newbase;
*(p+1)=*p;
*q=e;
++L.Length;
}//ListInsert void ListDelete(SqList &amp;L,int i,ElemType &amp;e) { int *p,*q; if((i&lt;1)||(i&gt;L.Length)) return ERROR; p=&amp;(L.elem[i-1]); e=*p; q=L.elem+L.Length-1; for(++p;p&lt;=q;++p) *(p-1)=*p; --L.Length;
}
for(i=1;i&lt;=Lb_len;i++) { GetElem(Lb,i,e);
if(!LocateElem(La,e,equal)) ListInsert(La,++La_len,e);
} } void main() { SqList La,Lb; int i,x,y,g; int m,n,k; k=0; InitList(La); cout&lt;&lt;&quot;m=&quot;; cin&gt;&gt;m; for(i=1;i&lt;=m;i++)
{ cout&lt;&lt;&quot;please input a number&quot;; cin&gt;&gt;x; ListInsert(La,i,x); } cout&lt;&lt;&quot;La= &quot;; ListTraverse(La,visit); InitList(Lb); cout&lt;&lt;&quot;n=&quot;; cin&gt;&gt;n; for(i=1;i&lt;=n;i++) { cout&lt;&lt;&quot;please input a number&quot;; cin&gt;&gt;y; ListInsert(Lb,i,y); } cout&lt;&lt;&quot;Lb= &quot;; ListT
raverse(Lb,visit); Bing(La,Lb); cout&lt;&lt;&quot;La0= &quot;; ListTraverse(La,visit); cout&lt;&lt;&quot;插入数据元素位置:&quot;; cin&gt;&gt;x; cout&lt;&lt;&quot;需要插入的元素;&quot;; cin&gt;&gt;y; ListInsert(La,x,y); cout&lt;&lt;&quot;La1=&quot;; ListTraverse(La,visit); cout&lt;&lt;&quot;删除数据元素位置:&quot;; cin&gt;&gt;x; cout&lt;&lt;&quot;需要删除的元素;&quot;; cin&gt;&gt;y; ListDelete(La,x,y); cout&lt;&lt;&quot;La2=&quot;; ListTraverse(La,visit);
相关文档
最新文档