数据结构—矩阵课后题

合集下载

数据结构课后习题答案详解(C语言版_严蔚敏) 2

数据结构课后习题答案详解(C语言版_严蔚敏) 2

数据结构习题集答案(C语言版严蔚敏)第2章线性表2.1 描述以下三个概念的区别:头指针,头结点,首元结点(第一个元素结点)。

解:头指针是指向链表中第一个结点的指针。

首元结点是指链表中存储第一个数据元素的结点。

头结点是在首元结点之前附设的一个结点,该结点不存储数据元素,其指针域指向首元结点,其作用主要是为了方便对链表的操作。

它可以对空表、非空表以及首元结点的操作进行统一处理。

2.2 填空题。

解:(1) 在顺序表中插入或删除一个元素,需要平均移动表中一半元素,具体移动的元素个数与元素在表中的位置有关。

(2) 顺序表中逻辑上相邻的元素的物理位置必定紧邻。

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

(3) 在单链表中,除了首元结点外,任一结点的存储位置由其前驱结点的链域的值指示。

(4) 在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。

2.3 在什么情况下用顺序表比链表好?解:当线性表的数据元素在物理位置上是连续存储的时候,用顺序表比用链表好,其特点是可以进行随机存取。

2.4 对以下单链表分别执行下列各程序段,并画出结果示意图。

解:2.5 画出执行下列各行语句后各指针及链表的示意图。

L=(LinkList)malloc(sizeof(LNode)); P=L;for(i=1;i<=4;i++){P->next=(LinkList)malloc(sizeof(LNode));P=P->next; P->data=i*2-1;}P->next=NULL;for(i=4;i>=1;i--) Ins_LinkList(L,i+1,i*2);for(i=1;i<=3;i++) Del_LinkList(L,i);解:2.6 已知L是无表头结点的单链表,且P结点既不是首元结点,也不是尾元结点,试从下列提供的答案中选择合适的语句序列。

a. 在P结点后插入S结点的语句序列是__________________。

数据结构课后习题答案第七章

数据结构课后习题答案第七章

第七章图(参考答案)7.1(1)邻接矩阵中非零元素的个数的一半为无向图的边数;(2)A[i][j]= =0为顶点,I 和j无边,否则j和j有边相通;(3)任一顶点I的度是第I行非0元素的个数。

7.2(1)任一顶点间均有通路,故是强连通;(2)简单路径V4 V3 V1 V2;(3)0 1 ∞ 1∞ 0 1 ∞1 ∞ 0 ∞∞∞ 1 0邻接矩阵邻接表(2)从顶点4开始的DFS序列:V5,V3,V4,V6,V2,V1(3)从顶点4开始的BFS序列:V4,V5,V3,V6,V1,V27.4(1)①adjlisttp g; vtxptr i,j; //全程变量② void dfs(vtxptr x)//从顶点x开始深度优先遍历图g。

在遍历中若发现顶点j,则说明顶点i和j间有路径。

