计算机软件技术基础(第三版)沈被娜 课后习题答案较全

第一章信息与计算机

1.1 什么是信息？信息与数据的区别和联系在何处？

信息定义之一：信息是现实世界中存在的客观实体、现象、关系进行描述的数据。信息定义之二：信息是经过加工后并对实体的行为产生影响的数据。

与数据的区别和联系：数据定义：数据是现实世界客观存在的实体或事物的属性值，即指人们听到的事实和看到的景象。我们把这些数据收集起来，经过处理后，即得到人们需要的信息。信息和数据的关系可以归结为： 1. 信息是有一定含义的数据。 2. 信息是经过加工（处理）后的数据。 3. 信息是对决策有价值的数据。

1.2 信息有哪些基本属性？

信息的基本属性有： 1. 事实性。 2. 等级性。 3. 可压缩性。

4. 可扩散性。

5. 可传输性。

6. 共享性。

7. 增值性和再生性。

8. 转换性。

1.3 计算机的主要特点是什么？

计算机最主要的特点是： 1. 高速自动的操作功能。 2. 具有记忆的能力。 3. 可以进行各种逻辑判断。 4. 精确高速的计算能力。

1.5 完整的计算机系统应该包括哪几部分？

目前最完整的计算机系统学说认为由五部分组成： 1. 人员 2. 数据 3. 设备 4. 程序 5. 规程

1.6 什么是计算机硬件？什么是计算机软件？

硬件：泛指实际存在的物理设备，包括计算机本身及其外围设备。

微型计算机的硬件系统：主机、外存储器、输入设备、输出设备、微机的系统总线。

软件：是指计算机程序、方法、规则的文档以及在计算机上运行它时所必须的数据。计算机软件一般分为系统软件和应用软件。

1.8 软件技术发展的几个阶段各有什么特点？它与硬件的关系如何？

第一阶段：高级语言阶段特点：这一时期，编译技术代表了整个软件技术，软件工作者追求的主要目的是设计和实现在控制结构和数据结构方面表现能力强的高级语言。但在这一时期内，编译系统主要是靠手工编制，自动化程度很低。硬件关系：此时期计算机的硬件要求仅能用机器指令来编制可运行的程序。

第二阶段：结构程序设计阶段特点：在程序的正确性方面，提出了结构化程序设计思想使程序的可靠性提高了。程序设计方法论方面，提出由顶向下法和自底向上法。使程序模块化，使问题的复杂性和人的思维统一起来了。出现了软件生产管理。硬件关系：磁盘问世，操作系统发展，非数值计算应用发展，通信设备完善，网络发展，集成电路发展等使软件复杂性增加产生软件危机，在此背景下发展了软件技术。

第三阶段：自动程序设计阶段特点：向集成化、一体化发展。出现了软件开发环境。程序设计基本方法进一步改进。硬件关系：集成电路迅速发展以及高分辨率终端的出现，为个人计算机发展提供了条件，再加上人工智能、专家系统研究的发展，使程

序设计进入成熟期。

1.9 什么是多媒体计算机？多媒体计算机包含那几项？

什么是多媒体计算机？

1.“媒体”的概念分为两部分，其一是信息存储的实体，其二是

表现信息形式的载体；

2.多媒体计算机是以计算机为核心，可以综合处理数值计算、文

本文件、图形图像、声音视频等多种信息的计算机系统。

3.多媒体是20世纪90年代计算机发展的新领域，它是计算机技

术与图形图像、动画、声音和视频等领域顶尖技术结合的产物，

它将人机交互的信息从单纯的视觉（文字、图形）扩大到两个

以上的媒体信息

B：多媒体的基本要素：

文本，图形，图像，动画，音频，视频，可以看出，它是电脑，电视机，游戏机，录放机，传真机和电话机的综合体

第二章常用数据结构及其运算

2.1 什么是数据结构？它对算法有什么影响？

数据结构是指同一数据对象中各数据元素间存在的关系。

数据结构对算法的影响：算法的实现必须借助程序设计语言中

提供的数据类型及其运算。一个算法的效率往往与数据的表达形式有关，因此数据结构的选择对数据处理的效率起着至关重

要的作用。它是算法和程序设计的基本部分，它对程序的质量影响很大。

2.2何谓算法？它与程序有何区别？

