线性表顺序存储结构插入-删除 (1)
开放大学数据结构2020年考试必备填空题

1、数据结构按结点间的关系,可分为4种逻辑结构:集合、线性结构、树形结构、图状结构。
2、数据结构中的数据元素存在多对多的关系称为图状结构结构。
3、在一个长度为n的顺序存储结构的线性表中,向第i(1≤i≤n+1)个元素之前插入新元素时,需向后移动n-i+1个数据元素。
4、从长度为n的采用顺序存储结构的线性表中删除第i(1≤i≤n+1)个元素,需向前移动n-i个元素。
5、数据的逻辑结构在计算机中的表示称为物理结构或存储结构。
6、除了第1个和最后一个结点外,其余结点有且只有一个前驱结点和后继结点的数据结构为线性结构,每个结点可有任意多个前驱和后继结点数的结构为非线性结构。
7、算法的5个重要特性是有穷性、确定性、可形性、有零个或多个输入、有零个或多个输出。
8、数据结构中的数据元素存在一对多的关系称树形结构结构。
9、往栈中插入元素的操作方式是:先移动栈顶指针,后存入元素。
10、数据结构中的数据元素存在一对一的关系称为线性结构结构。
11、要求在n个数据元素中找其中值最大的元素,设基本操作为元素间的比较。
则比较的次数和算法的时间复杂度分别为n-1和O(n)。
12、在一个单链表中p所指结点之后插入一个s所指结点时,应执行__s->next=p->next;__和p->next=s;的操作。
13、设有一个头指针为head的单向循环链表,p指向链表中的结点,若p->next= =head,则p所指结点为尾结点。
14、在一个单向链表中,要删除p所指结点,已知q指向p所指结点的前驱结点。
则可以用操作q->next=p->next; 。
15、设有一个头指针为head的单向链表,p指向表中某一个结点,且有p->next= =NULL,通过操作p->next=head;,就可使该单向链表构造成单向循环链表。
16、每个结点只包含一个指针域的线性表叫单链表。
17、线性表具有顺序存储和链式存储两种存储结构。
数据结构实验报告-线性表(顺序表实现)

实验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.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。
例2.2设计一个算法,将x插入到一个有序(从小到大排序)的

SqList *merge(SqList *p, SqList *q) { SqList *r; int i=0,j=0,k=0; r=(SqList *)malloc(sizeof(SqList)); while (i<p->length && j<q->length) { if (p->data[i]<q-> data[j]) { r-> data[k]=p-> data[i]; i++;k++; } else { r-> data[k]=q-> data[j]; j++;k++; } }
本算法实际上是采用尾插法建立两个新表。 所以,尾插法建表算法是很多类似习题的基础!
例2.6 有一个带头结点的单链表head,其ElemType 类型为char,设计一个算法使其元素递增有序。
解:若原单链表中有一个或以上的数据结点 ,先构 造只含一个数据结点的有序表 (只含一个数据结点的 单链表一定是有序表 ) 。扫描原单链表余下的结点 *p( 直到 p==NULL 为止 ), 在有序表中通过比较找插入 *p 的前驱结点 *q, 然后将 *p 插入到 *q 之后 ( 这里实际 上采用的是直接插入排序方法)。
答:可以简单地推算,得容易得出D,A,B,C是 不可能的,因为D先出来,说明A,B,C,D均在栈中, 按照入栈顺序,在栈中顺序应为D,C,B,A,出栈的 顺序只能是D,C,B,A。所以本题答案为D。
例 3.3 已知一个栈的进栈序列是 1,2,3,…,n, 其输出 序列是p1,p2,…,pn,若p1=n,则pi的值 。 (A) i (B) n-i
/*r保存*p结点后继结点的指针*/
线性表

2. 2线性表2.2.1 线性表的定义和运算一般形式:L=(a1,a2,…,a n)其中L为线性表,a i(i=1,…,n)是属于某数据对象的元素,n(n≥0)为元素个数称为表长,n=0为空表。
线性表的定义:L=(D,R)其中:D={ a1,a2,…,a n}R={< a i-1,a i>| a i-1,a i∈D,2≤i≤n}若a i-1≥a i,i=2,3,…,n,则称该线性表为有序表,否则称为无序表。
线性表的基本运算:插入、删除、查找、排序。
2.2.2顺序存储线性表1.顺序存储结构2.顺序存储结构的插入、删除运算插入INSERTLIST(V,n,i,x)1.if (i<1) OR ((i>n+1) then {参数错return}(i=n+1表示插入在最后)2.for j=n to i step (-1)3.V[j+1]←V[j]4.end (j)5.V[i]←x6.n←n+17.return删除DELETELIST(V,n,i)1.if (i<1) OR ((i>n+1) then {参数错return}2.for j=i to n-13.V[j]←V[j+1]4.end (j)5.n←n-16.return2.2.3 线性链表1.链式存储结构2.线性链表的基本运算(1)基本操作设p,q,s均为指针类型变量,指向数据域为data,指针域为next的结点,表2.2表示线性链表的几项基本操作。
(2)结点的动态生成及回收设具有数据域date,指针域next的空白链表,其头指针为av。
从空白链表中获取一个结点,由指针P指向,其算法为:GETNODE(P)1.p←av2.av←next(av) //修改空白链表头指针//3.return回收一个由P指针指向的结点,放回空白链表的算法为:REP(P)1. Next(P)←av2. av←P3. return(3)插入运算INLINKST(head,a,b)1.GETNODE(p); data(p)←b; //取得一个新结点p//2.if (head=nil) then {head←p;next(p)←nil; return} //空白情况//3.if (data(head)=a) then {next(p)←head; head←p; return} //a为头结点//4.LOOKFOR(head,a,q) //寻找元素a之前的结点q//5.next(p)←next(q); next(q)←p6.return其中LOOKFOR(head,a,q)为在非空链表中寻找包含指定元素a之前的结点q的算法:LOOKFOR(head,a,q)1.q←head2. While (next(q)≠nil) and (data(next(q))≠a) do3. q←next(q) //如果表中无a结点,则q指向链表最后一个结点//(4)删除运算DELINKST(head,a)1.if (head=nil) then {空表return} //空表情况//2.if(data(head)=a) then {s←next(head); RET(head); head←s; return} //a为头结点//3. LOOKFOR(head,a,q)4.if (next(q)=nil) then {无此结点return}5.p←next(q); next (q)←next (p)6.RET(p)7.return3.线性链表的其他形式4.应用实例---一元多项式相加P n(x)=P0+P1X2+…+P i x i+…+P n x n设有一元多项式A(x)和B(x),现要求相加结果C(x)=A(x)+B(x)。
2023年-2024年国家电网招聘之电网计算机强化训练试卷B卷附答案

2023年-2024年国家电网招聘之电网计算机强化训练试卷B卷附答案单选题(共45题)1、以下关于DoS攻击的描述中,错误的是()。
A.是一种对网络危害巨大的恶意攻击B.最常见的DoS攻击有计算机网络宽带攻击和连通性攻击C.以导致受攻击系统无法处理正常用户的请求为目的D.以扫描受攻击系统上的漏洞为目的【答案】 D2、已知计算机存储器按字节编址,指令字长32位,则一条指令结束后,PC值应自动加()。
A.1B.2C.4D.以上都不对【答案】 C3、定点运算器中判断溢出的条件是()。
A.最高符号位产生进位B.符号位进位和最高数值位进位同时产生C.用般符号位表示数符,当运算结果的两个符号位不相同时D.用艘符号位表示数符,当运算结果的两个符号位相同时【答案】 B4、ISP 是()的简称。
A.传输控制层协议B.间际协议C.Internet 服务商D.拨号器【答案】 C5、防火墙技术可以分为()等三大类。
A.IP过滤、线路过滤和入侵检测B.IP过滤、线路过滤和应用代理C.包过滤、线路过滤和入侵检测D.包过滤、线路过滤和应用代理【答案】 B6、下列与队列结构有关联的是()。
A.函数的递归调用B.数组元素的引用C.多重循环的执行D.先到先服务的作业调度【答案】 D7、CPU的基本功能不包括()。
A.指令控制B.操作控制C.数据处理D.数据通信【答案】 D8、在SQL语言中,用GRANT/REVOKE语句实现数据库的()。
A.并发控制B.安全性控制C.一致性控制D.完整性控制【答案】 B9、在指令系统设计中,采用扩展操作码的设计,目的是()A.保持指令长度不变的情况下增加指令寻址空间B.减少指令字长度C.增加指令字长度D.保持指令长度不变的情况下增加指令数量【答案】 D10、内存按字节编址,地址从90000H到CFFFFH,若用存储容量为16K×8bit 芯片构成该内存,至少需要的芯片数是()。
A.2B.4C.8D.16【答案】 D11、信息安全技术具体包括保密性、完整性、可用性和()等几方面的含义。
线性表的顺序存储结构

∑
n +1 i =1
p i ( n i + 1)
1 不失一般性,若在线性表的任何位置插入元素都是等概率的,即 p i = 不失一般性,若在线性表的任何位置插入元素都是等概率的, , n + 1 上式可化简为: 上式可化简为: 1 n+1 n
Eis =
∑(n i +1) = 2 n +1
第二章 线性表
2.1 线性表的类型定义 2.2 线性表的顺序表示和实现
2.3 线性表的链式表示和实现
2.4 一元多项式的表示及相加
2.2 线性表的顺序表示和实现 线性表的顺序表示指的 是用一组地址连续的存储单 元依次存储线性表的数据元 素.
£2.2 线性表的顺序存储结构
(1)线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性 ) 表的数据元素.如下图2.1所示 所示: 表的数据元素.如下图 所示: 存储地址 b b+l … b+(i-1)l … b+(n-1)l b+nl … b+(maxlen-1)l 内存状态 a1 a2 … ai … an 空闲 数据元素在线性表中的位序 1 2 … i … n
// 为顺序表分配大小为 maxsize 的数组空间
if (!L.elem) exit(OVERFLOW); L.length = 0; L.listsize = maxsize; return OK; 算法时间复杂度 O(1) 时间复杂度: 时间复杂度 } // InitList_Sq
(4)线性表的插入和删除运算 ) 序号 数据元素 1 2 3 4 5 6 7 8 12 13 21 24 28 30 42 77 (a) 序号 数据元素 1 2 3 4 5 6 7 8 9 12 13 21 24 25 28 30 42 77 (b) 序号 数据元素 1 2 3 4 5 6 7 8 12 13 21 24 28 30 42 77 (a) 序号 数据元素 1 2 3 4 5 6 7 12 13 21 28 30 42 77
DS第二章_课后习题答案

第二章线性表2.1 填空题(1)一半插入或删除的位置(2)静态动态(3)一定不一定(4)头指针头结点的next 前一个元素的next2.2 选择题(1)A (2) DA GKHDA EL IAF IFA(IDA)(3)D (4)D (5) D2.3头指针:在带头结点的链表中,头指针存储头结点的地址;在不带头结点的链表中,头指针存放第一个元素结点的地址;头结点:为了操作方便,在第一个元素结点前申请一个结点,其指针域存放第一个元素结点的地址,数据域可以什么都不放;首元素结点:第一个元素的结点。
2.4已知顺序表L递增有序,写一算法,将X插入到线性表的适当位置上,以保持线性表的有序性。
void InserList(SeqList *L,ElemType x){int i=L->last;if(L->last>=MAXSIZE-1) return FALSE; //顺序表已满while(i>=0 && L->elem[i]>x){L->elem[i+1]=L->elem[i];i--;}L->elem[i+1]=x;L->last++;}2.5 删除顺序表中从i开始的k个元素int DelList(SeqList *L,int i,int k){int j,l;if(i<=0||i>L->last) {printf("The Initial Position is Error!"); return 0;}if(k<=0) return 1; /*No Need to Delete*/if(i+k-2>=L->last) L->last=L->last-k; /*modify the length*/for(j=i-1,l=i+k-1;l<L->last;j++,l++)L->elem[j]=L->elem[l];L->last=L->last-k;return 1;}2.6 已知长度为n的线性表A采用顺序存储结构,请写一时间复杂度为O(n)、空间复杂度为O(1)的算法,删除线性表中所有值为item的数据元素。
国家开放大学《数据结构(本)》单元测试参考答案

31.顺序存储方式只能用于存储线性结构。(×) 32.顺序存储方式的有点是存储密度大,且插入、删除运算效率高。(×)
单元 3 栈和队列 1.一个顺序栈一旦被声明,其占用空间的大小( )。
A. 已固定 B. 动态变化 C. 可以改变 D. 不能固定 2.链栈和顺序栈相比,有一个比较明显的缺点,即( )。 A. 不会出现栈空的情况 B. 插入操作更加方便 C. 删除操作更加方便 D. 通常不会出现栈满的情况 3.用单链表表示的链式队列的队头在链表的( )位置。 A. 链头 B. 任意位置 C. 链尾 D. 链中 4.在解决计算机主机与打印机之间速度不匹配问题时通常设置一个打印数据缓 冲区,主机将要输出的数据依次写入缓冲区中,而打印机则从缓冲区中取出数据 打印,该缓冲区应该是一个( )结构。 A. 数组 B. 堆栈 C. 队列 D. 线性表 5.循环队列 A[m] 存放其元素,用 front 和 rear 分别表示队头及队尾,则循环队 列满的条件是( )。
12.一个栈的进栈序列是 5,6,7,8,则栈的不可能的出栈序列是( )。(进 出栈操作可以交替进行)
A. 8,7,6,5 B. 7,6,8,5 C. 7,6,5,8 D. 5,8,6,7 13.栈的插入删除操作在( )进行。 A. 栈底 B. 栈顶 C. 指定位置 D. 任意位置 14.栈和队列的相同点是( )。 A. 逻辑结构与线性表相同,都是操作规则受到限制的线性表 B. 逻辑结构与线性表不同 C. 都是后进后出 D. 都是后进先出 15.以下说法正确的是( )。 A. 栈的特点是先进先出,队列的特点是先进后出 B. 栈和队列的特点都是先进后出
14.算法是在数据结构的基础上对特定问题求解步骤的一种描述,也是若干条指 令组成的优先序列(√)。 15.算法可以用不同的语言描述,如果用 C 语言等高级语言来描述,则算法实际 上就是程序了(×)。 16.程序一定是算法(×)。 17.数据的物理结构是指数据在计算机内的实际存储形式(√)。 18.数据结构中评价算法的两个重要指标是时间复杂度和空间复杂度(√)。 19.在顺序存储结构中,有时也存储数据结构中元素之间的关系(×)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
线性表顺序存储结构插入,删除
(数据结构)
一、实验目的
1.掌握顺序存储结构的特点。
2.掌握顺序存储结构的常见算法。
3.实现顺序表的插入,删除等操作。
二、实验要求
1、用vs6.0 进行线性表程序的编写,用c语言程序开发
三、实验内容
1、定义常量,变量等
2、定义主函数main
3、定义调用函数void Initlist(Sqlist &L),void Creatlist(Sqlist &L),void
Insertlist(Sqlist &L,int j,int e),void Deletelist(Sqlist &L,int j)
#include<stdio.h>
#define maxsize 100
typedef int elemtype;
typedef struct
{
elemtype elem[maxsize];
int length;
}Sqlist;
void Initlist(Sqlist &L) //初始化表L
{
L.length=0;
}
void Creatlist(Sqlist &L)
{
int i;
scanf("%d\n",&L.length);
for(i=0;i<L.length;i++)
scanf("%d",&L.elem[i]);
for(i=0;i<L.length;i++)
printf("%5",L.elem[i]);
}
void Insertlist(Sqlist &L,int j,int e) //插入操作{
int i;
for(i=L.length;i>=j-1;i--)
L.elem[i+1]=L.elem[i];
L.elem[j-1]=e;
L.length=L.length+1;
}
void Deletelist(Sqlist &L,int j) //删除元素
{
int i;
for(i=j-1;i<L.length-1;i++)
L.elem[i]=L.elem[i+1];
L.length=L.length-1;
printf("新的线性表序列为:");
for(i=0;i<L.length;i++)
printf("%3d",L.elem[i]);
printf("\n");
}
void main()
{
Sqlist L;
int j,e;
printf("请定义表长和元素:");
Initlist(L);
Creatlist(L);
printf("请输入插入的位置:");
scanf("%d",&j);
printf("请输入插入的元素:");
scanf("%d",&e);
Insertlist(L,j,e);
printf("请输入删除的元素:"); scanf("%d",&j);
Deletelist(L,j);
}。