{ visited[x]=1; //置访问标记if (y= =j){ found=1;exit(0);}//有通路,退出else { p=g[x].firstarc;//找x的第一邻接点while (p!=null){ k=p->adjvex;if (!visited[k])dfs(k);p=p->nextarc;//下一邻接点}}③ void connect_DFS (adjlisttp g)//基于图的深度优先遍历策略,本算法判断一邻接表为存储结构的图g种,是否存在顶点i //到顶点j的路径。

设 1<=i ,j<=n,i<>j.{ visited[1..n]=0;found=0;scanf (&i,&j);dfs (i);if (found) printf (” 顶点”,i,”和顶点”,j,”有路径”);else printf (” 顶点”,i,”和顶点”,j,”无路径”);}// void connect_DFS(2)宽度优先遍历全程变量,调用函数与(1)相同,下面仅写宽度优先遍历部分。

数据结构课后习题答案(耿国华版

数据结构课后习题答案(耿国华版

第1章绪论2 、(1)×(2)×(3) √3 、(1)A(2)C(3)C5、f or计(算i=下1n程;序中 1 得语句频度for(j=1;j<=i; j++)for(k=1;k<=j;k ++)x=x+1;【解答】 x=x+1 得语句频度为:T(n)=1+(1+2)+(1+2+3)+. …+(1+2+……+n)=n(n+1)(n+2)/66 、编写算法,求一元多项式p。

(x)=a。

+a,x+a₂X2+……、+a Xn得值p(x) 并确定算法中每一语句得执行次数与整个算法得时间复杂度,要求时间复杂度尽可能小,规定算法中不能使用求幂函数.注意:本题中得输入为a,(i=01,…n)、x 与n,输出为P。

(x)。

算法得输入与输出采用下列方法(1)通过参数表中得参数显式传递(2)通过全局变量隐式传递。

讨论两种方法得优缺点,并在算法中以您认为较好得一种实现输入输出.【解答】(1)通过参数表中得参数显式传递优点:当没有调用函数时,不占用内存,调用结束后形参被释放,实参维持,函数通用性强,移置性强。

缺点:形参须与实参对应,且返回值数量有限。

(2)通过全局变量隐式传递优点:减少实参预形参得个数,从而减少内存空间以及传递数据时得时间消耗缺点:函数通用性降低,移植性差算法如下:通过全局变量隐式传递参数PolyValue({ int,in;floatx,a[]p;pri n tf(hn=”);s c anf(“%f,”&n);printf(“x=”;)sca nf(“%f&x);f or(i=0;i<n; i++)s c anf(%f ,&a[i]; /*执行次数:n 次 */p=a[0];for (i=1;i<=n;i++){ p=p+a [i]*x; /*执行次数:n次*/x= x*x;}prin t f(%f” p);}算法得时间复杂度:T(n)=0(n)通过参数表中得参数显式传递f loat PolyVa lue(float a[ ], float x, i nt n)f 1 oat p, s;int;is p a X0];for(=1;i<= n;i++)/执行次数:n 次*/{s=s+a [i]* p;p=p*x;}re turn(p);算法得时间复杂度:T(n)=O(n)第2章线性表习题1、填空:(1)在顺序表中插入或者删除一个元素,需要平均挪移一半元素,具体挪移得元素个数与插入或者删除得位置有关。

矩阵练习题及答案

矩阵练习题及答案

矩阵练习题及答案矩阵是线性代数中的一个重要概念,也是在数学、物理、计算机科学等领域中广泛应用的工具。

通过解矩阵练习题,可以帮助我们加深对矩阵运算和性质的理解。

下面给出一些矩阵练习题及其答案,供大家参考。

1. 问题描述:已知矩阵 A = [4 2],求 A 的转置矩阵 A^T。

解答:矩阵的转置就是将矩阵的行和列互换得到的新矩阵。

因此,A 的转置矩阵为 A^T = [4; 2]。

2. 问题描述:已知矩阵 B = [1 -2; 3 4],求 B 的逆矩阵 B^-1。

解答:对于一个可逆矩阵 B,其逆矩阵 B^-1 满足 B * B^-1 = I,其中 I 是单位矩阵。

通过矩阵的求逆公式,可以得到 B 的逆矩阵 B^-1 = [4/11 2/11; -3/11 1/11]。

3. 问题描述:已知矩阵 C = [2 1; -3 2],求 C 的特征值和特征向量。

解答:矩阵的特征值和特征向量是矩阵在线性变换下的重要性质。

特征值λ 是方程 |C - λI| = 0 的根,其中 I 是单位矩阵。

解方程可得特征值λ1 = 1 和λ2 = 3。

特征向量 v1 对应于特征值λ1,满足矩阵C * v1 = λ1 *v1,解方程可得 v1 = [1; -1]。

特征向量 v2 对应于特征值λ2,满足矩阵C * v2 = λ2 * v2,解方程可得 v2 = [1; 3]。

4. 问题描述:已知矩阵 D = [1 2 -1; 3 2 4],求 D 的行列式和秩。

解答:矩阵的行列式表示线性变换后单位面积或单位体积的变化率。

计算 D 的行列式可得 det(D) = 1 * (2*4 - 4*(-1)) - 2 * (3*4 - 1*(-1)) + (-1) * (3*2 - 1*2) = 10。

矩阵的秩表示矩阵中独立的行或列的最大个数。

对矩阵 D 进行行变换得到矩阵的行最简形式为 [1 0 6; 0 1 -3],因此 D 的秩为 2。

矩阵习题带答案

矩阵习题带答案

矩阵习题带答案矩阵习题带答案矩阵是线性代数中的重要概念,广泛应用于各个领域。

掌握矩阵的运算和性质对于学习线性代数和解决实际问题都具有重要意义。

在这篇文章中,我们将提供一些矩阵习题,并附上详细的解答,帮助读者更好地理解和掌握矩阵的相关知识。

1. 习题一已知矩阵A = [1 2 3; 4 5 6; 7 8 9],求矩阵A的转置矩阵AT。

解答:矩阵A的转置矩阵AT即将A的行变为列,列变为行。

因此,矩阵A的转置矩阵为:AT = [1 4 7; 2 5 8; 3 6 9]2. 习题二已知矩阵B = [2 4; 1 3],求矩阵B的逆矩阵B-1。

解答:对于一个二阶矩阵B,如果其行列式不为零,即|B| ≠ 0,那么矩阵B存在逆矩阵B-1,且B-1 = (1/|B|) * [d -b; -c a],其中a、b、c、d分别为矩阵B的元素。

计算矩阵B的行列式:|B| = ad - bc = (2*3) - (4*1) = 6 - 4 = 2因此,矩阵B的逆矩阵为:B-1 = (1/2) * [3 -4; -1 2]3. 习题三已知矩阵C = [1 2 3; 4 5 6],求矩阵C的秩rank(C)。

解答:矩阵的秩是指矩阵中非零行的最大个数,也可以理解为矩阵的行向量或列向量的最大线性无关组的向量个数。

对于矩阵C,我们可以通过高斯消元法将其化为行简化阶梯形矩阵:[1 2 3; 0 -3 -6]可以看出,矩阵C中非零行的最大个数为1,因此矩阵C的秩为1。

4. 习题四已知矩阵D = [2 1; -1 3],求矩阵D的特征值和特征向量。

解答:对于一个n阶矩阵D,如果存在一个非零向量X,使得D*X = λ*X,其中λ为常数,则称λ为矩阵D的特征值,X为对应的特征向量。

首先,我们需要求解矩阵D的特征值,即求解方程|D - λI| = 0,其中I为n阶单位矩阵。

计算矩阵D - λI:[D - λI] = [2-λ 1; -1 3-λ]设置行列式等于零,得到特征值的方程式:(2-λ)(3-λ) - (1)(-1) = 0λ^2 - 5λ + 7 = 0解特征值的方程,得到两个特征值:λ1 = (5 + √(-11))/2λ2 = (5 - √(-11))/2由于特征值的计算涉及到虚数,这里不再继续计算特征向量。

数据结构第七章课后习题答案 (1)

数据结构第七章课后习题答案 (1)

7_1对于图题7.1(P235)的无向图,给出:(1)表示该图的邻接矩阵。

(2)表示该图的邻接表。

(3)图中每个顶点的度。

解:(1)邻接矩阵:0111000100110010010101110111010100100110010001110(2)邻接表:1:2----3----4----NULL;2: 1----4----5----NULL;3: 1----4----6----NULL;4: 1----2----3----5----6----7----NULL;5: 2----4----7----NULL;6: 3----4----7----NULL;7: 4----5----6----NULL;(3)图中每个顶点的度分别为:3,3,3,6,3,3,3。

7_2对于图题7.1的无向图,给出:(1)从顶点1出发,按深度优先搜索法遍历图时所得到的顶点序(2)从顶点1出发,按广度优先法搜索法遍历图时所得到的顶点序列。

(1)DFS法:存储结构:本题采用邻接表作为图的存储结构,邻接表中的各个链表的结点形式由类型L_NODE规定,而各个链表的头指针存放在数组head中。

数组e中的元素e[0],e[1],…..,e[m-1]给出图中的m条边,e中结点形式由类型E_NODE规定。

visit[i]数组用来表示顶点i是否被访问过。

遍历前置visit各元素为0,若顶点i被访问过,则置visit[i]为1.算法分析:首先访问出发顶点v.接着,选择一个与v相邻接且未被访问过的的顶点w访问之,再从w 开始进行深度优先搜索。

每当到达一个其所有相邻接的顶点都被访问过的顶点,就从最后访问的顶点开始,依次退回到尚有邻接顶点未曾访问过的顶点u,并从u开始进行深度优先搜索。

这个过程进行到所有顶点都被访问过,或从任何一个已访问过的顶点出发,再也无法到达未曾访问过的顶点,则搜索过程就结束。

另一方面,先建立一个相应的具有n个顶点,m条边的无向图的邻接表。

数据结构(c语言版)课后习题答案完整版

数据结构(c语言版)课后习题答案完整版
Push( &s, t[i]);
while( !EmptyStack( &s))
{// 每弹出一个字符与相应字符比较
temp=Pop (&s);
if( temp!=S[i]) return 0 ;// 不等则返回0
else i++;
}
return 1 ; // 比较完毕均相等则返回 1
}
(7)假设以数组Q[m]存放循环队列中的元素,同时设置一个标志tag,以tag==0和tag ==1来区别在队头指针(front)和队尾指针(rear)相等时,队列状态为“空”还是“满”。试编写与此结构相应的插入(enqueue)和删除(dlqueue)算法。
t串
a b c a a b b a b c a b
next[j]
0 1 1 1 2 2 3 1 2 3 4 5
nextval[j]
0 1 1 0 2 1 3 0 1 1 0 5
(3)数组A中,每个元素A[i,j]的长度均为32个二进位,行下标从-1到9,列下标从1到11,从首地址S开始连续存放主存储器中,主存储器字长为16位。求:
(5)因为x++共执行了n-1+n-2+……+1= n(n-1)/2,所以执行时间为O(n2)
(6)O( )

1.选择题
babadbcabdcddac
2.算法设计题
(6)设计一个算法,通过一趟遍历在单链表中确定值最大的结点。
ElemType Max (LinkList L ){
if(L->next==NULL) return NULL;
rear=(rear+ 1 ) %m;//队尾位置进1,队尾指针指示实际队尾位置

数据结构课后习题及答案

数据结构课后习题及答案

填空题(10 * 1’ = 10’)一、概念题2.2.当对一个线性表经常进行的是插入和删除操作时,采用链式存储结构为宜。

2.3.当对一个线性表经常进行的是存取操作,而很少进行插入和删除操作时,最好采用顺序存储结构。

2.6.带头结点的单链表L中只有一个元素结点的条件是L->Next->Next==Null。

3.6.循环队列的引入,目的是为了克服假溢出。

4.2.长度为0的字符串称为空串。

4.5.组成串的数据元素只能是字符。

4.8.设T和P是两个给定的串,在T中寻找等于P的子串的过程称为模式匹配,又称P为模式。

7.2.为了实现图的广度优先搜索,除一个标志数组标志已访问的图的结点外,还需要队列存放被访问的结点实现遍历。

5.7.广义表的深度是广义表中括号的重数7.8.有向图G可拓扑排序的判别条件是有无回路。

7.9.若要求一个稠密图的最小生成树,最好用Prim算法求解。

8.8.直接定址法法构造的哈希函数肯定不会发生冲突。

9.2.排序算法所花费的时间,通常用在数据的比较和交换两大操作。

1.1.通常从正确性﹑可读性﹑健壮性﹑时空效率等几个方面评价算法的(包括程序)的质量。

1.2.对于给定的n元素,可以构造出的逻辑结构有集合关系﹑线性关系树形关系﹑图状关系四种。

1.3.存储结构主要有顺序存储﹑链式存储﹑索引存储﹑散列存储四种。

1.4.抽象数据类型的定义仅取决于它的一组逻辑特性,而与存储结构无关,即不论其内部结构如何变化,只要它的数学特性不变,都不影响其外部使用。

1.5.一个算法具有五大特性:有穷性﹑确定性﹑可行性,有零个或多个输入﹑有一个或多个输入。

2.8.在双向链表结构中,若要求在p指针所指的结点之前插入指针为s所指的结点,则需执行下列语句:s->prior= p->prior; s->next= p; p->prior- next= s; p->prior= s;。

2.9.在单链表中设置头结点的作用是不管单链表是否为空表,头结点的指针均不空,并使得对单链表的操作(如插入和删除)在各种情况下统一。

数组和矩阵(数据结构)

数组和矩阵(数据结构)

数组和矩阵1、(2分)【单选题】某串的长度小于一个常数,则采用( )存储方式最节省空间A、链式B、顺序C、堆结构D、无法确定参考答案:B解析:串的顺序和链式存储结构2、(2分)【单选题】与线性表相比,串的插入和删除操作的特点是( )。

A、通常以串整体作为操作对象B、需要更多的辅助空间C、算法的时间复杂度较高D、涉及移动的元素更多参考答案:A解析:串的基本运算3、(2分)【单选题】在稀疏矩阵的三元组表示法中,每个三元组表示( )。

A、矩阵中非零元素的值B、矩阵中数据元素的行号和列号C、矩阵中数据元素的行号、列号和值D、矩阵中非零数据元素的行号、列号和值参考答案:D解析:二维数组的存储结构及求址方法4、(2分)【单选题】已知二维数组A8X10,按行存储时,元素a12的地址为1000,每个元素占2个字节,则元素a00的地址为( )A、972B、974C、976D、978参考答案:C解析:二维数组的存储结构及求址方法5、(2分)【单选题】数组通常具有的两种基本操作是( )A、建立和删除B、索引和修改C、查找和修改D、查找和索引参考答案:C解析:二维数组的存储结构及求址方法6、(2分)【单选题】在长度为n的字符串S的第i个位置插入另外一个字符串,i的合法值应该是( )。

A、i>0B、i≤nC、1≤i≤nD、1≤i≤n+1参考答案:D解析:串的基本运算7、(2分)【单选题】两个字符串相等的条件是( )。

A、两串的长度相等B、两串包含的字符相同C、两串的长度相等,并且两串包含的字符相同D、两串的长度相等,并且对应位置上的字符相同参考答案:D解析:串的基本运算8、(2分)【单选题】设有串s=“software”,则其子串的数目是( )。

A、36B、37C、8D、9参考答案:B解析:串的基本运算9、(2分)【单选题】广义表A=((x,(a,b)),((x,(a,b)),y),y),则运算head(head(tail(A)))为( )A、xB、(a,b)C、(x,(a,b))D、A参考答案:C解析:广义表的概念10、(2分)【单选题】串的模式匹配是指( )。

数据结构第五章习题课

数据结构第五章习题课

1、特殊矩阵和稀疏矩阵哪一种压缩存储后会失去随机存取的功能?为什么?答:后者在采用压缩存储后将会失去随机存储的功能。

因为在这种矩阵中,非零元素的分布是没有规律的,为了压缩存储,就将每一个非零元素的值和它所在的行、列号作为一个结点存放在一起,这样的结点组成的线性表中叫三元组表,它已不是简单的向量,所以无法用下标直接存取矩阵中的元素。

2、二维数组M的元素是4个字符(每个字符占一个存储单元)组成的串,行下标i的范围从0到4,列下标j的范围从0到5,M按行存储时元素M[3][5]的起始地址与M按列存储时元素()的起始地址相同。

A、M[2][4]B、M[3][4]C、M[3][5]D、M[4][4]为第3、设有一个10阶的对称矩阵A,采用压缩存储方式,以行序为主存储,a11的地址为()。

一元素,其存储地址为1,每个元素占一个地址空间,则a85A. 13B. 33C. 18D. 404、若对n阶对称矩阵A以行序为主序方式将其下三角形的元素(包括主对角线(i<j)上所有元素)依次存放于一维数组B[1..(n(n+1))/2]中,则在B中确定aij的位置k的关系为( )。

A. i*(i-1)/2+jB. j*(j-1)/2+iC. i*(i+1)/2+jD. j*(j+1)/2+i5、设A是n*n的对称矩阵,将A的对角线及对角线上方的元素以列为主的次序(1≤i,j≤n,且i≤j)存放在一维数组B[1..n(n+1)/2]中,对上述任一元素aij在B中的位置为( )。

A. i(i-l)/2+jB. j(j-l)/2+iC. j(j-l)/2+i-1D. i(i-l)/2+j-16、设二维数组A[1.. m,1.. n](即m行n列)按行存储在数组B[1.. m*n]中,则二维数组元素A[i,j]在一维数组B中的下标为( )。

A.(i-1)*n+jB.(i-1)*n+j-1C. i*(j-1)D. j*m+i-17、有一个100*90的稀疏矩阵,非0元素有10个,设每个整型数占2字节,则用三元组表示该矩阵时,所需的字节数是()。

《数据结构》第八章习题参考答案 (1)

《数据结构》第八章习题参考答案 (1)
《数据结构》第八章习题参考答案
一、判断题(在正确说法的题后括号中打“√”,错误说法的题后括号中打“×”)
1、用邻接矩阵法存储一个图所需的存储单元数目与图的边数有关。(×)
2、有e条边的无向图,在邻接表中有e个结点。(×)
3、强连通图的各顶点间均可达。(√)
4、无向图的邻接矩阵一定是对称矩阵,有向图的邻接矩阵一定是非对称矩阵。(×)
注: 答案并不唯一
2、课本P3928.1题
【解答】
(1)不是强连通图
(2)简单路径如:D->B->C->F
(3)略
(4)邻接表见图,其他略
3、课本P3928.2题
【解答】
(1)邻接矩阵表示:无向图的边数为
矩阵中非零元素的个数/2;有向图的边数为矩阵中非零元素的个数。
邻接表表示时:无向图的边数为邻接表中边结点的个数/2;有向图的边数为邻接表中边结点的个数。
5、课本P3928.4题
【解答】
用邻接矩阵表示图,矩阵元素的个数是顶点个数的平方,与边的条数无关。矩阵中非零元素的个数与边的条数有关。
6、课本P3928.5题
【解答】
一个图中有1000个顶点,其邻接矩阵中的矩阵元素有10002= 1000000个。它有1000个非零元素(对于有向图)或2000个非零元素(对于无向图),是稀疏矩阵。
(2)邻接矩阵表示:顶点i和j是否有边只需看i行j列(或j行i列)矩阵元素是否非零;
邻接表表示时:看i顶点(或j顶点)的边结点链表中是否存在地址指向j顶点(或i顶点)的结点。
(3)邻接矩阵表示:无向图的任意顶点的度=顶点所对应行(或列)的非零矩阵元素个数。
有向图的任意顶点的度=顶点所对应行和对应列的非零矩阵元素个数之和。

数据结构课后题答案(1-4章)

数据结构课后题答案(1-4章)

数据结构部分课后习题答案第一章1.1数据的逻辑结构是从具体问题中抽象出来的数学模型,体现了事物的组成和事物之间的逻辑关系。

数据的存储结构主要用来解决各种逻辑结构在计算机中物理存储表示的问题。

1.2事前分析和事后统计事前分析:优点,程序不必运行,所得结果只依赖于算法本身缺点,不够精确事后统计:优点,精确缺点,必须运行程序,所得结果依赖于硬件、环境等因素考虑赋值、运算操作执行的次数第3行赋值2次第6行赋值执行n次,加法执行n次所以,总共2n+2次操作,算法复杂度为O(n)1.4y= y + i * j 执行次数:1.5第二章2.9内存中一片连续空间(不妨假设地址从1到m)提供给两个栈S1和S2使用,怎样分配这部分存储空间,使得对任一个栈,仅当这部分空间全满时才发生上溢。

答:S1和S2共享内存中一片连续空间(地址1到m),可以将S1和S2的栈底设在两端,两栈顶向共享空间的中心延伸,仅当两栈顶指针相邻(两栈顶指针值之差的绝对值等于1)时,判断为栈满,当一个栈顶指针为0,另一个栈顶指针m+1时为两栈均空。

2.10线性表是数据项组成的一种有限且有序的序列,各元素之间呈线性关系。

从逻辑结构来说,栈和队列与线性表相同,都是典型的线性结构。

与线性表不同的是,栈和队列的操作特殊,受到一定的限制,仅允许在线性表的一端或两端进行。

栈是限定仅在一端进行插入删除的线性表,无论插入、删除还是读取都在一端进行,按后进先出的原则。

队列的元素只能从一端插入,从另一端删除,按先进先出的原则进行数据的存取。

2.11共有132种合法序列。

235641序列可以。

154623序列不可以。

对于每一个数来说,必须进栈一次、出栈一次。

我们把进栈设为状态‘1’,出栈设为状态‘0’。

n个数的所有状态对应n个1和n个0组成的2n位二进制数。

由于等待入栈的操作数按照1‥n的顺序排列、入栈的操作数b大于等于出栈的操作数a(a≤b),因此输出序列的总数目=由左而右扫描由n个1和n个0组成的2n位二进制数,1的累计数不小于0的累计数的方案种数。

矩阵分析课后习题解答(整理版)

矩阵分析课后习题解答(整理版)

第一章 线性空间与线性变换(以下题目序号与课后习题序号不一定对应,但题目顺序是一致的,答案为个人整理,不一定正确,仅供参考,另外,此答案未经允许不得擅自上传)(此处注意线性变换的核空间与矩阵核空间的区别)1.9.利用子空间定义,)(A R 是m C 的非空子集,即验证)(A R 对m C 满足加法和数乘的封闭性。

1.10.证明同1.9。

1.11.rankA n A N rankA A R -==)(dim ,)(dim (解空间的维数)1.13.提示:设),)(-⨯==n j i a A nn ij (,分别令Ti X X ),0,0,1,0,0( ==(其中1位于i X 的第i 行),代入0=AX X T ,得0=ii a ;令T ij X X )0,0,10,0,1,0,0( ==(其中1位于ij X 的第i 行和第j 行),代入0=AX X T ,得0=+++jj ji ij ii a a a a ,由于0==jj ii a a ,则0=+ji ij a a ,故A A T -=,即A 为反对称阵。

若X 是n 维复列向量,同样有0=ii a ,0=+ji ij a a ,再令T ij i X X ),0,1,0,0,,0,0( ='=(其中i 位于ij X 的第i 行,1位于ij X 的第j 行),代入0=AX X H ,得0)(=-++ij ji jj ii a a i a a ,由于0==jj ii a a ,ij ji a a -=,则0==ji ij a a ,故0=A1.14.AB 是Hermite 矩阵,则AB BA A B AB H H H ===)(1.15.存在性:令2,2HH A A C A A B -=+=,C B A +=,其中A 为任意复矩阵,可验证C C B B H H -==,唯一性:假设11C B A +=,1111,C C B B H H -==,且C C B B ≠≠11,,由1111C B C B A HH H -=+=,得C A A C B A A B HH =-==+=2,211(矛盾) 第二章 酉空间和酉变换(注意实空间与复空间部分性质的区别)2.8 法二:设~2121),,()0,0,1,0,0)(,,(X e e e e e e e n Tn i ==(1在第i 行);~2121),,()0,0,1,0,0)(,,(Y e e e e e e e n Tn j ==(1在第j 行)根据此题内积定义⎩⎨⎧≠===j i ji X Y e e H j i 01),~~( 故n e e e ,,21是V 的一个标准正交基。

《数据结构》课后习题答案(第2版)

《数据结构》课后习题答案(第2版)

1 填空题(1)数据元素(2)数据项数据元素(3)集合线性结构树结构图结构(4)顺序存储链接存储数据元素数据元素之间的关系(5)零或多个输入一个或多个输出有穷性确定性可行性(6)自然语言程序设计语言流程图伪代码,伪代码(7)问题规模(8)O(1) O(nlog2n)2 选择题(1)C D (2)B (3) B (4) A (5) D (6)A (7) C (8) C E3 判断题×××√×第二章1 填空题(1)表长一半表长位置(2)108(3)p->next=(p->next)->next;(4)运算方便(5)p->next=head;(6)s->next=rear->next rear->next=s; rear=s;q=rear->next->next; rear->next->next=q->next; delete q;(7)O(1) O(n)(8)循环单链表循环双链表双链表2 选择题(1) A B (2) D (3) B (4) A (5) A (6) D(7) B(8) B(9) C(10)B(11)B(12)D(13)A(14)A3 判断题×××××1 填空题(1)1003H(2)顺序栈和链栈top=-1或top==NULL top==数组长度或内存无可用空间(3)栈(4)abc+*d-(5)后进先出先进先出操作位置受限(6)假溢出(7)(rear-front+n)% n(8)O(1) O(n)2 选择题(1) C (2) D (3) C (4) B(5) B(6) B(7) D(8) A(9) C3 判断题×√√××第四章1 填空题(1)数据元素的类型是字符(2)长度相等且对应位置字符相等(3)存取修改顺序存储(4)1140(5)d+41(6)三元组顺序表十字链表2 选择题(1) B (2) D E K (3) B (4) C(5) D(6) C(7) D3 判断题×√√××1 填空题(1)有且仅有一个互不相交(2)度孩子双亲(3)2i-1(n+1)/2 (n-1)/2 (4)2h-1 2h-1(5)2k-1(6)50(7)12(8)CDBGFEA (9)2n n-1 n+1 (10)n n-12 选择题(1) D (2) D (3) B (4) C (5) B C (6) D(7) A(8) A B(9) D A(10)B(11)B(12)C(13)D(14)C3 判断题×√×√×第六章1 填空题(1)0 n(n-1)/2 0 n(n-1) (2)自身(3)邻接矩阵邻接表(4)O(n+e)(5)第j列所有元素之和(6)出度(7)前序栈层序队列(8)O(n2) O(elog2e) (9)回路(10)v i v j v k2 选择题(1) c (2) A G (3) C (4) B (5) D (6) C F(7) B(8) D(9) A(10)A(11)A(12)C(13)A(14)C C F(15)B3 判断题√√××××√×1 填空题(1)顺序存储和链接存储顺序存储按照关键码有序(2) 1 ,7(3)8,59/15(4) 4(5)62(6)开放定址法拉链法(7)散列查找(8)通过关键码计算记录的存储地址并进行一定的比较2 选择题(1) B (2) D B (3) A D (4) D (5) A(6) C(7) C(8) B(9) D(10)A(11)C(12)D3 判断题×××××第八章1 填空题(1)查找(2)正序n-1 反序n(n-1)/2 (3) 3(4) 3(5)O(nlog2n) O(n)(6)n-1(7)50(8)602 选择题(1) C (2) C (3) C (4) B (5) A (6) A(7) B C B(8) C(9) D(10)A D(11)B(12)D,B,E,A,C(13)C,A,D,B,B,D,F(14)C(15)D3 判断题×√××√。

数据结构课后作业答案

数据结构课后作业答案

1. 画出下图所示的无向图的邻接表。

列出深度优先和广度优先搜索遍历该图所的顶点序列和边的序列。

邻接表:深度优先搜索:顶点序列:1 -2 -3- 4- 5 -6边的序列:(1,2) (2,3) (3,4) (4,5) (5,6)广度优先搜索:顶点序列:1 -2 -3 -6 -5-4边的序列:(1,2) (1,3) (1,6) (1,5) (5,4)2 已知以二维数组表示的图的邻接矩阵如下图所示。

试分别画出自顶点1出发进行遍历所得的深度优先生成树和广度优先生成树。

1 2 3 4 5 6 7 8 9 101 0 0 0 0 0 0 1 0 1 02 0 0 1 0 0 0 1 0 0 03 0 0 0 1 0 0 0 1 0 04 0 0 0 0 1 0 0 0 1 05 0 0 0 0 0 1 0 0 0 16 1 1 0 0 0 0 0 0 0 0 70 0 1 0 0 0 0 0 0 115246 38 1 0 0 1 0 0 0 0 1 09 0 0 0 0 1 0 1 0 0 110 1 0 0 0 0 1 0 0 0 0 解:邻接矩阵所表示的图如下:自顶点1出发进行遍历所得的深度优先生成树:自顶点1出发进行遍历所得的广度优先生成树:3请对下图的无向带权图(1)写出它的邻接矩阵,并按普里母算法求其最小生成树。

(2)写出它的邻接表,并按克鲁斯卡尔算法求其最小生成树。

解:(1) 邻接矩阵:∞ 4 3 ∞ ∞ ∞ ∞ ∞ 4 ∞ 5 5 9 ∞ ∞ ∞ 3 5 ∞ 5 ∞ ∞ ∞ 5 ∞ 5 5 ∞ 7 6 5 4 ∞ 9 ∞ 7 ∞ 3 ∞ ∞ ∞ ∞ ∞ 6 3 ∞ 2 ∞ ∞ ∞ ∞ 5 ∞ 2 ∞ 6 ∞∞54 ∞ ∞ 6 ∞普里母算法求得的最小生成树:759645635 534 ed25cbhfga(2)邻接表:克鲁斯卡尔算法生成最小生成树过程:4 试列出下图中全部可能的拓扑有序序列。

实用数据结构基础(第四版)课后习题

实用数据结构基础(第四版)课后习题

一、判断题(第一章绪论)1.数据元素是数据的最小单元。

答案:错误2.一个数据结构是由一个逻辑结构和这个逻辑结构上的基本运算集构成的整体。

答案:错误3.数据的存储结构是数据元素之间的逻辑关系和逻辑结构在计算机存储器内的映像。

答案:正确4.数据的逻辑结构是描述元素之间的逻辑关系,它是依赖于计算机的。

答案:错误5.用语句频度来表示算法的时间复杂度的最大好处是可以独立于计算机的软硬件,分析算法的时间答案:正确(第二章线性表)6.取顺序存储线性表的第i个元素的时间同i的大小有关。

答案:错误7.线性表链式存储的特点是可以用一组任意的存储单元存储表中的数据元素。

答案:正确8.线性链表的每一个节点都恰好包含一个指针域。

答案:错误9.顺序存储方式的优点的存储密度大,插入和删除效率不如练市存储方式好。

答案:正确10.插入和删除操作是数据结构中最基本的两种操作,所以这两种操作在数组中也经常使用。

答案:错误(第三章栈)11.栈是一种对进栈和出栈作了限制的线性表。

答案:错误12.在C(或C++)语言中设顺序栈的长度为MAXLEN,则top=MAXLEN表示栈满。

答案:错误13.链栈与顺序栈相比,其特点之一是通常不会出现满栈的情况。

答案:正确14.空栈就是所有元素都为0上的栈。

答案:错误15.将十进制数转换为二进制数是栈的典型应用之一。

答案:正确(第四章队列)16.队列式限制在两端进行操作的线性表。

答案:正确17.判断顺序队列为空的标准是头指针和尾指针都指向同一结点。

答案:错误18.在循环链列队中无溢出现像。

答案:错误19.在循环队列中,若尾指针rear大于头指针front,则元素个数为rear-front。

答案:正确20.顺序队列和循环队列关于队满和队空的判断条件是一样的。

答案:错误(第五章串)21.串是n个字母的有限序列。

答案:错误22.串的堆分配存储是一种动态存储结构。

答案:正确23.串的长度是指串中不同字符的个数。

(完整版) 《数据结构》教材课后习题+答案

(完整版) 《数据结构》教材课后习题+答案

第1章绪论习题1.简述下列概念:数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。

2.试举一个数据结构的例子,叙述其逻辑结构和存储结构两方面的含义和相互关系。

3.简述逻辑结构的四种基本关系并画出它们的关系图。

4.存储结构由哪两种基本的存储方法实现?5.选择题(1)在数据结构中,从逻辑上可以把数据结构分成()。

A.动态结构和静态结构B.紧凑结构和非紧凑结构C.线性结构和非线性结构D.内部结构和外部结构(2)与数据元素本身的形式、内容、相对位置、个数无关的是数据的()。

A.存储结构B.存储实现C.逻辑结构D.运算实现(3)通常要求同一逻辑结构中的所有数据元素具有相同的特性,这意味着()。

A.数据具有同一特点B.不仅数据元素所包含的数据项的个数要相同,而且对应数据项的类型要一致C.每个数据元素都一样D.数据元素所包含的数据项的个数要相等(4)以下说法正确的是()。

A.数据元素是数据的最小单位B.数据项是数据的基本单位C.数据结构是带有结构的各数据项的集合D.一些表面上很不相同的数据可以有相同的逻辑结构(5)以下与数据的存储结构无关的术语是()。

A.顺序队列 B. 链表 C. 有序表 D. 链栈(6)以下数据结构中,()是非线性数据结构A.树B.字符串C.队D.栈6.试分析下面各程序段的时间复杂度。

(1)x=90; y=100;while(y>0)if(x>100){x=x-10;y--;}else x++;(2)for (i=0; i<n; i++)for (j=0; j<m; j++)a[i][j]=0;(3)s=0;for i=0; i<n; i++)for(j=0; j<n; j++)s+=B[i][j];sum=s;(4)i=1;while(i<=n)i=i*3;(5)x=0;for(i=1; i<n; i++)for (j=1; j<=n-i; j++)x++;(6)x=n; //n>1y=0;while(x≥(y+1)* (y+1))y++;(1)O(1)(2)O(m*n)(3)O(n2)(4)O(log3n)(5)因为x++共执行了n-1+n-2+……+1= n(n-1)/2,所以执行时间为O(n2)(6)O(n)第2章线性表1.选择题(1)一个向量第一个元素的存储地址是100,每个元素的长度为2,则第5个元素的地址是()。

矩阵分析课后习题答案

矩阵分析课后习题答案

矩阵分析课后习题答案矩阵分析是一门重要的数学学科,广泛应用于各个领域,如物理学、工程学和经济学等。

通过矩阵分析,我们可以更好地理解和解决实际问题。

然而,学习矩阵分析过程中,经常会遇到各种复杂的习题,给学生带来困扰。

在这篇文章中,我将为大家提供一些常见矩阵分析课后习题的答案,希望能够帮助大家更好地掌握这门学科。

1. 矩阵乘法的性质矩阵乘法是矩阵分析中的基础概念,了解其性质对于解决复杂的习题非常重要。

下面是几个常见的矩阵乘法性质的答案:- 乘法结合律:对于三个矩阵A、B和C,满足(A*B)*C = A*(B*C)。

- 乘法分配律:对于三个矩阵A、B和C,满足A*(B+C) = A*B + A*C。

- 乘法单位元:对于任意矩阵A,满足A*I = I*A = A,其中I为单位矩阵。

2. 矩阵的转置和逆矩阵矩阵的转置和逆矩阵是矩阵分析中常见的概念,它们在解决线性方程组和求解特征值等问题中起到重要作用。

以下是一些常见的矩阵转置和逆矩阵的答案:- 矩阵的转置:矩阵A的转置记作A^T,即将A的行变为列,列变为行。

- 逆矩阵的存在性:如果一个n阶矩阵A存在逆矩阵A^-1,那么AA^-1 =A^-1A = I,其中I为单位矩阵。

- 逆矩阵的计算:对于2阶矩阵A = [a b; c d],如果ad-bc≠0,则A的逆矩阵为A^-1 = 1/(ad-bc) * [d -b; -c a]。

3. 矩阵的特征值和特征向量特征值和特征向量是矩阵分析中的重要概念,它们在解决线性方程组和矩阵对角化等问题中起到关键作用。

以下是一些常见的特征值和特征向量的答案:- 特征值和特征向量的定义:对于一个n阶矩阵A,如果存在一个非零向量x和一个标量λ,使得Ax = λx,那么λ称为A的特征值,x称为对应于λ的特征向量。

- 特征值的计算:特征值可以通过解方程|A-λI|=0来计算,其中I为单位矩阵。

- 特征向量的计算:对于给定的特征值λ,可以通过求解(A-λI)x=0来计算对应的特征向量。

数据结构课后题答案(第4章).

数据结构课后题答案(第4章).

数据结构部分课后习题答案第四章4.1广度优先生成树(黑体加粗边:深度拓扑排序序列:v0-v2-v3-v1-v4 4.2广度深度(1(2加边顺序a-b b-e e-d d-f f-c4.3、如图所示为一个有6个顶点{u1,u2,u3,u4,u5,u6}的带权有向图的邻接矩阵。

根据此邻接矩阵画出相应的带权有向图,利用dijkstra 算法求第一个顶点u1到其余各顶点的最短路径,并给出计算过程。

带权有向图:4.4证明在图中边权为负时Dijkstra算法不能正确运行若允许边上带有负权值,有可能出现当与S(已求得最短路径的顶点集,归入S内的结点的最短路径不再变更内某点(记为a以负边相连的点(记为b确定其最短路径时,它的最短路径长度加上这条负边的权值结果小于a原先确定的最短路径长度,而此时a在Dijkstra算法下是无法更新的。

4.5P.198 图中的权值有负值不会影响prim和kruskal的正确性如图:KRUSKAL求解过程:4.6 Dijkstra算法如何应用到无向图?答:Dijkstra算法通常是运用在带非负权值的有向图中,但是无向图其实就是两点之间两条有向边权值相同的特殊的有向图,这样就能将Dijkstra算法运用到无向图中。

4.7用FLOYD算法求出任意两顶点的最短路径(如图A(6所示。

A(0= A(1= A(2=A(3= A(4=A(5= A(6= V1 到 V2、V3、V4、V5、V6 往返路径长度分别为 5,9,5,9,9,最长为 9,总的往返路程为 37 同理 V2 到 V1、V3、V4、V5、V6 分别为 5,8,4,4,13,最长为 13,总和 34 V3 对应分别为 9,8,12,8,9,最长为 12,总和为 46 V4 对应分别为 5,4,12,4,9,最长为 12,总和为 34 V5 对应分别为9,4,8,4,9,最长为 9,总和为 34 V6 对应分别为 9,13,9,9,9,最长为13,总和为 49 题目要求娱乐中心“距其它各结点的最长往返路程最短” ,结点V1, V5 最长往返路径最短都是 9。

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

P-219-29Ttemplate<class T>T** LowerMatrix<T>::operator*(const LowerMatrix<T>& m) const{ if(n!=m.n) throw SizeMismatch();T** w = new T *[n];for(int i=0;i<n;i++){w[i] = new int[n];}int ct=0,cm=0;for(int i=1;i<=n;i++){for(int j=1;j<=n;j++){T sum = t[ct]*m.t[cm];for(int k=j;k<i;k++){ct++;cm++;sum += t[ct]*m.t[cm];}w[i-1][j-1]=sum;if(i<j){w[i-1][j-1] = 0;}ct = i*(i-1)/2+j-1;cm = j;}ct = i*(i+1)/2;cm = 0;}return w;}函数时间复杂性为O(n^3);P-219-30Ttemplate<class T>T** UpperMatrix<T>::operator*(const LowerMatrix<T>& m) const{ int front=0;if(n!=m.n) throw SizeMismatch();T** c = new T *[n];for(int i=0;i<n;i++){c[i] = new int[n];}int ct=0,cm=0;for(int i=0;i<n;i++){for(int j=0;j<n;j++){c[i][j]=0;if(i<=j)front=j;else front=i;for(int k=front;k<n;k++){ct = i*(2*n-i)/2+k-i;cm = k*(k+1)/2+j;c[i][j] += t[ct]*m.t[cm];}}}return c;}函数时间复杂性为O(n^3);P-237-36Ttemplate<class T>SparseMatrix<T>& SparseMatrix<T>::Store(const int& x,int i,int j){ if(i<1 || j<1 || i>rows || j>cols ) throw OutOfBounds();if(terms = = 0){if(x ==0 )return *this;a[0].row = i;a[0].col = j;a[0].value = x;terms++;return *this;}int location = a[0].row*cols + a[0].col;int other = i*cols + j;int k = 0;while(k<terms && other>location){k++;if(k!=terms)location = a[k].row*cols + a[k].col;}if(k == terms){if(terms = = MaxTerms) throw OutOfBounds();a[k].row = i;a[k].col = j;a[k].value = x;terms++;}if(other = = location){a[k].row = i;a[k].col = j;a[k].value = x;}else{if(terms = = MaxTerms) throw OutOfBounds();for(int l=k;l<terms;l++)a[l+1] = a[l];a[k].row = i;a[k].col = j;a[k].value = x;terms++;}return *this;}template<class T>T SparseMatrix<T>::Retrieve(int i,int j) const{if(i<1 || j<1 || i>rows || j>cols) throw OutOfBounds();int location = a[0].row*cols + a[0].col;int other = i*cols + j;int k = 0;while(k<terms && other>location){k++;if(k!=terms)location = a[k].row*cols + a[k].col;}if(other == location)return a[k].value;elsereturn 0;}Store函数和Retrieve 函数的时间复杂性均为O(terms)P-237-43template<class T>SparseMatrix<T>& SparseMatrix<T>::Multiply(SparseMatrix<T>& m,SparseMatrix<T>& n){if(cols!=m.rows) throw SizeMismatch();n.rows = rows;n.cols = m.cols;n.terms = 0;int *RowNext,RowSize;RowSize = new int[m.rows+1];for(int i=1;i<=m.rows;i++){RowSize[i] = 0;}for(int i=0;i<=m.rows;i++)RowSize[m.a[i].row]++;RowNext[1]=0;for(int i=2;i<=m.rows;i++)RowNext[i] = RowNext[i-1] + RowSize[i-1];int **t = new int[rows];for(int i=0;i<rows;i++){t[i] = new int[m.cols];}for(int i=0;i<rows;i++){for(int j=0;j<m.cols;j++){t[i][j] = 0;}}for(int i=0;i<terms;i++){for(int j=RowNext[a[i].col];j<RowNext[a[i].col+1];j++) t[a[i].row][a[j].col] += a[i].value * m.a[j].value;}for(int i=0;i<rows;i++){for(int j=0;j<m.cols;j++){if(t[i][j]){Term<T> b;b.row = i;b.col = j;b.value = t[i][j];Append(b);}}}}P-247-1T(1)template<class T>T Stack<T>::Length()const{return top+1;}(2)template<class T>void Stack<T>::Input(){cout<<"Please Enter the length of the stack "<<endl;int len;cin>>len;if(len<0 || len-1>MaxTop) throw BadInitializers();for(int i=0;i<len;i++){cin>>stack[i];top++;}}(3)template<class T>void Stack<T>::Output() const{for(int i=0;i<=top;i++){cout<<stack[i]<<" ";}cout<<endl;}P-247-2T(1)template<class T>void Stack<T>::Split(Stack<T>& a,Stack<T>& b){if(top/2 > a.MaxTop) throw NoMem();if(top/2-1 > b.MaxTop) throw NoMem();for(int i=0; i<(top+2)/2; i++)a.stack[i] = stack[i];a.top =(top+2)/2-1;for(int i=0; i<top/2; i++)b.stack[i] = stack[(top+2)/2+i];b.top = top/2-1;}(2)template<class T>void Stack<T>::Merge(Stack<T>& a){if(a.top+top+1>MaxTop) throw OutOfBounds();for(int i=0;i<=top;i++)a.stack[a.top+i+1] = stack[i];a.top += top+1;top = -1;}P-290-1T (1)int Length() const{if(IsEmpty()) throw OutOfBounds();return (rear+MaxSize-front)%MaxSize; }P-291-4T#include"except.h"template<class T>class Queue{public:Queue(int MaxQueueSize = 10);~Queue(){delete []queue;}bool IsEmpty() const {return front==rear&&LastOp==0;} bool IsFull() const {return rear==front&&LastOp==1);}int Length() const;T First() const;T Last() const;Queue<T>& Add(const T& x);Queue<T>& Delete(T& x);private:int front;int rear;int LastOp;int MaxSize;T *queue;}template<class T>Queue<T>::Queue(int MaxQueueSize){MaxSize = MaxQueueSize;queue = new T[MaxSize];front = rear = 0;int LastOp = 0;//0为空,1为满}template<class T>int Queue<T>::Length() const{int a = rear+MaxSize-front;if(rear==front){if(lastop==0)return MaxSize;elsereturn 0;}return a % maxsize;}template<class T>T Queue<T>::First() const{if (IsEmpty()) throw OutOfBounds();return queue[front];}template<class T>T Queue<T>::Last() const{if (IsEmpty()) throw OutOfBounds();return queue[rear];}template<class T>Queue<T>& Queue<T>::Add(const T& x){ if(IsFull()) throw NoMem();rear = (rear+1)%MaxSize;queue[rear] = x;LastOp = 1;return *this;}template<class T>bool Queue<T>::Delete(T& x){if(IsEmpty()) throw BadInitializers();front = (front+1) % MaxSize;x = queue[front];LastOp = 0;return true;}P-297-7T#include"except.h"template<class T>class Node{friend LinkedQueue<T>;private:T data;Node<T> *link;};template<class T>class LinkedQueue{public:LinkedQueue(){front = rear =0;}~LinkedQueue(){};bool IsEmpty() const{return ((front)? false:true;) }bool IsFull()const;T First() const;T Last() const;int Length() const;void Input();void Output();LinkedQueue<T>& Add(const T& x);LinkedQueue<T>& Delete(T& x); private:Node<T>*front;Node<T>*rear;};template<class T>LinkedQueue<T>::~LinkedQueue(){ Node<T> *next;while (front){next = front->link;delete front;front = next;}}template<class T>bool LinkedQueue<T>::IsFull() const{ Node<T> *p;try {p = new Node<T>;delete p;return false;}catch (NoMem){return true;}}template<class T>int LinkedQueue<T>::Length() const{ Node<T> *p = front;int i = 0;for(;p;){i++;p = p->link;}return i;}template<class T>void LinkedQueue::Input(){Node<T> *p;int len;cout<<"Please enter the length of the Queue: "<<endl;cin>>len;front = rear = 0;for (int i=0;i<len;i++){p = new Node<T>;cin>>p->data;p->link = 0;if(i)rear->link = p;elsefront = p;rear = p;}}template<class T>void LinkedQueue<T>::Output(){Node<T> *p = front;for(;p;){cout<<p->data<<" ";p = p->link;}cout<<endl;}template<class T>T LinkedQueue<T>::First() const{if (IsEmpty) throw OutOfBounds();return front->data;}template<class T>T LinkedQueue<T>::Last() const{if (IsEmpty) throw OutOfBounds();return rear->data;}template<class T>LinkedQueue<T>& LinkedQueue<T>::Add(const T& x){Node<T> *p = new Node<T>;p->data = x;p->link = 0;if(front) rear->link = p;else front = p;rear = p;return *this;}template<class T>LinkedQueue<T>& LinkedQueue<T>::Delete(T& x){if (IsEmpty) throw OutOfBounds();x = front->data;Node<T> *p = front;front = front->link;delete p;return *this;}P-324-17T可以把堆栈换成队列,但换成队列后效率会降低,时间复杂性增高。

相关文档
最新文档