广义地说，为解决一个问题而采取的方法和步骤，就称为“算法”。计算机算法是通过计算机能执行的算法语言来表达的。

和程序的区别：一个程序包括两个方面的内容：

（1）对数据的描述，即数据结构。

（2）对操作的描述，即算法。

所以算法是程序的一个要素。

2.3 何谓频度，时间复杂度，空间复杂度？说明其含义。

频度：在某个算法中某个语句被重复执行的次数就是此语句的频度。时间复杂度：是用来估算一个算法的执行时间的量，以算法中频度最大的语句来度量。空间复杂度：指在算法中所需的辅助空间的单元，而不包括问题的原始数据占用的空间。

2.4试编写一个求多项式Pn =a n x n +a n-1 x n-1+……+a1x+a0的值Pn(x0)的算法，要求用乘法次数最少，并说明算法中主要语句的执行次数及整个算法的时间复杂度。

A=(a0, a1 ……a n)

mul ＝ 1 //

sum=a0

for i=1 to n

mul ＝ mul * x // x

sum = A[i]*mul + sum //求和end(i)

进行了n次

时间复杂度为：2n

2.5计算下列各片段程序中X←X+1执行次数(1)

for i=1 to n

for j=1 to i

for k=1 to j

x←x+1

end(k)

end(j)

end(i)

执行次数：n*n*n

(2)

i←1

while i

x←x+1

i←i+1

end(while)

执行次数：n-1

(3)

for i=1 to n

j←1

for k=j+1 to n

x← x+1

end(k)

end(i)

执行次数：n*（n-1）

2.6 数据的存储结构主要有哪两种?它们之间的本质区别是什么？数据的存储结构：向量和链表。

本质区别：

向量是连续存放的，其存储空间是静态分配的，以存放顺序来表达元素的前后件的关系。

链式存储结果不需要一组连续的存储单元，其数据元素可以分散存放在存储空间中，其元素关系由指针来指向。

2.8已知线性表L(a 1, a 2, … , a n ) 元素按递增有序排列。用向量作为存储结构，试编写算法：删除表中值在c 与d 之间(c<=d)的元素

找到第1个大于等于c

的元素，序号为s 找到第一个大于d 的元素，序号为t L[s] ← L[t]

L[s+1] ← L[t+1]…

L[s+m] ← L[t+m] // s+m = t -1 m = t – s - 1 L[s + i ] ← L[t + i ] // i = 0 to t-s-1

i=1; // i 从1 循环到n

s = -1; // 第1个大于等于c 的元素序号 t = -1; // 第1个大于d 的元素序号 for i = 1 to n step -1

if s ==-1 and L[i]>=c // 找到第1个大于等于c 的元素 s = i

if t == -1 and L[i] >d // 找到第1个大于d 的元素 t = i ; end (i)

if s != -1 and t !=-1 i = s

while i < t and i + t – s <=n L[i] = L [i + t – s ] i++ end(while) else

return(错误 没有找到 元素在c 和d 之间) end(if)

for j=c to n-d+c

L[j]<--L[j+d-c]//把j+d-c 项给j End(j)

N<--n-d+c//所有项数减少 Return

2.9 线性表A，B中的元素为字符串类型，用向量结构存储，试编写算法，判断B是否为A 的子序列（例如A=ENGLISH ，B=LIS ，则B为A的子序列）

A[m] B[n]

A：

B：

i=1 检查A中第1个元素开始的字符串是否与B匹配

i=2 检查A中第2个元素开始的字符串是否与B匹配

……

i= m – n + 1 检查A中第(m-n+1)个元素开始的字符串是否与B匹配

A[m]

B[n]

