数据结构课后习题答案清华大学出版社殷人昆
1-1什么是数据? 它与信息是什么关系?
【解答】
什么是信息？广义地讲，信息就是消息。宇宙三要素（物质、能量、信息）之一。它是现实世界各种事物在人们头脑中的反映。此外，人们通过科学仪器能够认识到的也是信息。信息的特征为：可识别、可存储、可变换、可处理、可传递、可再生、可压缩、可利用、可共享。
什么是数据？因为信息的表现形式十分广泛，许多信息在计算机中不方便存储和处理，例如，一个大楼中4部电梯在软件控制下调度和运行的状态、一个商店中商品的在库明细表等，必须将它们转换成数据才能很方便地在计算机中存储、处理、变换。因此，数据(data)是信息的载体，是描述客观事物的数、字符、以及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。在计算机中，信息必须以数据的形式出现。
1-2什么是数据结构? 有关数据结构的讨论涉及哪三个方面?
【解答】
数据结构是指数据以及相互之间的关系。记为：数据结构= { D, R }。其中，D是某一数据对象，R是该对象中所有数据成员之间的关系的有限集合。
有关数据结构的讨论一般涉及以下三方面的内容：
①数据成员以及它们相互之间的逻辑关系，也称为数据的逻辑结构，简称为数据结构；
②数据成员极其关系在计算机存储器内的存储表示，也称为数据的物理结构，简称为存储结构；
③施加于该数据结构上的操作。
数据的逻辑结构是从逻辑关系上描述数据，它与数据的存储不是一码事，是与计算机存储无关的。因此，数据的逻辑结构可以看作是从具体问题中抽象出来的数据模型，是数据的应用视图。数据的存储结构是逻辑数据结构在计算机存储器中的实现（亦称为映像），它是依赖于计算机的，是数据的物理视图。数据的操作是定义于数据逻辑结构上的一组运算，每种数据结构都有一个运算的集合。例如搜索、插入、删除、更新、排序等。
1-3数据的逻辑结构分为线性结构和非线性结构两大类。线性结构包括数组、链表、栈、
队列、优先级队列等; 非线性结构包括树、图等、这两类结构各自的特点是什么？
【解答】
线性结构的特点是：在结构中所有数据成员都处于一个序列中，有且仅有一个开始成员和一个终端成员，并且所有数据成员都最多有一个直接前驱和一个直接后继。例如，一维数组、线性表等就是典型的线性结构
非线性结构的特点是：一个数据成员可能有零个、一个或多个直接前驱和直接后继。例如，树、图或网络等都是典型的非线性结构。
1-4．什么是抽象数据类型？试用C++的类声明定义“复数”的抽象数据类型。要求
(1) 在复数内部用浮点数定义它的实部和虚部。
(2) 实现3个构造函数：缺省的构造函数没有参数；第二个构造函数将双精度浮点数赋给复数的实部，虚部置为0；第三个构造函数将两个双精度浮点数分别赋给复数的实部和虚部。
(3) 定义获取和修改复数的实部和虚部，以及+、-、*、/等运算的成员函数。
(4) 定义重载的流函数来输出一个复数。
【解答】
抽象数据类型通常是指由用户定义，用以表示应用问题的数据模型。抽象数据类型由基本的数据类型构成，并包括一组相关的服务。
//在头文件complex.h中定义的复数类
#ifndef _complex_h_
#define _complex_h_
#include
class comlex {
public:
complex ( ){ Re = Im = 0; }//不带参数的构造函数
complex ( double r ) { Re = r;Im = 0; }//只置实部的构造函数
complex ( double r, double i ) { Re = r;Im = i; }//分别置实部、虚部的构造函数
double getReal ( ) { return Re; }//取复数实部
double getImag ( ) { return Im; }//取复数虚部
void setReal ( double r ) { Re = r; }//修改复数实部
void setImag ( double i ) { Im = i; } //修改复数虚部
complex& operator = ( complex& ob) { Re = ob.Re;Im = ob.Im; }//复数赋值
complex& operator + ( complex& ob );//重载函数：复数四则运算
complex& operator– ( complex& ob );
complex& operator * ( complex& ob );
complex& operator / ( complex& ob );
friend ostream& operator << ( ostream& os, complex& c );//友元函数：重载<<
private:
double Re, Im; //复数的实部与虚部
};
#endif
//复数类complex的相关服务的实现放在C++源文件complex.cpp中
#include
#include
#include“complex.h”
complex& complex :: operator + ( complex & ob ) {
//重载函数：复数加法运算。
complex * result = new complex ( Re + ob.Re, Im + ob.Im );
return *result;
}
complex& complex :: operator– ( complex& ob ) {
//重载函数：复数减法运算
complex * result = new complex ( Re – ob.Re, Im – ob.Im );
return * result;
}
1n ,21)n(n i n
1i ≥+=∑=complex & complex :: operator * ( complex & ob ) { //重载函数：复数乘法运算
complex * result =
new complex ( Re * ob.Re – Im * ob.Im, Im * ob.Re + Re * ob.Im );
return *result ;
}
complex & complex :: operator / ( complex & ) { //重载函数：复数除法运算
double d = ob.Re * ob.Re + ob.Im * ob.Im ;
complex * result = new complex ( ( Re * ob.Re + Im * ob.Im ) / d,
( Im * ob. Re – Re * ob.Im ) / d ); return * result ;
}
friend ostream& operator << ( ostream& os, complex & ob ) { //友元函数：重载<<，将复数ob 输出到输出流对象os 中。 return os << ob.Re << ( ob.Im >= 0.0 ) ? “+” : “-” << fabs ( ob.Im ) << “i”;
}
1-5 用归纳法证明：
(1) (2) 1n ,6
1)
1)(2n n(n i
n
1i 2
≥++=
∑=
(3)
0n 1, x ,1x 1x x 1n n
i i
≥≠--=+=∑ 【证明】略
1-6 什么是算法? 算法的5个特性是什么? 试根据这些特性解释算法与程序的区别。 【解答】 通常，定义算法为“为解决某一特定任务而规定的一个指令序列。”一个算法应当具有以下特性： ① 有输入。一个算法必须有0个或多个输入。它们是算法开始运算前给予算法的量。这些输入取自于特定的对象的集合。它们可以使用输入语句由外部提供，也可以使用赋值语句在算法内给定。 ② 有输出。一个算法应有一个或多个输出，输出的量是算法计算的结果。 ③ 确定性。算法的每一步都应确切地、无歧义地定义。对于每一种情况，需要执行的动作都应严格地、清晰地规定。 ④ 有穷性。一个算法无论在什么情况下都应在执行有穷步后结束。 ⑤ 有效性。算法中每一条运算都必须是足够基本的。就是说，它们原则上都能精确地执行，甚至人们仅用笔和纸做有限次运算就能完成。 算法和程序不同，程序可以不满足上述的特性(4)。例如，一个操作系统在用户未使用前一直处于“等待”的循环中，直到出现新的用户事件为止。这样的系统可以无休止地运行，直到系统停工。 此外，算法是面向功能的，通常用面向过程的方式描述；程序可以用面向对象方式搭建
∑∑∑
====n 1i n 1j 3n
1
k n 16
2)
1)(n n(n 21)n(n 2161)1)(2n n(n 21 i 21i 2121)i(i j 1n
1i n
1i n 1i 2n 1i i 1j n 1i i 1j j 1k ++=++++==+=??? ?
?+==∑∑
∑∑∑∑∑∑========?
?
?
??++=++??? ??++=+??? ??++==++
=+==∑∑==21)n(n 2121)n(n 21)n(n 1j 21)n(n 1i 时， 2i 2
1)
n(n 1j 1i 时 1i n 1j n
1
j ，???
??++=+???? ?
???? ??++==∑=21)n(n 31j 21)n(n 21i 时, 3i n 1j 它的框架。
1-7 设n 为正整数, 分析下列各程序段中加下划线的语句的程序步数。 (1) for (int i = 1; i <= n ; i++) (2) x = 0; y = 0; for (int j = 1; j <= n ; j++) { for (int i = 1; i <= n ; i++) c[i][j] = 0.0; for (int j = 1; j <= i ; j++) for (int k = 1; k <= n ; k++) for (int k = 1; k <= j ; k++) c[i][j] = c[i][j] + a[i][k] * b[k][j]; x = x + y ; } (3) int i = 1, j = 1; (4) int i =1; while (i<=n && j<=n) { do { i = i + 1; j = j + i ; for (int j = 1; j <= n ; j++) } i = i + j ; } while ( i < 100 + n );
【解答】
(1) (2)
(3) i = 1时，i = 2，j = j + i = 1 + 2 = 2 + 1，
i = 2时，i = 3，j = j + i = ( 2 + 1 ) + 3 = 3 + 1 + 2，
i = 3时，i = 4，j = j + i = ( 3 + 1 + 2 ) + 4 = 4 + 1 + 2 + 3，
i = 4时，i = 5，j = j + i = ( 4 + 1 + 2 + 3 ) + 5 = 5 + 1 + 2 + 3 + 4， ……
i = k 时，i = k + 1，j = j + i = ( k + 1 ) + ( 1 + 2 + 3 + 4 + … + k )，
解出满足上述不等式的k 值，即为语句i = i + 1的程序步数。
(4)
一般地，
()()()n
2
3
3k k 21k k 1k n
i 1k j 2k
1
i ≤++=+++∴≤++=∑=Θn
10021)n(n k 1i ,时k i +
? ??++==
求出满足此不等式的k值，即为语句i = i + j的程序步数。
1-8 试编写一个函数计算n!*2n的值，结果存放于数组A[arraySize]的第n个数组元素中，0 ≤n ≤ arraySize。若设计算机中允许的整数的最大值为maxInt，则当n > arraySize或者对于某一个k (0 ≤ k ≤ n)，使得k!*2k > maxInt时，应按出错处理。可有如下三种不同的出错处理方式：
(1) 用cerr<<及exit (1)语句来终止执行并报告错误；
(2) 用返回整数函数值0, 1来实现算法，以区别是正常返回还是错误返回；
(3) 在函数的参数表设置一个引用型的整型变量来区别是正常返回还是某种错误返回。
试讨论这三种方法各自的优缺点，并以你认为是最好的方式实现它。
【解答】
#include "iostream.h"
#define arraySize 100
#define MaxInt 0x7fffffff
int calc ( int T[ ], int n ) {
int i, value = 1;
if ( n != 0 ) {
int edge = MaxInt / n / 2;
for ( i = 1; i < n; i++ ) {
value *= i*2;
if ( value > edge ) return 0;
}
value *= n * 2;
}
T[n] = value;
cout << "A[" << n << "]=" << T[n] << endl;
return 1;
}
void main ( ) {
int A[arraySize];
int i;
for ( i = 0; i < arraySize; i++ )
if ( !calc ( A, i ) ) {
cout << "failed at " << i << " ." << endl;
break;
}
}
1-9 (1) 在下面所给函数的适当地方插入计算count的语句：
void d (ArrayElement x[ ], int n ) {
int i = 1;
do {
x[i] += 2; i +=2;
} while (i <= n );
i = 1;
while ( i <= (n/2) ) {
x[i] += x[i+1];i++;
}
}
(2) 将由(1)所得到的程序化简。使得化简后的程序与化简前的程序具有相同的count值。
(3) 程序执行结束时的count值是多少？
(4) 使用执行频度的方法计算这个程序的程序步数，画出程序步数统计表。
【解答】
(1) 在适当的地方插入计算count语句
void d ( ArrayElement x [ ], int n ) {
int i = 1;
count ++;
do {
x[i] += 2; count ++;
i += 2;count ++;
count ++;//针对while语句
} while ( i <= n );
i = 1;
count ++;
while ( i <= ( n / 2 ) ) {
count ++;//针对while语句
x[i] += x[i+1];
count ++;
i ++;
count ++;
}
count ++; //针对最后一次while语句
}
(2) 将由(1)所得到的程序化简。化简后的程序与原来的程序有相同的count值：
void d ( ArrayElement x [ ], int n ) {
int i = 1;
do {
count += 3;i += 2;
} while ( i <= n );
i = 1;
while ( i <= ( n / 2 ) ) {
count += 3;i ++;
}
count += 3;
}
(3) 程序执行结束后的count值为3n + 3。
当n为偶数时，count = 3 * ( n / 2 ) + 3 * ( n / 2 ) + 3 = 3 * n + 3
当n为奇数时，count = 3 * ( ( n + 1 ) / 2 ) + 3 * ( ( n – 1 ) / 2 ) + 3 = 3 * n + 3
(4) 使用执行频度的方法计算程序的执行步数，画出程序步数统计表：
1-10 设有3个值大小不同的整数a、b和c，试求
(1)其中值最大的整数；
(2)其中值最小的整数；
(3)其中位于中间值的整数。
【解答】
(1) 求3个整数中的最大整数的函数
【方案1】
int max ( int a, int b, int c ) {
int m = a;
if ( b > m ) m = b;
if ( c > m ) m = c;
return m;
}
【方案2】(此程序可修改循环终止变量扩大到n个整数)
int max ( int a, int b, int c ) {
int data[3] = { a, b, c };
int m = 0;//开始时假定data[0]最大
for ( int i = 1; i < 3; i++ ) //与其他整数逐个比较
if ( data[i] > data[m] ) m = i;//m记录新的最大者
return data[m];
}
(2)求3个整数中的最小整数的函数
可将上面求最大整数的函数稍做修改，“>”改为“<”，可得求最小整数函数。
【方案1】
int min ( int a, int b, int c ) {
int m = a;
if ( b < m ) m = b;
if ( c < m ) m = c;
return m;
}
【方案2】(此程序可修改循环终止变量扩大到n个整数)
int max ( int a, int b, int c ) {
int data[3] = { a, b, c };
int m = 0;//开始时假定data[0]最小
for ( int i = 1; i < 3; i++ ) //与其他整数逐个比较
if ( data[i] < data[m] ) m = i;//m记录新的最小者
return data[m];
}
(3)求3个整数中具有中间值的整数
可将上面求最大整数的函数稍做修改，“>”改为“<”，可得求最小整数函数。
【方案1】
int mid ( int a, int b, int c ) {
int m1 = a, m2;
if ( b < m1 ) { m2 = m1;m1 = b; }
else m2 = b;
if ( c < m1 ) { m2 = m1;m1 = c; }
else if ( c < m2 ) { m2 = c; }
return m2;
}
【方案2】(此程序可修改循环终止变量扩大到n个整数寻求次小元素)
int mid ( int a, int b, int c ) {
int data[3] = { a, b, c };
int m1 = 0, m2 = -1; //m1指示最小整数, m2指示次小整数
for ( int i = 1; i < 3; i++ ) //与其他整数逐个比较
if ( data[i] < data[m1] ) { m2 = m1; m1 = i; }//原来最小变为次小, m1指示新的最小
else if ( m2 == -1 || data[i] < data[m2] ) m2 = i;//m2记录新的次小者
return data[m2];
}
第10章索引与散列
10-1 什么是静态索引结构？什么是动态索引结构？它们各有哪些优缺点？
【解答】
静态索引结构指这种索引结构在初始创建，数据装入时就已经定型，而且在整个系统运行期间，树的结构不发生变化，只是数据在更新。动态索引结构是指在整个系统运行期间，树的结构随数据的增删及时调整，以保持最佳的搜索效率。静态索引结构的优点是结构定型，建立方法简单，存取方便；缺点是不利于更新，插入或删除时效率低。动态索引结构的优点是在插入或删除时能够自动调整索引树结构，以保持最佳的搜索效率；缺点是实现算法复杂。
10-2 设有10000个记录对象, 通过分块划分为若干子表并建立索引, 那么为了提高搜索效
率, 每一个子表的大小应设计为多大? 【解答】
每个子表的大小 s = ?n ? = ?10000? = 100 个记录对象。
10-3如果一个磁盘页块大小为1024 (=1K) 字节，存储的每个记录对象需要占用16字节，其中关键码占4字节，其它数据占12字节。所有记录均已按关键码有序地存储在磁盘文件中，每个页块的第1个记录用于存放线性索引。另外在内存中开辟了256K 字节的空间可用于存放线性索引。试问：
(1) 若将线性索引常驻内存，文件中最多可以存放多少个记录？(每个索引项8字节，其中关键码4字节，地址4字节)
(2) 如果使用二级索引，第二级索引占用1024字节（有128个索引项），这时文件中最多可以存放多少个记录？ 【解答】 (1) 因为一个磁盘页块大小为1024字节，每个记录对象需要占用16字节，则每个页块可存放1024 / 16 = 64个记录，除第一个记录存储线性索引外，每个页块可存储63个记录对象。又因为在磁盘文件中所有记录对象按关键码有序存储，所以线性索引可以是稀疏索引，每一个索引项存放一个页块的最大关键码及该页块的地址。若线性索引常驻内存，那么它最多可存放256 * (1024 / 8 ) = 256 * 128 = 32768个索引项，文件中可存放 32768 * 63 = 2064384个记录对象。 (2) 由于第二级索引占用1024个字节，内存中还剩255K 字节用于第一级索引。第一级索引有255 * 128 = 32640个索引项，作为稀疏索引，每个索引项索引一个页块，则索引文件中可存放32640 * 63 = 2056320。
10-4 假设在数据库文件中的每一个记录是由占2个字节
的整型数关键码和一个变长的数据字段组成。数据字段都
是字符串。为了存放右面的那些记录，应如何组织线性索
引？
【解答】
将所有字符串依加入的先后次序存放于一个连续的
存储空间store 中，这个空间也叫做“堆”，它是存放所有
字符串的顺序文件。它有一个指针free ，指示在堆store 中当前可存放数据的开始地址。初始时free 置为0，表示可从文件的0号位置开始存放。线性索引中每个索引项给出记录关键码，字符串在store 中的起始地址和字符串的长度：
10-5 设有一个职工文件：
记录地址
10032
10068
10104
10140
10176
10212
10248
10284
10320
其中，
索结果关键码。(1) 男性职工；(2) 月工资超过800元的职工；(3) 月工资超过平均工资的职工；(4) 职业为实验员和行政秘书的男性职工；(5) 男性教师或者年龄超过25岁且职业为实验员和教师的女性职工。
【解答】
搜索结果：
(1) 男性职工(搜索性别倒排索引)：{034, 073, 081, 092, 123}
(2) 月工资超过800元的职工(搜索月工资倒排索引)：{064, 081}
(3) 月工资超过平均工资的职工(搜索月工资倒排索引) {月平均工资776元}：
{064, 081, 140}
(4) 职业为实验员和行政秘书的男性职工(搜索职务和性别倒排索引)：
{073, 123, 175}&&{034, 073, 081, 092, 123} = {073, 123}
(5) 男性教师(搜索性别与职务倒排索引)：
{034, 073, 081, 092, 123} && { 034, 064, 081, 092, 140, 209} = {034, 081, 092}年龄超过25岁且职业为实验员和教师的女性职工(搜索性别、职务和年龄倒排索引)：{064, 140, 175, 209} && {034, 064, 073, 081, 092, 140, 175, 209} && {034, 064, 073, 081,092, 123, 140, 175} = {064, 140, 175}
10-6 倒排索引中的记录地址可以是记录的实际存放地址，也可以是记录的关键码。试比较这两种方式的优缺点。
【解答】
在倒排索引中的记录地址用记录的实际存放地址，搜索的速度快；但以后在文件中插入或删除记录对象时需要移动文件中的记录对象，从而改变记录的实际存放地址，这将对所有的索引产生影响：修改所有倒排索引的指针，不但工作量大而且容易引入新的错误或遗漏，使得系统不易维护。
记录地址采用记录的关键码，缺点是寻找实际记录对象需要再经过主索引，降低了搜索速度；但以后在文件中插入或删除记录对象时，如果移动文件中的记录对象，导致许多记录对象的实际存放地址发生变化，只需改变主索引中的相应记录地址，其他倒排索引中的指针一律不变，使得系统容易维护，且不易产生新的错误和遗漏。
10-7 m = 2的平衡m路搜索树是A VL树，m = 3的平衡m路搜索树是2-3树。它们的叶结
点必须在同一层吗？m阶B树是平衡m路搜索树，反过来，平衡m路搜索树一定是B树吗？为什么？
【解答】
m = 3的平衡m路搜索树的叶结点不一定在同一层，而m阶B_树的叶结点必须在同一层，所以m阶B_树是平衡m路搜索树，反过来，平衡m路搜索树不一定是B_树。
10-8 下图是一个3阶B树。试分别画出在插入65、15、40、30之后B树的变化。
【解答】
插入65后：
插入15后：
插入40后：
插入30后：
10-9 下图是一个3阶B 树。试分别画出在删除50、40之后B 树的变化。
【解答】
删除50后：
删除40后：
10-10 对于一棵有1999999个关键码的199阶B 树，试估计其最大层数(不包括失败结点)及最小层数(不包括失败结点)。 【解答】 设B 树的阶数m = 199，则?m/2? = 100。若不包括失败结点层，则其最大层数为 ?log ?m/2? ((N+1)/2)? + 1 = ?log 100 1000000? +1 = 4
若使得每一层关键码数达到最大，可使其层数达到最小。第0层最多有(m -1)个关键码，第1层最多有(m -1)2个关键码，?，第h -1层最多有(m -1)h 个关键码。层数为h 的B 树最多有
(m -1) + (m -1)2 + … + (m -1)h -1 = (m -1) ( (m -1)h – 1 ) / (m -2)个关键码。反之，若有n 个关键码，n ≤ (m -1) ( (m -1)h – 1 ) / (m -2)，则 h ≥ log (m -1) (n(m -2)/(m -1)+1)，所以，有1999999个关键码的199阶B 树的最小层数为 ?log (m -1) (n*(m -2)/(m -1)+1)? = ?log 198 (1999999*197 / 198 +1)? = ?log 198 1989899?
10-11 给定一组记录，其关键码为字符。记录的插入顺序为 { C, S, D, T, A, M, P, I, B, W, N, G , U, R, K, E, H, O, L, J }，给出插入这些记录后的4阶B+树。假定叶结点最多可存放3个记录。 【解答】
插入C, S, D 插入T 插入A 插入M
插入P 插入I
插入B, W, N, G 插入U
插入R
插入K
插入H
插入O, L
插入J
10-12 设有一棵B+树，其内部结点最多可存放100个子女，叶结点最多可存储15个记录。对于1, 2, 3, 4, 5层的B+树，最多能存储多少记录，最少能存储多少记录。 【解答】 一层B+树：根据B+树定义，一层B+
树的结点只有一个，它既是根结点又是叶结点，最多可存储m1 = 15个记录，最少可存储 ?m1/2? = 8个记录。
二层B+树：第0层是根结点，它最多有m = 100棵子树，最少有2个结点；第1层是叶结点，它最多有m 个结点，最多可存储m*m1 = 100*15 = 1500个记录，最少有2个结点，最少可存储2* ?m1/2? = 16个记录。
三层B+树：第2层是叶结点。它最多有m 2个结点，最多可存储m 2 * m1 = 150000个记录。最少有2* ?m/2? = 100个结点，最少可存储2* ?m/2? * ?m1/2? = 800个记录。
四层B+树：第3层是叶结点。它最多有m 3个结点，可存储m 3 * m1 = 15000000个记录。最少有2* ?m/2? 2 = 2 * 50
2 = 5000个结点，存储2* ?m/2? 2 * ?m1/2? = 40000个记录。
五层B+树：第4层是叶结点。它最多有m 4个结点，可存储m 4 * m1 = 1500000000个记
录。最少有2* ?m/2? 3 = 2 * 503 = 250000个结点，存储2* ?m/2? 3 * ?m1/2? = 2000000个记录。
10-13设散列表为HT[13], 散列函数为 H (key ) = key %13。用闭散列法解决冲突, 对下列关键码序列 12, 23, 45, 57, 20, 03, 78, 31, 15, 36 造表。 (1) 采用线性探查法寻找下一个空位, 画出相应的散列表, 并计算等概率下搜索成功的平均搜索长度和搜索不成功的平均搜索长度。 (2) 采用双散列法寻找下一个空位, 再散列函数为 RH (key ) = (7*key ) % 10 + 1, 寻找下一个空位的公式为 H i = (H i-1 + RH (key )) % 13, H 1 = H (key )。画出相应的散列表, 并计算等概率下搜索成功的平均搜索长度。 【解答】 使用散列函数 H(key ) = key mod 13，有 H(12) = 12, H(23) = 10, H(45) = 6, H(57) = 5, H(20) = 7, H(03) = 3, H(78) = 0, H(31) = 5, H(15) = 2, H(36) = 10. (1) 利用线性探查法造表：
搜索成功的平均搜索长度为
ASL succ = 110(1 + 1 + 1 + 1 + 1 + 1 + 4 + 1 + 2 + 1) = 1410
搜索不成功的平均搜索长度为
ASL unsuc c = 113(2 + 1 + 3 + 2 + 1 + 5 + 4 + 3 + 2 + 1 + 5 + 4 + 3) = 3613
(2) 利用双散列法造表：
H i = (H i -1 + RH (key)) % 13, H 1 = H (key)
搜索成功的平均搜索长度为
ASL succ = 110(1 + 1 + 1 + 1 + 1 + 1 + 3 + 5 + 1 + 1) = 1610
10-14 设有150个记录要存储到散列表中, 要求利用线性探查法解决冲突, 同时要求找到所需记录的平均比较次数不超过2次。试问散列表需要设计多大？ 设α是散列表的装载因子，则有
)11
1(21ASL succ α
-+=
【解答】
已知要存储的记录数为n = 150，查找成功的平均查找长度为ASL succ ≤ 2，则有ASL succ
=12111+-?? ???
α≤ 2，解得 α ≤23。又有α = n m m =150≤ 23，则 m ≥ 225。
10-15 若设散列表的大小为m，利用散列函数计算出的散列地址为h = hash(x)。
(1) 试证明：如果二次探查的顺序为(h + q2), (h + (q-1)2), …, (h+1), h, (h-1), …, (h-q2)，其中，q = (m-1)/2。因此在相继被探查的两个桶之间地址相减所得的差取模(%m)的结果为m-2, m-4, m-6, …, 5, 3, 1, 1, 3, 5, …, m-6, m-4, m-2
(2) 编写一个算法，使用课文中讨论的散列函数h(x)和二次探查解决冲突的方法，按给定值x来搜索一个大小为m的散列表。如果x不在表中，则将它插入到表中。
【解答】
(1)将探查序列分两部分讨论：
(h + q2), (h + (q-1)2), …, (h+1), h 和(h-1), (h-22), …, (h-q2)。
对于前一部分，设其通项为h + ( q – d )2, d = 0, 1, …, q，则相邻两个桶之间地址相减所得的差取模：
( h + (q – (d -1) )2 – ( h + (q – d )2 ) ) % m = ( (q – (d -1 ) )2 – (q – d )2 ) % m
= (2*q -2*d +1) % m = ( m – 2*d ) % m. ( 代换q = (m-1)/2 )
代入d = 1, 2, …, q，则可得到探查序列如下：
m-2, m-4, m-6, …, 5, 3, 1。( m – 2*q = m – 2* (m-1)/2 = 1 )
对于后一部分，其通项为h – ( q – d )2, d = q, q+1, …, 2q，则相邻两个桶之间地址相减所得的差取模：
( h – ( q – d )2– ( h – ( q – (d+1) )2 ) ) % m = ( ( q – (d+1)2– (q – d )2 ) % m
= ( 2*d – 2*q +1) % m = ( 2*d – m + 2) % m ( 代换q = (m-1)/2 )
代入d = q, q+1, …, 2q-1，则可得到
2*d–m+2 = 2*q – m +2 = m – 1 – m +2 = 1,
2*d–m+2 = 2*q + 2 – m +2 = m – 1 + 2 – m +2 = 3, ……,
2*d–m+2 = 2*(2*q-1) – m +2 = 2*(m–1–1) – m + 2 = 2*m – 4 – m +2 = m – 2。〖证毕〗
(2) 编写算法
下面是使用二次探查法处理溢出时的散列表类的声明。
template
public:
enum KindOfEntry { Active, Empty, Deleted }; //表项分类(活动/ 空/ 删)
HashTable ( ) : TableSize ( DefaultSize ) { AllocateHt ( ); CurrentSize = 0; } //构造函数
~HashTable ( ) { delete [ ] ht;} //析构函数
const HashTable & operator = ( const HashTable & ht2 ); //重载函数：表赋值
int Find ( const Type & x ); //在散列表中搜索x
int IsEmpty ( ) { return !CurrentSize ? 1 : 0;} //判散列表空否，空则返回1 private:
struct HashEntry { //散列表的表项定义
Type Element; //表项的数据, 即表项的关键码
KindOfEntry info; //三种状态: Active, Empty, Deleted
HashEntry ( ) : info (Empty ) { }//表项构造函数
HashEntry ( const Type &E, KindOfEntry i = Empty ) : Element (E), info (i) { } };
enum { DefualtSize = 31;}
HashEntry *ht;//散列表存储数组
int TableSize; //数组长度，要求是满足4k+3的质数，k是整数int CurrentSize;//已占据散列地址数目
void AllocateHt ( ) { ht = new HashEntry[TableSize ];} //为散列表分配存储空间;
int FindPos ( const Type & x ); //散列函数
};
template
operator = ( const HashTable
//重载函数：复制一个散列表ht2
if ( this != &ht2 ) {
delete [ ] ht; TableSize = ht2.TableSize;AllocateHt ( ); //重新分配目标散列表存储空间for ( int i = 0; i < TableSize; i++ ) ht[i] = ht2.ht[i];//从源散列表向目标散列表传送CurrentSize = ht2.CurrentSize;//传送当前表项个数}
return *this;//返回目标散列表结构指针
}
template
//共有函数：找下一散列位置的函数
int i = 0, q = ( TableSize -1 ) / 2, h0; // i为探查次数
int CurrentPos = h0 = HashPos ( x ); //利用散列函数计算x的散列地址
while ( ht[CurrentPos].info != Empty && ht[CurrentPos].Element != x ) {
/搜索是否要求表项
if ( i <= q ) {//求“下一个”桶
CurrentPos = h0 + (q - i ) * ( q - i );
while ( CurrentPos >= TableSize ) CurrentPos -= TableSize; //实现取模
}
else {
CurrentPos = h0 - ( i -q ) * ( i - q );
while ( CurrentPos < 0 ) CurrentPos += TableSize; //实现取模
}
i++;
}
if ( ht[CurrentPos].info == Active && ht[CurrentPos].Element == x )
return CurrentPos;//返回桶号
else {
ht[CurrentPos].info = Active; ht[CurrentPos].Element = x;//插入x
if ( ++CurrentSize < TableSize / 2 ) return CurrentPos;
//当前已有项数加1, 不超过表长的一半返回HashEntry *Oldht = ht; //分裂空间处理:保存原来的散列表
int OldTableSize = TableSize;
CurrentSize = 0;
TableSize = NextPrime ( 2 * OldTableSize ); //原表大小的2倍，取质数
Allocateht ( ); //建立新的二倍大小的空表
for ( i = 0; i < OldTableSize; i++) //原来的元素重新散列到新表中
if ( Oldht[i].info == Active ) {
Find ( Oldht[i].Element );//递归调用
if ( Oldht[i].Element == x ) CurrentPos = i;
}
delete [ ] Oldht;
return CurrentPos;
}
}
求下一个大于参数表中所给正整数N的质数的算法。
int NextPrime ( int N ) { //求下一个>N的质数，设N >= 5
if ( N % 2 == 0 ) N++; //偶数不是质数
for ( ; !IsPrime (N); N += 2 ); //寻找质数
return N;
}
int IsPrime ( int N ) {//测试N是否质数
for ( int i = 3; i*i <= N; i += 2 ) //若N能分解为两个整数的乘积, 其中一个一定 N if ( N % i == 0 ) return 0;//N能整除i, N不是质数
return 1;//N是质数
}
10-16 编写一个算法，以字典顺序输出散列表中的所有标识符。设散列函数为hash(x) = x 中的第一个字符，采用线性探查法来解决冲突。试估计该算法所需的时间。
【解答】
用线性探查法处理溢出时散列表的类的声明。
#define DefaultSize 1000
#include
#include
#include
class HashTable { //散列表类定义
public:
enum KindOfEntry { Active, Empty, Deleted }; //表项分类(活动/ 空/ 删)
HashTable ( ) : TableSize ( DefaultSize ) { ht = new HashEntry[TableSize];} //构造函数
~HashTable ( ) { delete [ ] ht;} //析构函数
int Find-Ins ( const char * id ); //在散列表中搜索标识符id
void HashSort ( );
private:
struct HashEntry {//表项定义
Type Element; //表项的数据, 即表项的关键码
KindOfEntry info; //三种状态: Active, Empty, Deleted HashEntry ( ) : info (Empty ) { } //表项构造函数, 置空};
HashEntry *ht; //散列表存储数组
int TableSize; //最大桶数
int FindPos ( string s) const { return atoi (*s) - 32; } //散列函数
}
int HashTable :: Find-Ins ( const char * id ) {
int i = FindPos ( id ),j = i;//i是计算出来的散列地址
while ( ht[j].info != Empty && strcmp ( ht[j].Element, id ) != 0 ) { //冲突j = ( j + 1 ) % TableSize; //当做循环表处理, 找下一个空桶if ( j == i ) return-TableSize; //转一圈回到开始点, 表已满, 失败}
if ( ht[j].info != Active ) { //插入
if ( j > i ) {
while ( int k = j; k > i; k-- )
{ ht[k].Element = ht[k-1].Element; ht[k].info = ht[k-1].info; }
ht[i].Element = id;ht[i].info = Active;//插入
} else {
HashEntry temp;
temp.Element = ht[TableSize-1].Element;https://www.360docs.net/doc/122077757.html, = ht[TableSize-1].info;
while ( int k = TableSize-1; k > i; k-- )
{ ht[k].Element = ht[k-1].Element; ht[k].info = ht[k-1].info; }
ht[i].Element = id;ht[i].info = Active;//插入
while ( int k = j; k > 0; k-- )
{ ht[k].Element = ht[k-1].Element; ht[k].info = ht[k-1].info; }
ht[0].Element = temp.Element;ht[0].info = https://www.360docs.net/doc/122077757.html,;
}
return j;
}
void HashTable :: HashSort ( ) {
int n, i; char * str;
cin >> n >> str;
for ( i = 0; i < n; i++ ) {
if ( Find-Ins ( str ) == - Tablesize ) { cout << "表已满" << endl; break; }
cin >> str;
}
for ( i = 0; i < TableSize; i++ )
if ( ht[i].info == Active ) cout << ht[i].Element << endl;
}
10-17 设有1000个值在1到10000的整数，试设计一个利用散列方法的算法，以最少的数据比较次数和移动次数对它们进行排序。
【解答1】
建立TableSize = 10000的散列表，散列函数定义为
int HashTable :: FindPos ( const int x ) { return x-1; }
相应排序算法基于散列表类
#define DefaultSize 10000
#define n 1000
class HashTable {//散列表类的定义
public:
enum KindOfEntry { Active, Empty, Deleted }; //表项分类(活动/ 空/ 删)
HashTable ( ) : TableSize ( DefaultSize ) { ht = new HashEntry[TableSize ];} //构造函数
~HashTable ( ) { delete [ ] ht;} //析构函数
void HashSort ( int A[ ], int n ); //散列法排序
private:
struct HashEntry { //散列表的表项定义
int Element; //表项的数据, 整数
KindOfEntry info; //三种状态: Active, Empty, Deleted
HashEntry ( ) : info (Empty ) { }//表项构造函数
};
HashEntry *ht;//散列表存储数组
int TableSize; //数组长度
int FindPos ( int x ); //散列函数
};
void HashTable
for ( int i = 0; i < n; i++ ) {
int position = FindPos( A[i] );
ht[position].info = Active; ht[position].Element = A[i];
}
int pos = 0;
for ( int i = 0; i < TableSize; i++ )
if ( ht[i].info == Active )
{cout << ht[i].Element << endl; A[pos] = ht[i].Element; pos++; }
}
【解答2】
利用开散列的方法进行排序。其散列表类及散列表链结点类的定义如下：
#define DefaultSize 3334
#define n 1000
class HashTable;//散列表类的前视声明
class ListNode { //各桶中同义词子表的链结点(表项)定义
friend class HashTable;
《数据结构》课后习题答案
第1章绪论 1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。 答案： 数据：是客观事物的符号表示，指所有能输入到计算机中并被计算机程序处理的符号的总称。如数学计算中用到的整数和实数，文本编辑所用到的字符串，多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。 数据元素：是数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。在有些情况下，数据元素也称为元素、结点、记录等。数据元素用于完整地描述一个对象，如一个学生记录，树中棋盘的一个格局（状态）、图中的一个顶点等。 数据项：是组成数据元素的、有独立含义的、不可分割的最小单位。例如，学生基本信息表中的学号、姓名、性别等都是数据项。 数据对象：是性质相同的数据元素的集合，是数据的一个子集。例如：整数数据对象是集合N={0，±1，±2，…}，字母字符数据对象是集合C={‘A’，‘B’，…，‘Z’，‘a’，‘b’，…，‘z’}，学生基本信息表也可是一个数据对象。 数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。换句话说，数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。 逻辑结构：从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。因此，数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。 存储结构：数据对象在计算机中的存储表示，也称为物理结构。 抽象数据类型：由用户定义的，表示应用问题的数学模型，以及定义在这个模型上的一组操作的总称。具体包括三部分：数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。 2．试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。 答案： 例如有一张学生基本信息表，包括学生的学号、姓名、性别、籍贯、专业等。每个学生基本信息记录对应一个数据元素，学生记录按顺序号排列，形成了学生基本信息记录的线性序列。对于整个表来说，只有一个开始结点(它的前面无记录)和一个终端结点(它的后面无记录)，其他的结点则各有一个也只有一个直接前趋和直接后继。学生记录之间的这种关系就确定了学生表的逻辑结构，即线性结构。 这些学生记录在计算机中的存储表示就是存储结构。如果用连续的存储单元(如用数组表示)来存放这些记录，则称为顺序存储结构；如果存储单元不连续，而是随机存放各个记录，然后用指针进行链接，则称为链式存储结构。 即相同的逻辑结构，可以对应不同的存储结构。 3．简述逻辑结构的四种基本关系并画出它们的关系图。 答案： （1）集合结构 数据元素之间除了“属于同一集合”的关系外，别无其他关系。例如，确定一名学生是否为班级成员，只需将班级看做一个集合结构。 （2）线性结构 数据元素之间存在一对一的关系。例如，将学生信息数据按照其入学报到的时间先后顺序进行排列，将组成一个线性结构。 （3）树结构
数据结构实用教程第二版答案_徐孝凯
第一章绪习题一 1.有下列几种用二元组表示的数据结构，试画出它们分别对应的图形表示（当出现多个关系时， 对每个关系画出相应的结构图），并指出它们分别属于何种结构。 ⑴ A=(K,R)其中 K={a1,a2,a3...,an} R={} ⑵ B=(K,R)其中 K={a,b,c,d,e,f,g,h} R={r} r={
严蔚敏版数据结构课后习题答案-完整版
第1章绪论 1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。 数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 数据对象是性质相同的数据元素的集合，是数据的一个子集。 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 存储结构是数据结构在计算机中的表示。 数据类型是一个值的集合和定义在这个值集上的一组操作的总称。 抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。是对一般数据类型的扩展。 1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。 解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。抽象数据
类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。 1.3 设有数据结构(D,R)，其中 {}4,3,2,1d d d d D =，{}r R =，()()(){}4,3,3,2,2,1d d d d d d r = 试按图论中图的画法惯例画出其逻辑结构图。 解： 1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。 解： ADT Complex{ 数据对象：D={r,i|r,i 为实数} 数据关系：R={
数据结构习题及答案——严蔚敏_课后习题答案 精品
第一章绪论 选择题 1.组成数据的基本单位是（） （A）数据项（B）数据类型（C）数据元素（D）数据变量 2.数据结构是研究数据的（）以及它们之间的相互关系。 （A）理想结构，物理结构（B）理想结构，抽象结构 （C）物理结构，逻辑结构（D）抽象结构，逻辑结构 3.在数据结构中，从逻辑上可以把数据结构分成（） （A）动态结构和静态结构（B）紧凑结构和非紧凑结构 （C）线性结构和非线性结构（D）内部结构和外部结构 4.数据结构是一门研究非数值计算的程序设计问题中计算机的（①）以及它们之间的（②）和运算等的学科。 ①（A）数据元素（B）计算方法（C）逻辑存储（D）数据映像 ②（A）结构（B）关系（C）运算（D）算法 5.算法分析的目的是（）。 （A）找出数据结构的合理性（B）研究算法中的输入和输出的关系 （C）分析算法的效率以求改进（D）分析算法的易懂性和文档性 6.计算机算法指的是（①）,它必须具备输入、输出和（②）等5个特性。 ①（A）计算方法（B）排序方法（C）解决问题的有限运算序列（D）调度方法 ②（A）可执行性、可移植性和可扩充性（B）可行性、确定性和有穷性 （C）确定性、有穷性和稳定性（D）易读性、稳定性和安全性 二、判断题 1.数据的机内表示称为数据的存储结构。（） 2.算法就是程序。（） 3.数据元素是数据的最小单位。（） 4.算法的五个特性为：有穷性、输入、输出、完成性和确定性。（） 5.算法的时间复杂度取决于问题的规模和待处理数据的初态。（） 三、填空题 1.数据逻辑结构包括________、________、_________ 和_________四种类型,其中树形结构和图形结构合称为_____。 2.在线性结构中,第一个结点____前驱结点,其余每个结点有且只有______个前驱结点；最后一个结点______后续结点,其余每个结点有且只有_______个后续结点。 3.在树形结构中,树根结点没有_______结点,其余每个结点有且只有_______个前驱结点；叶子结点没有________结点,其余每个结点的后续结点可以_________。 4.在图形结构中,每个结点的前驱结点数和后续结点数可以_________。 5.线性结构中元素之间存在________关系,树形结构中元素之间存在______关系,图形结构中元素之间存在_______关系。 6.算法的五个重要特性是_______、_______、______、_______、_______。 7.数据结构的三要素是指______、_______和________。 8.链式存储结构与顺序存储结构相比较,主要优点是________________________________。 9.设有一批数据元素,为了最快的存储某元素,数据结构宜用_________结构,为了方便插入一个元素,数据结构宜用____________结构。 四、算法分析题 1.求下列算法段的语句频度及时间复杂度参考答案： 选择题1. C 2.C 3. C 4. A、B 5. C 6.C、B
数据结构(第二版)课后习题答案(王红梅主编)
第 1 章绪论 课后习题讲解 1. 填空 ⑴（）是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 【解答】数据元素 ⑵（）是数据的最小单位，（）是讨论数据结构时涉及的最小数据单位。 【解答】数据项，数据元素 【分析】数据结构指的是数据元素以及数据元素之间的关系。 ⑶从逻辑关系上讲，数据结构主要分为（）、（）、（）和（）。【解答】集合，线性结构，树结构，图结构 ⑷数据的存储结构主要有（）和（）两种基本方法，不论哪种存储结构，都要存储两方面的内容：（） 和（）。 【解答】顺序存储结构，链接存储结构，数据元素，数据元素之间的
关系 ⑸算法具有五个特性，分别是（）、（）、（）、（）、（）。 【解答】有零个或多个输入，有一个或多个输出，有穷性，确定性，可行性 ⑹算法的描述方法通常有（）、（）、（）和（）四种，其中，（）被称为算法语言。 【解答】自然语言，程序设计语言，流程图，伪代码，伪代码 ⑺在一般情况下，一个算法的时间复杂度是（）的函数。 【解答】问题规模 ⑻设待处理问题的规模为n，若一个算法的时间复杂度为一个常数，则表示成数量级的形式为（），若 为n*log25n，则表示成数量级的形式为（）。 【解答】Ο(1)，Ο(nlog2n) 【分析】用大O记号表示算法的时间复杂度，需要将低次幂去掉，将最高次幂的系数去掉。 2. 选择题
⑴顺序存储结构中数据元素之间的逻辑关系是由（）表示的，链接存储结构中的数据元素之间的逻辑关 系是由（）表示的。 A 线性结构 B 非线性结构 C 存储位置 D 指针 【解答】C，D 【分析】顺序存储结构就是用一维数组存储数据结构中的数据元素，其逻辑关系由存储位置（即元素在数 组中的下标）表示；链接存储结构中一个数据元素对应链表中的一个结点，元素之间的逻辑关系由结点中 的指针表示。 ⑵假设有如下遗产继承规则：丈夫和妻子可以相互继承遗产；子女可以继承父亲或母亲的遗产；子女间不 能相互继承。则表示该遗产继承关系的最合适的数据结构应该是（）。 A 树 B 图 C 线性表 D 集合
数据结构课后参考答案
单元练习1 一．判断题（下列各题，正确的请在前面的括号打√；错误的打╳） （√）（1）数据的逻辑结构与数据元素本身的容和形式无关。 （√）（2）一个数据结构是由一个逻辑结构和这个逻辑结构上的一个基本运算集构成的整体。 （ㄨ）（3）数据元素是数据的最小单位。 （ㄨ）（4）数据的逻辑结构和数据的存储结构是相同的。 （ㄨ）（5）程序和算法原则上没有区别，所以在讨论数据结构时可以通用。 （√）（6）从逻辑关系上讲，数据结构主要分为线性结构和非线性结构两类。 （√）（7）数据的存储结构是数据的逻辑结构的存储映像。 （√）（8）数据的物理结构是指数据在计算机实际的存储形式。 （ㄨ）（9）数据的逻辑结构是依赖于计算机的。 （√）（10）算法是对解题方法和步骤的描述。 二．填空题 （1）数据有逻辑结构和存储结构两种结构。 （2）数据逻辑结构除了集合以外，还包括：线性结构、树形结构和图形结构。（3）数据结构按逻辑结构可分为两大类，它们是线性结构和非线性结构。（4）树形结构和图形结构合称为非线性结构。 （5）在树形结构中，除了树根结点以外，其余每个结点只有 1 个前趋结点。（6）在图形结构中，每个结点的前趋结点数和后续结点数可以任意多个。（7）数据的存储结构又叫物理结构。 （8）数据的存储结构形式包括：顺序存储、链式存储、索引存储和散列存储。（9）线性结构中的元素之间存在一对一的关系。 （10）树形结构结构中的元素之间存在一对多的关系， （11）图形结构的元素之间存在多对多的关系。 （12）数据结构主要研究数据的逻辑结构、存储结构和算法（或运算）三个方面的容。 （13）数据结构被定义为(D，R)，其中D是数据的有限集合，R是D上的关系的有限集合。 （14）算法是一个有穷指令的集合。 （15）算法效率的度量可以分为事先估算法和事后统计法。 （16）一个算法的时间复杂性是算法输入规模的函数。 （17）算法的空间复杂度是指该算法所耗费的存储空间，它是该算法求解问题规模n 的函数。 （18）若一个算法中的语句频度之和为T（n）=6n+3nlog2n，则算法的时间复杂度为O （nlog2n）。
数据结构课后习题答案
数据结构习题集答案 第1章绪论 1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。 数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 数据对象是性质相同的数据元素的集合，是数据的一个子集。 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。存储结构是数据结构在计算机中的表示。 数据类型是一个值的集合和定义在这个值集上的一组操作的总称。抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。是对一般数据类型的扩展。 1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。 解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。抽象数据
类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。 1.3 设有数据结构(D,R)，其中 {}4,3,2,1d d d d D =，{}r R =，()()(){}4,3,3,2,2,1d d d d d d r = 试按图论中图的画法惯例画出其逻辑结构图。 解： 1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。 解：ADT Complex{ 数据对象：D={r,i|r,i 为实数} 数据关系：R={
(完整word版)数据结构课后习题及答案
填空题(10 * 1 '= 10') 一、概念题 22当对一个线性表经常进行的是插入和删除操作时，采用链式存储结构为宜。 23当对一个线性表经常进行的是存取操作，而很少进行插入和删除操作时，最好采用顺序存储结构。 2.6. 带头结点的单链表L中只有一个元素结点的条件是L->Next->Next==Null。 36循环队列的引入，目的是为了克服假溢出。 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. 在单链表中设置头结点的作用是不管单链表是否为空表，头结点的指针均不空，并使得对单链表的操作 (如插入和删除)在各种情况下统一。 3.1. 队列是限制在表的一端进行插入和在另一端进行删除的线性表，其运算遵循先进先出原则。 3.2 .栈是限定尽在表位进行插入或删除操作的线性表。 3.5. 在链式队列中，判定只有一个结点的条件是(Q->rear==Q->fro nt)&&(Q->rear!=NULL) 。 3.7. 已知链队列的头尾指针分别是f和r，则将x入队的操作序列是node *p=(node *)malloc(node); p->next=x;] p_>next=NULL; if(r) {r->next=p; r=p;} else {r=p; f=p;}。 3.8. 循环队列的满与空的条件是(rear+1)%MAXSIZE==fornt 和(fron t=-1 &&rear+ ^=MAXSIZE) 。 4.3. 串是一种特殊的线性表，其特殊性表现在数据元素都是由字符组成。 4.7. 字符串存储密度是串值所占存储位和实际分配位的比值，在字符串的链式存储结构中其结点大小是可变的。 5.3. 所谓稀疏矩阵指的是矩阵中非零元素远远小于元素总数，则称该矩阵为矩阵中非零元素远远小于元素总数，则称该矩阵为稀 疏矩阵。 5.4. —维数组的逻辑结构是线性结构，存储结构是顺序存储结构；对二维或多维数组，分别按行优先和列优先两种?不同的存储 方式。 7.4. 在有向图的邻接矩阵表示中，计算第i个顶点入度的方法是求邻接矩阵中第?i列非10元素的个数。 7.10. AOV网中，结点表示活动，边表示活动之间的优先关系，AOE网中，结点表示事件，边表示活动。 9.1. 按排序过程中依据不同原则对内部排序方法进行分类，主要有选择排序、交换排序、插入排序归并排序等4类。 9.3 .在堆排序、快速排序和归并排序中若只从排序结果的稳定性考虑，则应选择归并排序方法；若只从平均情况下 排序最快考虑，则应选择快速排序方法；若只从最坏情况下排序最快且要节省类存考虑，则应选择堆排序方法。 9.4. 直接插入排序用监视哨的作用是存当前要的插入记录，可又省去查找插入位置时对是否出界的判断。 9.6. 设表中元素的初始状态是按键值递增的，则直接插入排序最省时间，快速排序最费时间。 4.9. 下列程序判断字符串s是否对称，对称则返回1,否则返回0;如？(abba”返回1, ? (”abab”)返回0. Int f (char*s) { Int i=0,j=0;
数据结构课程 课后习题答案
《数据结构简明教程》练习题及参考答案 练习题1 1. 单项选择题 （1）线性结构中数据元素之间是（）关系。 A.一对多 B.多对多 C.多对一 D.一对一 答：D （2）数据结构中与所使用的计算机无关的是数据的（）结构。 A.存储 B.物理 C.逻辑 D.物理和存储 答：C （3）算法分析的目的是（）。 A.找出数据结构的合理性 B.研究算法中的输入和输出的关系 C.分析算法的效率以求改进 D.分析算法的易懂性和文档性 答：C （4）算法分析的两个主要方面是（）。 A.空间复杂性和时间复杂性 B.正确性和简明性 C.可读性和文档性 D.数据复杂性和程序复杂性 答：A （5）计算机算法指的是（）。 A.计算方法 B. 排序方法 C.求解问题的有限运算序列 D.调度方法 答：C （6）计算机算法必须具备输入、输出和（）等5个特性。 A.可行性、可移植性和可扩充性 B.可行性、确定性和有穷性 C.确定性、有穷性和稳定性 D.易读性、稳定性和安全性 答：B 2. 填空题 （1）数据结构包括数据的①、数据的②和数据的③这三个方面的内容。 答：①逻辑结构②存储结构③运算 （2）数据结构按逻辑结构可分为两大类，它们分别是①和②。 答：①线性结构②非线性结构 （3）数据结构被形式地定义为（D,R），其中D是①的有限集合，R是D上的②有限集合。
答：①数据元素 ②关系 （4）在线性结构中，第一个结点 ① 前驱结点，其余每个结点有且只有1个前驱结点；最后一个结点 ② 后继结点，其余每个结点有且只有1个后继结点。 答：①没有 ②没有 （5）在树形结构中，树根结点没有 ① 结点，其余每个结点有且只有 ② 个前驱结点；叶子结点没有 ③ 结点，其余每个结点的后继结点数可以是 ④ 。 答：①前驱 ②1 ③后继 ④任意多个 （6）在图形结构中，每个结点的前驱结点数和后继结点数可以是（ ）。 答：任意多个 （7）数据的存储结构主要有四种，它们分别是 ① 、 ② 、 ③ 和 ④ 存储结构。 答：①顺序 ②链式 ③索引 ④哈希 （8）一个算法的效率可分为 ① 效率和 ② 效率。 答：①时间 ②空间 3. 简答题 （1）数据结构和数据类型两个概念之间有区别吗？ 答：简单地说，数据结构定义了一组按某些关系结合在一起的数组元素的集合。数据类型不仅定义了一组数据元素，而且还在其上定义了一组操作。 （2）简述线性结构、树形结构和图形结构的不同点。 答：线性结构反映结点间的逻辑关系是一对一的，树形线性结构反映结点间的逻辑关系是一对多的，图在结构反映结点间的逻辑关系是多对多的。 （3）设有采用二元组表示的数据逻辑结构S=(D,R)，其中D={a ,b ,…,i }，R={(a ,b ),(a ,c ),(c ,d ),(c ,f ),(f ,h ),(d ,e ),(f ,g ),(h ,i )}，问相对于关系R ，哪些结点是开始结点，哪些结点是终端结点？ 答：该逻辑结构为树形结构，其中a 结点没有前驱结点，称为根结点，b 、e 、g 、i 结点没有后继结点，是终端结点，也称为叶子结点。 （4）以下各函数是算法中语句的执行频度，n 为问题规模，给出对应的时间复杂度： T 1(n )=n log 2n -1000log 2n T 2(n )=3log 2n -1000log 2n T 3(n )=n 2 -1000log 2n T 4(n )=2n log 2n -1000log 2n 答：T 1(n )=O(n log 2n )，T 2(n )=O( )，T 3(n )=O(n 2 )，T 4(n )=O(n log 2n )。 （5）分析下面程序段中循环语句的执行次数。 int j=0,s=0,n=100; do { j=j+1; s=s+10*j; } while (j 习题1 一、单项选择题 A1.数据结构是指（）。 A.数据元素的组织形式 B.数据类型 C.数据存储结构 D.数据定义 C2.数据在计算机存储器内表示时，物理地址与逻辑地址不相同的，称之为（）。 A.存储结构 B.逻辑结构 C.链式存储结构 D.顺序存储结构 D3.树形结构是数据元素之间存在一种（）。 A.一对一关系 B.多对多关系 C.多对一关系 D.一对多关系 B4.设语句x++的时间是单位时间，则以下语句的时间复杂度为（）。 for(i=1; i<=n; i++) for(j=i; j<=n; j++) x++; A.O(1) B.O(2n) C.O(n) D.O(3n) CA5.算法分析的目的是（1），算法分析的两个主要方面是（2）。 （1） A.找出数据结构的合理性 B.研究算法中的输入和输出关系 C.分析算法的效率以求改进 D.分析算法的易懂性和文档性 （2） A.空间复杂度和时间复杂度 B.正确性和简明性 C.可读性和文档性 D.数据复杂性和程序复杂性 6.计算机算法指的是（1），它具备输入，输出和（2）等五个特性。 （1） A.计算方法 B.排序方法 C.解决问题的有限运算序列 D.调度方法 （2） A.可行性，可移植性和可扩充性 B.可行性，确定性和有穷性 C.确定性，有穷性和稳定性 D.易读性，稳定性和安全性 7.数据在计算机内有链式和顺序两种存储方式，在存储空间使用的灵活性上，链式存储比顺序存储要（）。 A.低 B.高 C.相同 D.不好说 8.数据结构作为一门独立的课程出现是在（）年。 A.1946 B.1953 C.1964 D.1968 9.数据结构只是研究数据的逻辑结构和物理结构，这种观点（）。 A.正确 B.错误 C.前半句对，后半句错 D.前半句错，后半句对 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 10 1 0 0 0 0 0 0 1 0 1 0 2 0 0 1 0 0 0 1 0 0 0 3 0 0 0 1 0 0 0 1 0 0 4 0 0 0 0 1 0 0 0 1 0 5 0 0 0 0 0 1 0 0 0 1 6 1 1 0 0 0 0 0 0 0 0 7 0 0 1 0 0 0 0 0 0 1 1 5 2 4 6 3 8 1 0 0 1 0 0 0 0 1 0 9 0 0 0 0 1 0 1 0 0 1 10 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 ∞ ∞ 5 4 ∞ ∞ 6 ∞ 普里母算法求得的最小生成树： 7 5 9 6 4 5 6 3 5 5 3 4 e d 2 5 c b h f g a 填空题（10 * 1’ = 10’） 一、概念题 .当对一个线性表经常进行的是插入和删除操作时，采用链式存储结构为宜。 .当对一个线性表经常进行的是存取操作，而很少进行插入和删除操作时，最好采用顺序存储结构。 .带头结点的单链表L中只有一个元素结点的条件是L->Next->Next==Null。 .循环队列的引入，目的是为了克服假溢出。 .长度为0的字符串称为空串。 .组成串的数据元素只能是字符。 .设T和P是两个给定的串，在T中寻找等于P的子串的过程称为模式匹配，又称P为模式。 .为了实现图的广度优先搜索，除一个标志数组标志已访问的图的结点外，还需要队列存放被访问的结点实现遍历。 .广义表的深度是广义表中括号的重数 .有向图G可拓扑排序的判别条件是有无回路。 .若要求一个稠密图的最小生成树，最好用Prim算法求解。 . 直接定址法法构造的哈希函数肯定不会发生冲突。 .排序算法所花费的时间，通常用在数据的比较和交换两大操作。 .通常从正确性﹑可读性﹑健壮性﹑时空效率等几个方面评价算法的（包括程序）的质量。 .对于给定的n元素，可以构造出的逻辑结构有集合关系﹑线性关系树形关系﹑图状关系四种。 .存储结构主要有顺序存储﹑链式存储﹑索引存储﹑散列存储四种。 .抽象数据类型的定义仅取决于它的一组逻辑特性，而与存储结构无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部使用。 .一个算法具有五大特性：有穷性﹑确定性﹑可行性，有零个或多个输入﹑有一个或多个输入。 .在双向链表结构中，若要求在p指针所指的结点之前插入指针为s所指的结点，则需执行下列语句：s->prior= p->prior; s->next= p; p->prior- next= s; p->prior= s;。 .在单链表中设置头结点的作用是不管单链表是否为空表，头结点的指针均不空，并使得对单链表的操作（如插入和删除）在各种情况下统一。 .队列是限制在表的一端进行插入和在另一端进行删除的线性表，其运算遵循先进先出原则。 .栈是限定尽在表位进行插入或删除操作的线性表。 .在链式队列中，判定只有一个结点的条件是(Q->rear==Q->front)&&(Q->rear!=NULL)。 .已知链队列的头尾指针分别是f和r，则将x入队的操作序列是node *p=(node *)malloc(node); p->next=x; p->next=NULL; if(r) {r->next=p; r=p;} else {r=p; f=p;}。 .循环队列的满与空的条件是(rear+1)%MAXSIZE==fornt和(front=-1&&rear+1==MAXSIZE)。 .串是一种特殊的线性表，其特殊性表现在数据元素都是由字符组成。 .字符串存储密度是串值所占存储位和实际分配位的比值，在字符串的链式存储结构中其结点大小是可变的。 .所谓稀疏矩阵指的是矩阵中非零元素远远小于元素总数，则称该矩阵为矩阵中非零元素远远小于元素总数，则称该矩阵为稀疏矩阵。 .一维数组的逻辑结构是线性结构，存储结构是顺序存储结构；对二维或多维数组，分别按行优先和列优先两种不同的存储方式。 .在有向图的邻接矩阵表示中，计算第i个顶点入度的方法是求邻接矩阵中第i列非0元素的个数。 网中，结点表示活动，边表示活动之间的优先关系，AOE网中，结点表示事件，边表示活动。 .按排序过程中依据不同原则对内部排序方法进行分类，主要有选择排序﹑交换排序﹑插入排序归并排序等4类。 .在堆排序、快速排序和归并排序中若只从排序结果的稳定性考虑，则应选择归并排序方法；若只从平均情况下排序最快考虑，则应选择快速排序方法；若只从最坏情况下排序最快且要节省类存考虑，则应选择堆排序方法。 .直接插入排序用监视哨的作用是存当前要的插入记录，可又省去查找插入位置时对是否出界的判断。 .设表中元素的初始状态是按键值递增的，则直接插入排序最省时间，快速排序最费时间。 .下列程序判断字符串s是否对称，对称则返回1，否则返回0；如?(“abba”)返回1，?（”abab”）返回0. Int f (char*s) { Int i=0,j=0; 求串长*/ 1-1什么是数据? 它与信息是什么关系? 【解答】 什么是信息？广义地讲，信息就是消息。宇宙三要素（物质、能量、信息）之一。它是现实世界各种事物在人们头脑中的反映。此外，人们通过科学仪器能够认识到的也是信息。信息的特征为：可识别、可存储、可变换、可处理、可传递、可再生、可压缩、可利用、可共享。 什么是数据？因为信息的表现形式十分广泛，许多信息在计算机中不方便存储和处理，例如，一个大楼中4部电梯在软件控制下调度和运行的状态、一个商店中商品的在库明细表等，必须将它们转换成数据才能很方便地在计算机中存储、处理、变换。因此，数据(data)是信息的载体，是描述客观事物的数、字符、以及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。在计算机中，信息必须以数据的形式出现。 1-2什么是数据结构? 有关数据结构的讨论涉及哪三个方面? 【解答】 数据结构是指数据以及相互之间的关系。记为：数据结构= { D, R }。其中，D是某一数据对象，R是该对象中所有数据成员之间的关系的有限集合。 有关数据结构的讨论一般涉及以下三方面的内容： ①数据成员以及它们相互之间的逻辑关系，也称为数据的逻辑结构，简称为数据结构； ②数据成员极其关系在计算机存储器内的存储表示，也称为数据的物理结构，简称为存储结构； ③施加于该数据结构上的操作。 数据的逻辑结构是从逻辑关系上描述数据，它与数据的存储不是一码事，是与计算机存储无关的。因此，数据的逻辑结构可以看作是从具体问题中抽象出来的数据模型，是数据的应用视图。数据的存储结构是逻辑数据结构在计算机存储器中的实现（亦称为映像），它是依赖于计算机的，是数据的物理视图。数据的操作是定义于数据逻辑结构上的一组运算，每种数据结构都有一个运算的集合。例如搜索、插入、删除、更新、排序等。 1-3数据的逻辑结构分为线性结构和非线性结构两大类。线性结构包括数组、链表、栈、 队列、优先级队列等; 非线性结构包括树、图等、这两类结构各自的特点是什么？ 【解答】 线性结构的特点是：在结构中所有数据成员都处于一个序列中，有且仅有一个开始成员和一个终端成员，并且所有数据成员都最多有一个直接前驱和一个直接后继。例如，一维数组、线性表等就是典型的线性结构 非线性结构的特点是：一个数据成员可能有零个、一个或多个直接前驱和直接后继。例如，树、图或网络等都是典型的非线性结构。 1-4．什么是抽象数据类型？试用C++的类声明定义“复数”的抽象数据类型。要求 (1) 在复数内部用浮点数定义它的实部和虚部。 (2) 实现3个构造函数：缺省的构造函数没有参数；第二个构造函数将双精度浮点数赋给复数的实部，虚部置为0；第三个构造函数将两个双精度浮点数分别赋给复数的实部和虚部。 (3) 定义获取和修改复数的实部和虚部，以及+、-、*、/等运算的成员函数。 绪论第1章 √(2)×(3)2.(1)×C ）C（3（1）A（2）3. 的语句频度5.计算下列程序中x=x+1for(i=1;i<=n;i++) for(j=1;j<=i;j++) for(k=1;k<=j;k++) x=x+1; 的语句频度为：【解答】x=x+1=n(n+1)(n+2)/6 ）+……+（1+2+……+n）T(n)=1+(1+2)+（1+2+3 并确定算法中每一),p(xx+ax+a+…….+ax的值6.编写算法，求一元多项式p(x)=a n20nn20n1规定算法中不能使用要求时间复杂度尽可能小，语句的执行次数和整个算法的时间复杂度，算法的输入和输出)。n,输出为P(x求幂函数。注意：本题中的输入为a(i=0,1,…n)、x和0in采用下列方法1）通过参数表中的参数显式传递（）通过全局变量隐式传递。讨论两种方法的优缺点，并在算法中以你认为较好的一种实（2 现输入输出。【解答】1）通过参数表中的参数显式传递（优点：当没有调用函数时，不占用存，调用结束后形参被释放，实参维持，函数通用 性强，移置性强。缺点：形参须与实参对应，且返回值数量有限。 ）通过全局变量隐式传递（2 优点：减少实参与形参的个数，从而减少存空间以及传递数据时的时间消耗 缺点：函数通用性降低，移植性差 算法如下：通过全局变量隐式传递参数PolyValue() { int i,n; float x,a[],p; nn=”);printf(“\ scanf(“%f”,&n); nx=”);printf(“\ scanf(“%f”,&x); for(i=0;i 2011年元月湖北大学自学考试模拟题 C++程序设计模拟题一 （课程代码04737） 一、单项选择题(本大题共20小题，每小题1分，共20分) 在每小题列出的四个备选项中只有一个是符合题目要求的，请将其代码填写在题后的括号内。错选、多选或未选均无分。湖北大学自考教育网会以为快的速度为大家更新网站内容和知识要点、每次考前模拟题；湖北大学自考,湖北大学自考专升本招生信息；感谢大家的支持和关注谢谢！ 1. 编写C++程序一般需经过的几个步骤依次是编辑、编译、连接、运行 2. 决定C++语言中函数的返回值类型的是在定义该函数时所指定的数据类型 3. 下面叙述不正确的是（D） A. 派生类一般都用公有派生 B. 对基类成员的访问必须是无二义性的 C. 赋值兼容规则也适用于多重继承的组合 D. 基类的公有成员在派生类中仍然是公有的 4. 所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是. 类 5. 在公有派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的私有成员 6. 对基类和派生类的关系描述中，错误的是（B） A. 派生类是基类的具体化 B. 基类继承了派生类的属性 C. 派生类是基类定义的延续 D. 派生类是基类的特殊化 7. 关于this指针使用说法正确的是保证基类私有成员在子类中可以被访问。 8. 所谓多态性是指不同的对象调用相同名称的函数 9. 一个函数功能不太复杂，但要求被频繁调用，则应把它定义为内联函数 10. 下面函数模板定义中不正确的是A 11. 假设ClassY:publicX，即类Y是类X的派生类，则说明一个Y类的对象时和删除Y类对象时，调用构造函数和析构函数的次序分别为X,Y；Y,X 12. 适宜采用inline定义函数情况是函数代码少、频繁调用 13. 假定一个类的构造函数为A(int aa,int bb) {a=aa--;b=a*bb;},则执行A x(4,5)；语句后，x.a和x.b的值分别为4和20 14. 在类中说明的成员可以使用关键字的是public 15. 下列不能作为类的成员的是（B） A. 自身类对象的指针 B. 自身类对象 C. 自身类对象的引用 D. 另一个类的对象 16. 使用地址作为实参传给形参，下列说法正确的是实参与形参是同一对象 17. 下列程序的输出结果是（） #include 第1章 绪论 1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。 数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 数据对象是性质相同的数据元素的集合，是数据的一个子集。 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 存储结构是数据结构在计算机中的表示。 数据类型是一个值的集合和定义在这个值集上的一组操作的总称。 抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。是对一般数据类型的扩展。 1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。 解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。抽象数据类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。 1.3 设有数据结构(D,R)，其中 {}4,3,2,1d d d d D =，{}r R =，()()(){}4,3,3,2,2,1d d d d d d r = 试按图论中图的画法惯例画出其逻辑结构图。 解： 1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。 解： ADT Complex{ 数据对象：D={r,i|r,i 为实数} 数据关系：R={数据结构习题及参考答案
数据结构课后作业答案
数据结构课后习题及答案
数据结构课后习题答案清华大学出版社殷人昆
最全数据结构课后习题答案耿国华版
数据结构课后答案
数据结构课后习题详解(超完整,超经典)