第二章 顺序表

合集下载

第二章顺序存储结构的线性表——习题课

第二章顺序存储结构的线性表——习题课


6、栈和队列的共同点是_____。 A、都是先进后出 B、都是先进先出 C、只允许在端点处插入和删除元素 D、没有共同点

填空题
1、向量、栈和队列都是____结构,可以 在向量的__位置插入和删除元素;对于 栈只能在__插入和删除元素;对于队列 只能在___插入元素和___删除元素。 2、向一个长度为n的向量的第i(0<i<n+2) 个元素之前插入一个元素时,需向后移 动____个元素。 3、向一个长度为n的向量中删除第 i(0<i<n+2)个元素时,需向前移动____个 元素。
PROCEDURE hebing(a[], b[],m,n) ET a[], ET b[],int m,int n i=1; j=1; k=1; While(i<=m and j<=n) do If (a[i]<b[j]) { c[k]=a[i];i=i+1;k=k+1; } Else {c[k]=b[j];j=j+1;k=k+1; } If(j=n) for t=(i+1) to m do { c[k]=a[t];k=k+1 } If (i=m) for t=(j+1) to n do { c[k]=b[t]; k=k+1; }

第二题

试写出在顺序存储结构下逆转线性表的 算法,要求使用最少的附加空间。
PROCEDURE nizhuan(ET a[],int n) For k=1 to n/2 do { t=a[k]; a[k]=a[n-k+1]; a[n-k+1]=t; } END

第三题

2-5-数据结构——从概念到C++实现(第3版)-王红梅-清华大学出版社

2-5-数据结构——从概念到C++实现(第3版)-王红梅-清华大学出版社
第二章 v 线性表
2-5 顺序表和链表的比较
讲什么?
存储分配方式的比较 静态 OR 动态


时间性能比较
基本操作的时间复杂度
结 构 (





空间性能比较
所占存储空间的大小
现 )
清 华 大 学 出 版 社
存储分配方式
顺序表:采用顺序存储结构——静态存储分配,即用一段地址连续的存
储单元依次存储线性表的数据元素,数据元素之间的逻辑关系通过存储
结论
从空间上讲,若线性表中元素个数变化较大或者未知,最好使
用链表实现;如果用户事先知道线性表的大致长度,使用顺序

表的空间效率会更高
据 结 构




从时间上讲,若线性表频繁查找却很少进行插入和删除操作,
到 实 现

或其操作和元素在表中的位置密切相关时,宜采用顺序表作为
清 华

存储结构;若线性表需频繁插入和删除时,则宜采用链表做存
按位查找
0

a1

first
插入和删除
顺序表:O(1),随机存取
链表:O(n),顺序存取
i-2 i-1 … n-1
ai-1 ห้องสมุดไป่ตู้i

an

MaxSize-1
据 结 构

长度
从 概







a1
a2
an ∧
大 学 出 版

顺序表:O(n),平均移动表长一半的元素
链表:不用移动元素,合适位置的指针——O(1)

第二章 线性表

第二章 线性表

(7)已知顺序表L中的元素有序递增,设计算法将元素x插入到L 种,并依旧保持其有序递增;设计一个高效的算法,删除顺序表 中所有值为x的元素,要求空间复杂度为O(1)。(基于顺序表基本 操作的运算) (8)(2010年13分)设将n(n>1)个整数存放到一维数组R中。试 设计一个在时间和空间两方面尽可能有效的算法,将R中保有的 序列循环左移P(0<p< n)个位置,即将R中的数据由(X0 X1 ……Xn-1)变换为(Xp Xp+1 ……Xn-1 X0 X1……Xp-1) 要求: (1)给出算法的基本设计思想。 (2)根据设计思想,采用C或C++或JAVA语言描述算法,关键之处 给出注释。 (3)说明你所设计算法的时间复杂度和空间复杂度
2 3 4 5 6
30 60 20 40
6 -1 3 1
h
10
20Βιβλιοθήκη 304050
60∧
8、例题: (1)链表不具有的特点是( )。 A.可随机访问任一元素 B.插入删除不需要移动元素 C.不必事先估计存储空间 D.所需空间与线性表长度成正比 (2)在具有n个结点的单链表中插入一个新结点并使链表仍然有 序的时间复杂度是( )。 A. O(1) B. O(n) C. O(nlog2n) D. O(n2) (3)对于由n个元素组成的线性表,创建一个有序单链表的时间 复杂度是( )。 A. O(1) B. O(n) C. O(nlog2n) D. O(n2)
(4)设A是一个线性表,采用顺序存储结构。在等概率情况下, 平均插入一个元素需要移动多少个元素?若元素插在ai和ai+1之 间的概率为(n-i)/n(n-1)/2,则平均插入一个元素需要移动多少 个元素? (5)以顺序表作为存储结构,实现线性表的就地逆置;判断回 文;设计一个时间复杂度为O(n)的算法,将顺序表中所有元素循 环左移k位;设计一个时间复杂度为O (n)的算法,将顺序表中所 有元素循环右移k位;(基于逆置操作的运算) (6)将顺序表中的元素调整为左右两部分,左边元素为奇数, 右边元素为偶数,要求算法的时间复杂度为O (n);将顺序表A拆 分为B 和C,其中B中的元素小于0,C中的元素大于0;将有序表A和 有序表B合并为C,合并后C依然是有序的。(基于对顺序表的拆分 和合并操作的运算)

线性表栈和队列

线性表栈和队列

while( p !=NULL && j < i ) { p=p->link; j++; } // 指向第i结点,i=0,1,…,当链表 //中结点数小于i时返回NULL return p; }
单链表插入算法
// 插入数据内容为value的新结点,为第i个 结点。 ListNode * Insert(ELEM value, int i) { ListNode *p,*q; q = new ListNode; p = FindIndex(i-1); if(p == NULL ) return NULL;
}
2.2.2

Байду номын сангаас
向量的运算
插入元素运算

void insert( item) ELEM remove( )

删除元素运算

插入算法
/*(设元素的类型为ELEM,nodelist是存储顺序表的 向量, msize 是此向量的最大长度, curr_len 是此向 量的当前长度,curr为此向量当前下标)*/ #include <assert.h> viod insert(ELEM item) { //需要检查当前长度不能等于msize,当前游标指针 //curr不能小于0,也不能大于当前长度
q->link = p->link; q->data = value; p->link = q; if(q->link == NULL ) last=q; return q;
}
插入过程
单链表删除算法
//删除由参数link所指定的结点
void RemoveAfter(ListNode * link) { ListNode *newlink=link; if(link!=NULL) link=link->link; delete newlink; }

数据结构练习题线性表习题及答案

数据结构练习题线性表习题及答案

数据结构练习题线性表习题及答案精品文档第二章线性表一.名词解释1.线性结构2.数据结构的顺序实现3.顺序表4.链表5.数据结构的链接实现6. 建表7.字符串8.串9.顺序串 10.链串二、填空题1.为了便于讨论,有时将含n(n>=0)个结点的线性结构表示成(a,a,……a),其中每n12个a代表一个______。

a称为______结点,a称为______结点,i称为a在线性表中的________ii1n或______。

对任意一对相邻结点a、a(1<=i<n),a称为a的直接______a称为a的直iii┼1i┼1┼i1i接______。

< bdsfid="75" p=""></n),a称为a的直接______a称为a的直iii┼1i┼1┼i1i接______。

<>2.为了满足运算的封闭性,通常允许一种逻辑结构出现不含任何结点的情况。

不含任何结点的线性结构记为______或______。

3.线性结构的基本特征是:若至少含有一个结点,则除起始结点没有直接______外,其他结点有且仅有一个直接______;除终端结点没有直接______外,其它结点有且仅有一个直接______.4.所有结点按1对1的邻接关系构成的整体就是______结构。

5.线性表的逻辑结构是______结构。

其所含结点的个数称为线性表的______,简称______.6.表长为O的线性表称为______7.线性表典型的基本运算包括:______、______、______、______、______、______等六种。

8.顺序表的特点是______。

9.顺序表的类型定义可经编译转换为机器级。

假定每个datatype 类型的变量占用k(k>=1)个内存单元,其中,b是顺序表的第一个存储结点的第一个单元的内存地址,那么,第i个结点a的存储地址为______。

第二章 顺序表、链表(答案)

第二章 顺序表、链表(答案)

A. 单链表
B. 静态链表
C.单循环链表 D. 顺序表
8. 在一个长度为 n(n>1)的单元链表上,设有头和尾两个指针,执行( B )操作与链表的长度有关.
A. 删除单链表中的第一个元素
B. 删除单链表中的最后一个元素
C. 在单链表第一个元素前插入一个新元素 D. 在单链表最后一个元素后插入一个新元素
6、向一个长度为 n 的向量的第 i 个元素(1≤i≤n+1)之前插入一个元素时,需向后移动 n-i+指向双向循环链表中的结点 X,则删除结点 X 需要执行的语句序列为
_______p->llink->rlink=p->rlink
________p->rlink->llink=p->llink______________________________________________________
11. 在 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 个结点从小到大排序
12. 向一个有 127 个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移动(
D.p->next->prior=p.
1、算法是指令的有限序列,其中每一条指令表示一个或多个操作,此外,一个算法还具有五个重要
特性,它们分别是 ___有穷性____ 、__确定性____ 、__可行性______ 、有零或多个输入和有一 或多个输出。
2、算法优劣的五个标准是正确性、可使用性、__可读性____、_健壮性_____、_高效性____。

数据结构考研笔记整理(全)

数据结构考研笔记整理(全)

数据结构考研笔记整理(全)一、第二章线性表●考纲内容●一、线性表的基本概念●线性表是具有相同数据结构类型的n个数据元素的有限序列;线性表为逻辑结构,实现线性表的存储结构为顺序表或者链表●二、线性表的实现●1、顺序表●定义(静态分配)●#define MaxSize 50 \\ typedef struct{ \\ ElemType data[MaxSize];\\ intlength;\\ }SqList;●定义(动态分配)●#define MaxSize 50\\ typedef strcut{\\ EleType *data; //指示动态非配数组的指针\\ int MaxSize,length;\\ }SqList;●c的动态分配语句为L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);●c++动态分配语句为L.data=new ElemType[InitSize];●插入操作●删除操作●按值寻找●2、链表●单链表●单链表的定义●●头插法建立单链表●●尾插法建立单链表●●按序号查找getElem(LinkList L,int i)和按值查找locateElem(LinkListL,ElemType e)●插入结点(后插)●p=getElem(L,i-1); //查找插入位置的前驱结点\\ s.next=p.next;\\p.next=s;●将前插操作转化为后插操作,即先将s插入的p的后面然后调换s和p的数据域●s.next=p.next;\\ p.next=s.next;\\ temp=p.data;\\ p.data=s.data;\\s.data=temp;●删除结点●p.getElem(L,i-1);\\ q=p.next;\\ p.next=q.next;\\ free(q);●双链表(结点中有prior指针和next指针)●循环链表●静态链表●借助数组来描述线性表的链式存储结构,结点中的指针域next为下一个元素的数组下标●三、线性表的应用●使用的时候如何选择链表还是顺序表?●表长难以估计,经常需要增加、删除操作——链表;表长可以估计,查询比较多——顺序表●链表的头插法,尾插法,逆置法,归并法,双指针法;顺序表结合排序算法和查找算法的应用●小知识点(选择题)二、第三章栈,队列和数组●考纲内容●一、栈和队列的基本概念●栈:后进先出,LIFO,逻辑结构上是一种操作受限的线性表●队列:先进先出,FIFO,逻辑结构上也是一种操作受限的线性表●二、栈和队列的顺序存储结构●栈的顺序存储●●队列的顺序存储●进队:队不满时,送值到队尾元素,再将队尾指针加一●出队:队不空时,取队头元素值,再将队头指针加一●判断队空:Q.front==Q.rear==0;●循环队列(牺牲一个单元来区分队空和队满,尾指针指向队尾元素的后一个位置,也就是即将要插入的位置)●初始:Q.front==Q.rear●队满:(Q.rear+1)%MaxSize=Q.front●出队,队首指针进1:Q.front=(Q.front+1)%MaxSize●入队,队尾指针进1:Q.rear=(Q.rear+1)%MaxSize●队列长度:(Q.rear+MaxSize-Q.front)%MaxSize●三、栈和队列的链式存储结构●栈的链式存储●●队列的链式存储●实际是上一个同时带有头指针和尾指针的单链表,尾指针指向单链表的最后一个结点,与顺序存储不同,通常带有头结点●四、多维数组的存储●行优先:00,01,02,10,11,12●列优先:00,10,01,11,02,12●五、特殊矩阵的压缩存储●对称矩阵●三角矩阵●三对角矩阵(带状矩阵)●稀疏矩阵●将非零元素及其相应的行和列构成一个三元组存储●十字链表法●六、栈、队列、数组的应用●栈在括号匹配中的应用●栈在递归中的应用●函数在递归调用过程中的特点:最后被调用的函数最先执行结束●队列在层次遍历中的应用●二叉树的层次遍历●1跟结点入队●2若队空,则结束遍历,否则重复3操作●3队列中的第一个结点出队并访问,若有左孩子,则左孩子入队;若有右孩子,则右孩子入队●重点为栈的(出入栈过程、出栈序列的合法性)和队列的操作及其特征●小知识点(选择题)●n个不同元素进栈,出栈元素不同排列的个数为{2n\choose n }/(n+1)●共享栈是指让两个顺序栈共享一个存储空间,将两个栈的栈底分别设置在共享空间的两端,两个栈顶向共享空间的中间延伸,可以更有效的利用存储空间,同时对存储效率没有什么影响●双端队列是指允许两端都可以进行入队和出队操作的队列●输出受限的双端队列:允许两端插入,只允许一端删除●输入受限的双端队列:允许两端删除,只允许一端插入三、第四章串●考纲内容●字符串模式匹配●暴力算法●注意指针回退时的操作是i=i-j+2;j=j+1;●kmp算法●手工求next数组时,next[j]=s的最长相等前后缀长度+1,其中s为1到j-1个字符组成的串●在实际kmp算法中,为了使公式更简洁、计算简单,如果串的位序是从1开始的,则next数组需要整体加一;如果串的位序是从0开始的,则next数组不需要加一●根据next数组求解nextval数组:如果p[j]==p[next[j]],则nextval[j]=nextval[next[j]],否则nextval[j]=next[j];●小知识点●串和线性表的区别:1线性表的数据元素可以不同,但串的数据元素一般是字符;2串的操作对象通常是子串而不是某一个字符四、第五章树与二叉树●考纲内容●一、树的基本概念●定义●树是一种递归的数据结构,是一种逻辑结构●树的性质●结点数为n,则边的数量为n-1●树中的结点数等于所有结点的度数之和加1(一个结点的孩子个数称为该结点的度,树中结点的最大度数称为树的度,每一条边表示一个结点,对应一个度,只有根结点上面无边,故结点树=度数之和+1)●度为m的树中第i层至多有m^{i-1}个结点(i\geq1)(m叉树的第i层最多有m^{i-1}个结点)●高度为h的m叉树至多有(m^h-1)/(m-1)个结点(假设每一个结点都有m个孩子,则由等比数列的求和公式可以推导出该式子)●具有n个结点的m叉树的最小高度是\lceil log_m(n(m-1)+1)\rceil(由高度为h的m叉树的最大结点树公式有,n满足式子(m^{h-1}-1)/(m-1) \leq n\leq (m^h-1)/(m-1))●高度为h的m叉树至少有h个结点;高为h,度为m的树至少有h+m-1个结点(m叉树并不等于度为m的树,m叉树可以为空树,要求所有结点的度小于等于m,而度为m的树一定有一个结点的度数为m)●二、二叉树●二叉树的定义及其主要特征●定义●特点●每个结点至多只有两颗子树●二叉树是有序树,其子树有左右之分,次序不能颠倒,否则将成为另一颗二叉树,即使树中结点只有一颗子树,也要区分他是左子树还是右子树●特殊的二叉树●满二叉树:高度为h,结点数为2^h-1,所有叶子结点都集中在二叉树的最下面一层,除叶子结点外的所有结点度数都为2,从根结点为1开始编号,对于编号为i的结点,其父结点为\lfloor i/2 \rfloor,左孩子(若有)编号为2i,右孩子(若有)编号为2i+1,所以编号为偶数的结点只可能是左孩子,编号为奇数的结点只可能是右孩子●完全二叉树:删除了满二叉树中编号更大的结点,高为h,结点数为n的完全二叉树的每个结点的编号都与高度为h的满二叉树中编号为1到n的结点相同。

教案小数的计数单位和数位顺序表

教案小数的计数单位和数位顺序表

小数的计数单位和数位顺序表教学目标:1. 理解小数的计数单位,掌握数位顺序表。

2. 能够运用小数的计数单位和数位顺序表进行小数的读写和计算。

教学内容:第一章:小数的计数单位1.1 小数的产生和意义1.2 小数的计数单位:十分之一、百分之一、千分之一等1.3 练习运用小数的计数单位进行读写小数第二章:数位顺序表2.1 数位顺序表的定义和作用2.2 数位顺序表的构成:个位、十位、百位、千位等2.3 练习运用数位顺序表进行小数的读写和计算第三章:小数的读写3.1 小数的读法:整数部分和小数部分的读法3.2 小数的写法:整数部分和小数部分的写法3.3 练习运用小数的读写法进行小数的读写第四章:小数的计算4.1 小数的加法:同小数位加法和异小数位加法4.2 小数的减法:同小数位减法和异小数位减法4.3 小数的乘法和小数除法:乘法和除法的基本法则4.4 练习运用小数的计算法则进行计算第五章:综合练习5.1 运用小数的计数单位和数位顺序表进行小数的读写和计算5.2 解决实际问题,运用小数的知识进行计量和计算5.3 总结小数的计数单位和数位顺序表的应用教学方法:1. 采用讲解法,讲解小数的计数单位和数位顺序表的概念和运用。

2. 采用示范法,示范小数的读写和计算方法。

3. 采用练习法,让学生通过练习运用小数的计数单位和数位顺序表进行小数的读写和计算。

教学评价:1. 课堂练习:学生在课堂上进行小数的读写和计算练习,检验学生对小数的计数单位和数位顺序表的掌握程度。

2. 课后作业:布置相关的课后作业,让学生进一步巩固小数的计数单位和数位顺序表的知识。

3. 单元测试:进行单元测试,全面检验学生对小数的计数单位和数位顺序表的掌握程度。

第六章:小数的大小比较6.1 小数的大小比较方法:先比较整数部分,再比较小数部分6.2 练习运用小数的大小比较方法进行比较第七章:小数的应用7.1 小数在日常生活中的应用:如购物、烹饪等7.2 练习运用小数解决实际问题第八章:小数的换算8.1 小数与整数的换算:如将小数转换为整数,或将整数转换为小数8.2 小数与分数的换算:如将小数转换为分数,或将分数转换为小数8.3 练习运用小数的换算方法进行换算第九章:误差与近似值9.1 误差的定义和产生原因:如测量工具的精度、人的视觉误差等9.2 近似值的定义和求法:如四舍五入法、进一法、去尾法等9.3 练习运用误差和近似值的概念进行实际问题的解决第十章:总结与拓展10.1 总结小数的计数单位和数位顺序表的知识点,强化记忆10.2 拓展小数的知识:如小数的运算规则、小数在科学计算中的应用等10.3 布置课后作业,让学生进一步巩固小数的计数单位和数位顺序表的知识教学方法:1. 采用案例分析法,通过生活中的实例讲解小数的大小比较和应用。

顺序表及其运算

顺序表及其运算
if ( ! L->list ) {printf( " Memory allocation failure ! \n" ) ; exit (1) ; }
L->len = 0 ; // 置初始线性表为空 }
2.2 顺序表及其运算
2. 顺序表的插入运算
在表中第 i个位置插入一个元素 item
设表长为 len
即:插入一元素的时间复杂度为:O(n) ② 空间复杂度:原地工作( in place )
思考:在有序顺序表中插入一个数据元素, 算法?
2.2 顺序表及其运算
3. 顺序表的删除运算 在表中删除第pos个元素 删除前:(b0,b1 ,…,bi ,bi+1 ,…,bn-1) 表长为 n ; 删除后:(b0',b1',…,bi-1',bi+1',…,bn-2' ) 表长为 n-1 ; 算法考虑:表空( L->len = 0)不能做删除 ——下溢处理;
保存现场1
a:
保存现场2
b:
保存现场3
c:
end
return
return
return
2.3 栈
为保证中断正确执行,须依次记住每层中断的现场及返回地址;
进入中断→
现场1
现场2 现场1
现场3 现场2 现场1
当各层中断“返回”时,则要按记入的相反次序逐个恢复现场继续 执行;
现场1
现场2 现场1
←中断返回
指定的删除位置不存在,要处理; 正常删除操作,表长 n 减 1; 算法描述:参考教材 算法分析: 与插入运算类似; 平均时间复杂度: O(n); 空间复杂度:原地工作
思考:在有序顺序表中删除指定元素, 算法?

教案小数的计数单位和数位顺序表

教案小数的计数单位和数位顺序表

小数的计数单位和数位顺序表第一章:小数的计数单位1.1 教学目标让学生理解小数的计数单位,包括十分之一、百分之一、千分之一等。

让学生能够用小数表示物品的单价、数量等。

培养学生运用小数进行计算和解决问题的能力。

1.2 教学内容小数的计数单位:十分之一、百分之一、千分之一等。

小数的表示方法:用小数表示物品的单价、数量等。

小数的计算方法:加法、减法、乘法、除法等。

1.3 教学步骤引入:通过实际例子,如购物场景,让学生接触到小数的计数单位。

讲解:详细讲解小数的计数单位,以及如何用小数表示物品的单价、数量等。

练习:让学生通过计算练习,运用小数的加法、减法、乘法、除法等计算方法。

1.4 作业布置让学生用小数表示一些日常生活中的物品价格和数量,如水果、零食等。

让学生完成一些小数计算的练习题,巩固所学知识。

第二章:数位顺序表2.1 教学目标让学生理解数位顺序表的概念,包括个位、十位、百位等。

让学生能够用数位顺序表表示整数和小数。

培养学生运用数位顺序表进行计算和解决问题的能力。

2.2 教学内容数位顺序表的概念:个位、十位、百位等。

小数的数位顺序表:整数部分和小数部分的数位顺序表。

小数的表示方法:用数位顺序表表示整数和小数。

2.3 教学步骤引入:通过实际例子,让学生接触到数位顺序表的概念。

讲解:详细讲解数位顺序表的概念,以及如何用数位顺序表表示整数和小数。

练习:让学生通过计算练习,运用数位顺序表表示整数和小数。

2.4 作业布置让学生用数位顺序表表示一些整数和小数,如身高、体重等。

让学生完成一些数位顺序表相关的练习题,巩固所学知识。

第三章:小数的比较3.1 教学目标让学生理解小数的大小比较方法,包括比较整数部分、比较小数部分等。

让学生能够用小数进行大小比较,并能够正确判断大小关系。

培养学生运用小数进行比较大小的能力和解决问题的能力。

3.2 教学内容小数的大小比较方法:比较整数部分、比较小数部分、比较十分位、比较百分位等。

数据结构C语言版第版习题答案—严蔚敏简化版

数据结构C语言版第版习题答案—严蔚敏简化版

数据结构C语言版第版习题答案—严蔚敏简化版 The following text is amended on 12 November 2020.第2章线性表1.选择题(1)顺序表中第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是()。

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

(3)向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变,平均要移动的元素个数为()。

A.8 B. C.63 D.7答案:B解释:平均要移动的元素个数为:n/2。

(4)链接存储的存储结构所占存储空间()。

A.分两部分,一部分存放结点值,另一部分存放表示结点间关系的指针B.只有一部分,存放结点值C.只有一部分,存储表示结点间关系的指针D.分两部分,一部分存放结点值,另一部分存放结点所占单元数答案:A(5)线性表若采用链式存储结构时,要求内存中可用存储单元的地址()。

A.必须是连续的 B.部分地址必须是连续的C.一定是不连续的 D.连续或不连续都可以答案:D(6)线性表L在()情况下适用于使用链式结构实现。

A.需经常修改L中的结点值B.需不断对L进行删除插入C.L中含有大量的结点D.L中结点结构复杂答案:B解释:链表最大的优点在于插入和删除时不需要移动数据,直接修改指针即可。

(7)单链表的存储密度()。

A.大于1 B.等于1 C.小于1 D.不能确定答案:C解释:存储密度是指一个结点数据本身所占的存储空间和整个结点所占的存储空间之比,假设单链表一个结点本身所占的空间为D,指针域所占的空间为N,则存储密度为:D/(D+N),一定小于1。

(8)将两个各有n个元素的有序表归并成一个有序表,其最少的比较次数是()。

A.n B.2n-1 C.2n D.n-1答案:A解释:当第一个有序表中所有的元素都小于(或大于)第二个表中的元素,只需要用第二个表中的第一个元素依次与第一个表的元素比较,总计比较n次。

C语言第2章上机及作业题

C语言第2章上机及作业题

第二章上机及作业题第二章上机题用三种存储结构(顺序表,链表,静态链表)求解josuphu问题!1:顺序表#include<stdio.h>#define max 100typedef struct{int data[max];int length;}stack,*pstack;pstack Creat() /*顺序表初始化*/{pstack p;p=(pstack)malloc(sizeof(stack));if(p)p->length=0;return p;}void Creatstack(pstack p) /*创建一个顺序表*/{int i,l,x;printf("please stack's length:\n");scanf("%d",&l);p->length=l;printf("please enter a stack:\n");for(i=0;i<l;i++){scanf("%d",&x);p->data[i]=x;}}Deletes(pstack p,int x) /*删除指定位置的元素*/{int i;for(i=x;i<=p->length;i++){p->data[i]=p->data[i+1];}p->length--;}int josephus(pstack p) /*约瑟夫循环*/{int s1,i,s,m,w;printf("please enter start adress:\n");scanf("%d",&s);printf("please enter how long to out eachother:\n");scanf("%d",&m);if(!p->length){printf("empty!\n");return 0;}s1=s-1;printf("please answer:\n");for(i=p->length;i>0;i--){s1=(s1+m-1)%i;w=p->data[s1];printf("%4d",w);Deletes(p,s1);}return 1;}int main() /*主函数*/ {pstack Q;Q=Creat();Creatstack(Q);josephus(Q);getch();}2:链表解决#include<stdio.h>typedef struct node /*定义一个链表结构体*/ {int data;struct node *next;}list,*List;void Putlist(List L) /*输入一个链表*/{int x,i,length;List s;L=NULL;printf("please enter the length:\n");scanf("%d",&length);printf("please enter the list:\n");for(i=0;i<length;i++){s=(List)malloc(sizeof(list));scanf("%d",&x);s->data=x;s->next=L;L=s;}s->next=L;}void Dislist(List L) /*输出链表*/{List p=L->next;printf("%d",L->data);while(p!=L){printf("%3d",p->data);p=p->next;}printf("\n");}int josephs(List L) /*约瑟夫循环的计算*/ {int s,m,count;List p,pre;printf("start in:\n");scanf("%d",&s);printf("how often:\n");scanf("%d",&m);if(!L){printf("the list is empty!\n");return 0;}p=L;for(count=1;count<s;count++){p=p->next;}printf("put the answer:\n");while(p!=p->next){for(count=1;count<m;count++) {pre=p;p=p->next;}printf("%2d",p->data);pre->next=p->next;free(p);p=pre->next;}printf(" %d",p->data);free(p);return 1;}void main(){int x,i,length;List L,s,r;s=L=(List)malloc(sizeof(list)); printf("please enter the length:\n"); scanf("%d",&length);printf("please enter the list:\n"); scanf("%d",&x);L->data=x;for(i=0;i<length-1;i++){r=(List)malloc(sizeof(list)); scanf("%d",&x);r->data=x;s->next=r;s=s->next;}s->next=L;josephs(L);getch();}3:静态链表#include<stdio.h>#define MAXSIZE 100struct node{int number;int next;}string[MAXSIZE];int josephus(void) /*约瑟夫循环*/ {int total;int out;int start;int i,j=1;int flag=0;int current,front;printf("The total number is:");scanf("%d",&total);printf("The out number is:");scanf("%d",&out);printf("The starting number is:");scanf("%d",&start);if(out==1) return total;for(i=0;i<total;i++){string[i].number=i+1;string[i].next=i+1;}string[i-1].next=0;front=total-1;current=0;for(i=1;i<start;i++){front=string[front].next;current =string[current].next;}while(flag<total){if(j%out==0){string[front].next=string[current].next;current=string[front].next;j=1;flag++;}else{j++;front=string[front].next;current =string[current].next;}}return(string[current].number);}void main(){int t;t=josephus();printf("The last one is %d",t);getch();}第二章作业:1.已知递增有序的两个单链表A,B分别存储了一个集合。

数据结构(第二版)课后习题答案

数据结构(第二版)课后习题答案

数据结构(第二版)课后习题答案第一章:数据结构概述数据结构是计算机科学中非常重要的一个概念,它用于组织和管理计算机内部存储的数据。

数据结构的设计直接影响到程序的运行效率和对真实世界问题的建模能力。

第二版的《数据结构》教材旨在帮助读者更好地理解和应用数据结构。

为了提高学习效果,每章节后都附有一系列习题。

本文将为第二版《数据结构》教材中的部分习题提供详细的答案和解析。

第二章:线性表2.1 顺序表习题1:请问如何判断顺序表是否为空表?答案:当顺序表的长度为0时,即为空表。

解析:顺序表是用一块连续的内存空间存储数据元素的线性结构。

当顺序表中没有元素时,长度为0,即为空表。

习题2:如何求顺序表中第i个元素的值?答案:可以通过访问顺序表的第i-1个位置来获取第i个元素的值。

解析:顺序表中的元素在内存中是连续存储的,通过下标访问元素时,需要将下标减1,因为数组是从0开始编号的。

2.2 链表习题1:请问链表中的结点包含哪些信息?答案:链表的结点一般包含两部分信息:数据域和指针域。

解析:数据域用于存储数据元素的值,指针域用于存储指向下一个结点的指针。

习题2:如何删除链表中的一个结点?答案:删除链表中的一个结点需要将其前一个结点的指针指向其后一个结点,然后释放被删除结点的内存空间。

解析:链表的删除操作相对简单,只需要通过修改指针的指向即可。

但需要注意释放被删除结点的内存空间,防止内存泄漏。

第三章:栈和队列3.1 栈习题1:如何判断栈是否为空?答案:当栈中没有任何元素时,即为空栈。

解析:栈是一种先进后出(Last In First Out,LIFO)的数据结构,栈顶指针指向栈顶元素。

当栈中没有元素时,栈顶指针为空。

习题2:请问入栈和出栈操作的时间复杂度是多少?答案:入栈和出栈操作的时间复杂度均为O(1)。

解析:栈的入栈和出栈操作只涉及栈顶指针的改变,不受栈中元素数量的影响,因此时间复杂度为O(1)。

3.2 队列习题1:请问队列可以用哪些方式实现?答案:队列可以用数组或链表来实现。

数据结构导论 第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++; //修改表长 } }
常见的线性表的基本运算有以下几个: 常见的线性表的基本运算有以下几个:

污水处理厂、自来水厂工程文件归档内容及顺序表

污水处理厂、自来水厂工程文件归档内容及顺序表

污水处理厂、自来水厂工程文件归档内容及顺序表建设工程名称:表一
污水处理厂、自来水厂工程文件归档内容及顺序表建设工程名称:表二
污水处理厂、自来水厂工程文件归档内容及顺序表建设工程名称:表三
污水处理厂、自来水厂工程文件归档内容及顺序表建设工程名称:表四
污水处理厂、自来水厂工程文件归档内容及顺序表建设工程名称:表五
污水处理厂、自来水厂工程文件归档内容及顺序表建设工程名称:表六
污水处理厂、自来水厂工程文件归档内容及顺序表建设工程名称:表七
污水处理厂、自来水厂工程文件归档内容及顺序表建设工程名称:表八
移交人接收人
建设单位名称接收单位
日期日期。

2-3-数据结构——从概念到C++实现(第3版)-王红梅-清华大学出版社

2-3-数据结构——从概念到C++实现(第3版)-王红梅-清华大学出版社

private:
DataType data[MaxSize];
int length;
};
顺序表的实现——初始化
初始化顺序表的函数原型是什么?
InitList 输入:无
SeqList<DataType> :: SeqList( )
数 据
{
结 构
功能:表的初始化,建一个空表
Length = 0;
( 从 概






i-2 i-1 … n-1
MaxSize-1
从 概

… ai-1 ai … an
长度
到 实 现



c
大 学
出Hale Waihona Puke 版Loc(ai)Loc(ai) = Loc(a1) + (i -1)×c 社
如何求得任意元素的存储地址?
存取时间是O(1)
Page 07
存储结构与存取结构
随机存取:在O(1)时间内存取数据元素
出 版 社
随机存取
顺序表的实现——按值查找
template <typename DataType>
int SeqList<DataType> :: Locate(DataType x)
{
for (int i = 0; i < length; i++)
数 据

if (data[i] == x) return i+1;
顺序表的实现——类定义
线性表的抽象数据类型定义?
InitList:表的初始化,建一个空表 DestroyList:销毁表,释放表所占用的存储空间 Length:求表的长度 Get:在表中取序号为 i 的数据元素 Locate:在线性表中查找值等于 x 的元素 Insert:在表的第 i 个位置处插入一个新元素 x Delete:删除表中的第 i 个元素 Empty:判断表是否为空

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

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

数据结构与算法华东师范大学计算机系杨沛第二章线性表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。

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

由于上述关系是线性的-------------线性结构。
6
2.1.2线性表的基本操作
(1) 初始化操作 initlist(L) 建立一个空表。 (2) 求表长操作 getlen(L) 返回线性表L的长度。 (3) 元素定位操作locate(L,x)
返回元素x在线性表L中第一次出现的位置,存在,返 回其位序,否则,返回-1 (4) 取元素操作 getelem(L, i) 返回线性表L的第i个元素的值。 (5) 插入操作 insert(L,x,i) 在线性表L 的第i个位置上插入一个值为x的元素。 i的合法取值范围是:1≤i≤n+1 (6) 删除操作 delete(L,i) 删除线性表L的第i个元素,i的合法到值范围是: 1≤i≤n+1 (7) 输出操作 print(L) 按先后顺序输出线性表L的所有元素值。
return 0; else return i+1;/*找到返回位序*/
算法} 性能分析:
时间性能 查找成功:平均时间复杂度 T(n)= 查找失败: T(n)=n=O(n)
n
pi*ti=
i=1
_1_ n
n i=1
i= n_+2_1
=O(n)
空间性能 O(1)
15
(5)插入操作 在线性表中指定位置i前插入一个元素x,成功返回1,失 败返回0。 插入元素时,线性表的逻辑结构由 (a1, …, ai-1, ai, …, an)
动表的一半元素,当n很大时,效率很低
23
(7)输出操作 void print(sqlist L) { int i; for(i=0; i<L->length;i++) printf(“%4d ”,L->data[i]); printf(“\n”); }
24
例 有两个顺序表L1和L2,其元素均为非递减有 序排列, 编写算法,将其合并成一个顺序表L, 要 求L也是非递减有序排列。 例如L1=(2, 2, 3), L2=(1, 3, 3, 4), 则L=(1, 2, 2, 3, 3, 3, 4)。
14
(4)元素定位操作
int locate(sqlist L, ElemType x) {/*从线性表中查找具有给定值x的第一个元素 若找到,则返回其在L中的位序,否则返回0。*/
int i=0; /*从前向后扫描顺序表,没找到i值加1*/
while( i<L.length && L.data[i]!=x) i++; if(i==L.length)/*没找到返回0*/
/*判断位置合法性*/ if (i<1||i>L->length+1) return 0; /*存储空间不足,增加存储空间*/ if(L->length= =L->listsize) {
L->data =(ElemType *)realloc(L->data, (L-> listsize+1) *sizeof(ElemType)); if(!L->data) {printf(“OVERFLOWER!\n”); return 0;} L->listsize++; } /*将序号i的结点及之后的结点后移一位*/ for(j=L->length-1;j >= i-1;j--) L->data[j+1]=L->data[j]; /*在序号i处放入x*/ L->data[i-1]=x; /*表长加1*/ L->length++; return 1; }
int getelem(sqlist L,int i, ElemType *e) {/*取出顺序表L的第i个数据元素的值*/
if (i>=1 && i<=L.length) {*e = L.data[i-1]; return 1;}
else return 0;
} 算法性能分析:时间性能 O(1) 空间性能 O(1)
L =(a1, a2, … ai-1,ai, ai+1 ,…, an)
线性起点
下标i,是元素ai 的序号 ,表示ai
在表中的位置
数据元素
ai的直接前趋 ai的直接后继 线性终点
n=0时称为 空表
n为元素总个
数,即表长
5
说明: 1、数据元素可以是一个数,一个符号或一个记录等,但 同一线性表中的元素必须属于同一种数据对象。
2
T n On
19
(6)删除操作 在顺序表中删除第i个元素: 顺序表的逻辑结构由(a1, …, ai-1, ai, ai+1, …, an) 改变为 (a1, …, ai-1, ai+1, …, an)
算法思想 1)检查i值是否超出所允许的范围(1≤i≤n),若 超出,则进行“超出范围”错误处理; 2)将表的第i个元素后面的所有元素均向前移动一 个位置; 3)使表的长度减1。
例1、一年的月份号(1,2,3,4,5,…,12) 例2、英文字母表(a, b, c, , ,z ) 例3、某单位的电话号码簿
姓名
电话号码
蔡颖
63214444
陈红
63217777
刘建平 63216666
王小林 63218888
张力
63215555
2、线性表的..结. 构是通过数据元素之间的相邻关系来体现的。
16
数组下标 内存 元素序号 数组下标 内存 元素序号
0
a1 1
1
a2 2
0
a1 1
1
a2 2
i-1 ai i
i
ai+1 i+1
n-1 an n
n
n+1
i-1 x i
i
ai i+1
ai+1
n-1 an-1 n
n
an n+1
插入前
插入后
图2.2顺序表插入操作
17
int insert (sqlist *L,int i,ElemType x) { int j;
10
顺序表的类型定义 :
typedef int ElemType; /*在实际问题中,根据需要定义所需的数据类型*/
#definห้องสมุดไป่ตู้ INITSIZE 100 /*顺序表存储空间的初始分配量*/
typedef struct
{ ElemType *data; /*存储空间基地址*/
int length;
算法性能分析:时间性能 O(1) 空间性能 O(1)
12
(2)求表长操作 统计顺序表L数据元素的个数 int getlen(sqlist L) {/*统计顺序表L数据元素的个数*/
return(L.length); }
算法性能分析:时间性能 O(1) 空间性能 O(1)
13
(3)取元素操作 取出顺序表L的第i个数据元素的值,将值通过 参数e带回,成功返回1,失败返回0. 注意i的合法取值范围: 1≤ i ≤ length
3
2.5 队列 2.5.1队列的定义及其基本操作 2.5.2顺序队列的表示和实现
*2.5.3链队列的表示和实现
2.6 串 2.6.1串的定义及其基本操作 2.6.2顺序串的表示和实现
*2.6.3链串的表示和实现 *2.6.4串的模式匹配
4
§2.1 线性表的定义及基本操作
2.1.1线性表的基本概念 定义:线性表是n(n≥0)个数据元素的有限序列,可记作:
算法思想:设表L是一个空表,为使L也是非递减有序 排列,可设两个指针i,j分别指向表L1和L2中的元素, 从两个顺序表的第1个元素开始进行比较: 若L1.data[i]≤L2.data[j],将L1.data[i]插入到L表尾 若L1.data[i]>L2.data[j],将L2.data[j]插入到L表尾 如此进行下去,直到其中一个表被扫描完毕,然后再 将未扫描完的表中剩余的所有元素放到表L中。
/*检查位置的合法性*/ if(i<1 || i>L->length)
return 0; /*将表的第i个元素后面的所有元素均向前移动一 个位置*/ for(j=i;j<=L->len-1;j++)
L->data[j-1]=L->data[j]; /*表长减1*/ L->length--; return 1; }
18
顺序表插入操作时间性能分析:
插入操作的时间主要花费在元素后移上
设Pi是在第i个元素之前插入一个元素的概率,则在 长度为n的线性表中插入一个元素时,所需移动的 元素的平均次数为:
n1
Eins
P(n i
i
1)
i 1
若认为P 1 i n 1
则Eins
1
n1
n
(n i 1)
n 1 i1
7
说明: 1 上面列出的操作,只是线性表的一些常用的基本操 作; 2 不同的应用,基本操作可能是不同的; 3 线性表的复杂操作可通过基本操作实现;
8
§2.2顺序表 -----线性表的顺序存储结构
2.2.1顺序表的定义 1.定义:用一组地址连续的存储单元将逻辑上相邻的 元素存放在物理地址也相邻的存储单元。
20
数组下标 内存 元素序号 数组下标 内存 元素序号
0
a1
1
1
a2 2
0
a1
1
1
a2
2
i-1 ai i
i
ai+1 i+1
i-1
ai+1
i
i
ai+2 i+1
n-1 an n
n
相关文档
最新文档