if ( m

for ( i =1; i<= m-n+1; i++)

for (j = 1; j<= n ; j++)

if (A[i+j-1 ] != B[j ])

break;

end(j)

if j>n then return( A字符串中第i个字符开始的子串与B匹配)

end(i)

renturn (找不到匹配的子串)

设A，B两个线性表的元素个数为m，n

If (m<=n)then{return}

For i=0 to n-1

a=A[i]

for j=0 to m-1

if(a=B[j])then{b++}

end(j)

end(i)

if(b=m)then{B 为A的子集}

return

2.11写一个将向量L（a1，a2，a n）倒置的算法。

a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13a14 a15

对L(a1，a2, ... ..., a n )

如果是奇数个元素，则

1, 15 交换1, n 交换

2，14 交换2, n-1 交换

3，13 交换3，n-2 交换

4，12 交换4，n-3 交换

5，11 交换5，n-4 交换

6，10 交换6，n-5 交换

7，9 交换7，n-6 交换

8，8 交换8，n-7 交换

9，7 交换9，n-8 交换？停止！！！

a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13a14 a15

如果是偶数个元素，则

1，14 交换1, n 交换

2，13 交换2, n-1 交换

3，12 交换3，n-2 交换

4，11 交换4，n-3 交换

5，10 交换5，n-4 交换

6，9 交换6，n-5 交换

7，8 交换7，n-6 交换

8，7 交换？8，n-7 交换？停止！！！！

小结：n个元素倒置的算法是，

i = 1

while ( i

a[i] 与a[n-i+1] 交换

i++

end(while)

2.12试编写算法求已知单链表长度，并考虑表空的情况。

p = head

i = 0

While(p!=nil) //表不为空

P<-- next(p)//移动到下一个元素

i++

End(while)

Return i //返回数据的个数

2.13试编写算法删除单链表中第k个结点。GETNODE(q) GETNODE(p)

q<-head

For i=1 to k-1

q<-next(q)

End(i)

P<-next(q);next(q)<-next(p)

Ret(p)

Return

head

2.14 已知一循环链表中数值已按递增有序排列现要插入一个新结点，并使插入一个新节点，并使插入后链表仍为有序序列

GETNODE(p)

Data(p)=a

While(data(p)

n<-next(n)

End(while)

q <-n

next(p) <--next(q)<-p

return

2.18 设在长度大于1 的循环链表中，即无头结点，也无头指正，p为指向链表中每个节点的指针，试编写算法删除该节点的前趋结点。

q<-Next(p)//找到该节点的前趋结点

p<-next(q);next(q)<-next(p)

RET(p)

Return

2.20试用单链表表示两个多项式；A=4x12+5x8+6x3+4，B=3x12+6x7+2x4+5

(1)设计此两个多项式的数据结构。

(2)写出两个多项式相加的算法。

(3)分析算法的时间、空间复杂度。

ADD-POLY(h a ,h b )

1. p←next(h a); q←next(h b)

2. p re←h a;h c←h a

//p re指向p的前趋，为c(x)头指针//

3.while (p<>nil) AND (q<>nil) do

4.case

5.EXP(p)

6.{p re←p;p←next(p)}

7.EXP(p)=EXP(q):

8.{x←COEF(p)+COEF(q);

9.if (x<>0) then {COEF(p)←x;p re←p}

10.else {next(p re)←next(p); RET(p)}

11.p←next(p re);u←q;q←next(q);RET(u)}

12.EXP(p)>EXP(q):

13.{u←next(q);next(q)←p;

next(p re)←q;p re←q;q←u}

14.end(case)

15.end(while)

16.if(q<>nil) then next(p re)←q

17.RET(h b)//释放多项式B(x)的头结点//

18.return

2.22 CQ[0:10]为一循环队列，初态front=rear=1，画出下列操作后队的头，尾指示器状态：

(1)d,e,b,g,h入队；rear=6 front=1

(2)d，e出队rear=6 front=3

(3)I,j,k,l,m入队rear=0 front=3

(4)b出队rear=0 front=4

(5)n,o,p,q,r入队rear=5 front=4

2.22 CQ[0：10]为一循环队列，初态front=rear=1，画出下列操作后队的头、尾指示器状态：

(1)d,e,b,g,h入队；(2) d,e出队；(3) i,j,k,l,m,入队；(4) b出队；

(5)n,o,p,q,r入队。

2.23试画出表达式A*(B-D)/C**(E*F)执行过程中NS，OS栈的变化情况。

2.24用一长度为m的数组存放一双向栈，两个栈顶分别为top1和top2,如图所示。上溢条件为top1=top2,从键盘输入一串整数，奇数入stack1，偶数如stack2，直到上溢时停止输入。试编写一算法实现此过程。

O_E(R,m,top1,top2,x)

1. top1←m;top2←1 //top1,top2置初值

2. if (top1=top2) then {‘上溢’,return}

3. while (top1<>top2) do

4. if (x mod 2=0) then

{R[top2]←x;top2←top2+1}

5. else

{ R[top1]←x;top1←top1+1}

6.end(while)

7.retun

2.25 有一个二维数组A[1:m ;1:n],假设A[3,2]地址为1110，A[2，3]地址为1115，

若每个单元占一个空间，问A[1,4]的地址是多少

答案：1120

2.26用三元组和带行辅助向量形式表示下列的稀疏矩阵：

答案：

2.29 设一颗完全二叉数有1000个结点，试问：

(1)有多少个叶子结点500

(2)有多少个度为2的结点499

(3) 有多少个结点只有非空左子树1

2.30 设一颗二叉树其中序和后序遍历为

中序：BDCEAFHG

后序：DECBHGFA

答案：ABCDEFHG

2．31.对二叉树写出如下算法：

(1)复制一棵二叉树；

(2)判断两棵二叉树是否相等；

(3)计算二叉树的树叶；

(4)计算二叉树的深度；

解：

1）//复制一棵二叉树

/*算法思想

采用递规函数来实现

（1）如果树为空，则复制一棵空树；

（2）如果树不为空，则依次递规复制已知二叉树的左子树和有子树；

（3）生成一个新的根结点，使复制得到的左子树和右子树的根指针分别成为这个新生成结点的左指针域和右指针域的值。

算法编写：

*/

BiTree *CopyTree(BiTree *T){

//

if(!T) return NULL;

if(T->lchild)

newlchild=CopyTree(T->lchild);//

else newlchild=NULL;//

if(T->rchild)

newrchild=CopyTree(T->rchild);//

else newrchild=NULL;//

newnode=GetTreeNode(T->data,newlchild,newrchild); //

return newnode;

}//CopyTree

BiTNode *GetTreeNode(TelemType item,BiTNode *lptr,BiTNode *rptr){

//

T=new BiTNode;

T->data=item;T->lchild=lptr;T->rchild=rptr;

return T;

}//GetTreeNode

(2)

在这里要对一种情况进行说明

当root1的左子树与root2的左子树相同，root1的右子树与root2的右子树相同时，这两颗二叉树相同。

当root1的左子树与root2的右子树相同，root1的右子树与root2的左子树相同时，这两颗二叉树同样相同。

以下是实现代码

bool IsBSTEqual(BNode* root1,BNode* root2)

{

if (root1==NULL && root2==NULL)

{

return true;

}

else if (root1==NULL || root2==NULL)

{

return false;

}

else

{

if (root1->data != root2->data)

{

return false;

}

bool is_left = IsBSTEqual(root1->left,root2->left);

bool is_right = IsBSTEqual(root1->right,root2->right);

if (is_left&&is_right)

return true;

else

{

is_right = IsBSTEqual(root1->right,root2->left);

is_left = IsBSTEqual(root1->left,root2->right);

if (is_left&&is_right)

return true;

else

return false;

}

}

}

3）4）

计算叶子数和树的深度。计算叶子：递归每个节点，当没有左孩子和右孩子时即为叶子。计算深度：对每个节点计算左右子树的深度，节点的最终深度是其子树深度的最大值加1，空树返回-1.

struct Tree

{

ElementType Element;

Tree *left;

Tree *right;

};

int CountLeaf(Tree *T)

{

static int count = 0;

if (T != NULL)

{

CountLeaf(T->left);

CountLeaf(T->right);

if (T->left == NULL && T->right == NULL)

count++;

}

return count;

}

int Depth(Tree *T)

{

int depthLeft, depthRight, depth;

if (T == NULL)

return -1;

else

{

depthLeft = Depth(T->left);

depthRight = Depth(T->right);

depth = 1 + (depthLeft > depthRight ? depthLeft:depthRight);

}

return depth;

}

2.32.给定一组元素{17,28,36,54,30,27,94,15,21,83,40},画出由此生成的二叉排序树。解：

2.33．给定一组权值W={8,2,5,3,2,17,4},画出由此生成的哈夫曼树。

2.34.有一图如题图2.4所示：

（1）写出此图的邻接表与邻接矩阵；

（2）由给点V1作深度优先搜索和广度优先搜索；

（3）试说明上述搜索的用途。

解：（1）

（2）

V1作深度优先搜索: