【篇一：数据结构试题库答案】
class=txt>一个算法应该是（）。 a) 程序 b) 问题求解步骤的描述d) a和c c) 要满足五个基本属性(2)
算法指的是（）。 a) 计算机程序 c) 排序算法(3)
b) 解决问题的计算方法 d) 解决问题的有限运算序列。
与数据元素本身的形式、内容、相对位置、个数无关的是数据的（）。 a) 存储结构 b) 逻辑结构 c) 算法 d)操作
(4) 从逻辑上可以把数据结构分为（ ）两大类。 a) 动态结构、静态结构 c) 线性结构、非线性结构
b) 顺序结构、链式结构d) 初等结构、构造型结构 (5) 下列叙述中正确的是( )。
a）一个逻辑数据结构只能有一种存储结构
b）数据的逻辑结构属于线性结构，存储结构属于非线性结构
c）一个逻辑数据结构可以有多种存储结构，且各种存储结构不影响数据处理的效率
d）一个逻辑数据结构可以有多种存储结构，且各种存储结构影响数据处理的效率 (6) (7)
数据的基本单位是（） a) 数据项 b) 数据类型 c) 数据元素 d) 数据变量
下列程序的时间复杂度为（）
i=0；s=0； while（sn） { i++；s=s+i；} a) o（n） b) o（2n） c) o（n） d) o（n2）
(8) 下列程序段的渐进时间复杂度为（ ）。for( int i=1;i=n;i++) for( int j=1;j= m; j++) a[i][j] = i*j ; a）o(m2)
b）o(n2)c）o(m*n) d）(m+n)
(9) 程序段如下：
sum=0； for(i=1;i=n;i++)for(j=1;j=n;j++) sum++；
其中 n为正整数，则最后一行的语句频度在最坏情况下是（ ）。 a）o(n）
b) o(nlogn) c) o(n) 3
d) o(n) 2
(10) 在下面的程序段中，对x的赋值语句的频度为（ ）。 for( j=1;j=n ; j++) x:=x+1; a) o(2n) b)o(n) c) o(n2) d) o(log2n)
(11) 程序段 for( i:=n-1; i=1; i--） for( j:=1;j=i ; j++) if(a[j]a[j+1] ) { t=a[j]; a[j]= a[j+1]; a[j+1]= t; }
其中 n为正整数，则最后一行的语句频度在最坏情况下是（）。 a) o(n）
b) o(nlogn) c) o(n3) d) o(n2)
(12) 设有一个递归算法如下： int fact(int n)
{ /* 大于等于0*/ if ( n=0 ) return 1 ; else return n*fact (n-1) ; }
则计算fact(n)需要调用该函数的次数为（ ）。 a) n b) n+1 c) n+2 d) n-1
(13) 下述程序段中语句①的频度是（）。 s=0;
for(i=1;im;i++)
for(j=0;j=i;j++) s+=j; a)
(m?1)(m?1) 2
m(m?1) 2
(m?2)(m?1) 2
m(m?1) 2
b)c) d)
(14) 若某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则最节
省运算时间的存储方式是（）。 a)单链表 c)双链表
b)仅有头指针的单循环链表 d)仅有尾指针的单循环链表
(1) 求循环链表中当前结点的后继和前驱的时间复杂度分别是（ ）。 a) o(n)和o(1) b) o(1)和o(1) c) o(1)和o(n) d) o(n)和o(n)
(15) 求单链表中当前结点的后继和前驱的时间复杂度分别是（ ）。 a) o（n）和o（1） c) o（1）和o（n） b) o（1）和o（1） d) o(n)和o（n）
(16) 非空的单循环链表的头指针为head,尾指针为rear，则下列条件成立的是（ ）。
a) rear-next= =head c) head-next= =rear
b) rear-next-next= =head d) head-next-next= =rear
(17) 从一个长度为n的顺序表中删除第i个元素（1≤i≤n）时，需向前移动的元素的个数是 （ ）。 a)n-i b)n-i+1 c)n-i-1 d)i
(18) 已知一个有序表为（13，18，24，35，47，50，62，83，90，115，134），当二分检索值为
90的元素时，检索成功需比较的次数是（ ）。 a)1 b)2 c)3 d)4
(19) 假设以行优先顺序存储三维数组r[6][9][6]，其中元素r[0][0][0]的地址为2100，且每个元
素占4个存储单元，则存储地址为2836的元素是（ ）。 a) r[3][3][3]
b) r[3][3][4] c) r[4][3][5] d) r[4][3][4]
(20) 设有一个10阶的对称矩阵a，采用压缩存储方式以行序为主序存储，a00为第一个元素，
其存储地址为0，每个元素占有1个存储地址空间，则a45的地址为（ ）。 a) 13 b) 35 c) 17 d) 36
(21) 线性表采用链式存储时，节点的存储的地址（ ）。 a) 必须是不连续的 c) 必须是连续的 b) 连续与否均可
d) 和头节点的存储地址相连续
(22) 用链表表示线性表的优点是（）。 a) 便于随机存取
b) 花费的存储空间比顺序表少
c) 数据元素的物理顺序与逻辑顺序相同 d) 便于插入与删除 (23) 链表不具有的特点是（） 。
a) 插入、删除不需要移动元素c) 不必事先估计存储空间 b) 可随机访问任一元素 d) 所需空间与线性长度成正比
(24) 在长度为n的顺序表中删除第i个元素(1≤i≤n)时，元素移动的次数为( )。 a) n-i+1 b) i c) i+1 d) n-i
(25) 采用顺序搜索方法查找长度为n的顺序表示，搜索成功的平均搜索长度为（ ）。 a) n b) n/2
c) (n-1)/2 d) (n+1)/2
(26) 将长度为n的单链表链接在长度为m的单链表之后的算法的时间复杂度为（ ）。 a) o(1) b) o(n) c) o(m) d) o(m+n)
(27) 若不带头结点的单链表的头指针为head，则该链表为空的判定条件是( )。
a) head==null b) head-next==null c) head!=nulld) head-next==head
(28) 某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用
（ ）存储方式最节省运算时间。 a) 单链表 c) 双链表
b) 仅有头指针的单循环链表 d) 仅有尾指针的单循环链表
(29) 若允许表达式内多种括号混合嵌套，则为检查表达式中括号是否正确配对的算法，通常选用 的辅助结构是（）。 a) 栈
b) 线性表 c) 队列
d) 二叉排序树
(30) 顺序栈s中top为栈顶指针，指向栈顶元素所在的位置，elem为存放栈的数组，则元素e
进栈操作的主要语句为（）。 a) s.elem［top］=e； s.top=s.top+1；
b) s.elem［top+1］=e；s.top=s.top+1；
c) s.top=s.top+1； s.elem［top+1］=e； d) s.top=s.top+1；s.elem［top］=e；
sq.rear指示队尾元素的当前位置，设当前sq.front为20，sq.rear为12，则当前队列中的元素个数为（）。 a) 8 b) 16 c) 17 d) 18
(32) 链式栈与顺序栈相比，一个比较明显的优点是（ ）。 a) 插入操作更加方便c) 不会出现栈空的情况
b) 通常不会出现栈满的情况 d) 删除操作更加方便
(33) 一个递归的定义可以用递归过程求解，也可以用非递归过程求解，但单从运行时间来看，通
常递归过程比非递归过程（ ）。 a) 较快 b) 较慢 c) 相同 d) 不定
(34) 若已知一个栈的入栈序列是1,2,3,4……n，其输出序列为p1,p2,p3,……pn，若p1= =n,则pi 为（）。 a) i
b) n= =i c) n-i+1 d) 不确定
(35) 一个栈的入栈序列是a,b,c,d,e，则栈的不可能的输出序列是() 。 a) edcba b) decba c) dceab d) abcde
(36) 若进栈序列为1，2，3，4，5，6，且进栈和出栈可以穿插进行，则不可能出现的出栈序列 是()。
a) 2，4，3，1，5，6 c) 4，3，2，1，5，6 b) 3，2，4，1，6，5 d) 2，3，5，1，6，4 (37) 对于栈操作数据的原则是（）。 a) 先进先出 b) 后进先出 c) 后进后出 d) 不分顺序
(38) 栈和队列的共同点是（ ）。
a) 都是先进先出 b) 都是先进后出 c) 只允许在端点处插入和删除元素d) 没有共同点 (39) 一个队列的入队序列是1，2，3，4，则队列的输出序列是（）。 a) 4,3,2,1 b) 1,2,3,4
c)1,4,3,2 d) 3,2,4,1
(40) 设数组data[m]作为循环队列sq的存储空间，front为队头指针，rear为队尾指针，则执行
出对操作后其头指针front值为（ ）。 a) front=front+1 b) front=(front+1)%(m-1) d) front=(front+1)%m c) front=(front-1)%m
(41) 引起循环队列队头位置发生变化的操作是( )。 a) 出队 b) 入队
c) 取队头元素 d) 取队尾元素
(2) 设以数组a[m]存放循环队列的元素，其头尾指针分别为front和rear，则当前队列中的元素 个数为（ ）。
a）(rear-front+m)%m b）rear-front+1
c）(front-rear+m)%m d）(rear-front)%m
(42) 二维数组a[12][18]采用列优先的存储方法，若每个元素各占3个存储单元，且a[0][0]地址
为150，则元素a[9][7]的地址为( )。 a) 429 b) 432 c) 435 d) 438
(43) 设有一个10阶的对称矩阵a[10][10]，采用压缩方式按行将矩阵中下三角部分的元素存入一
维数组b[]中，a[0][0]存入b[0]中，则a[8][5]在b[]中（）位置。 a) 32
b) 33 c) 41 d) 65
(44) 若对n阶对称矩阵a以行序为主序方式将其下三角形的元素(包括主对角线上所有元素)依次
存放于一维数组b［1..(n(n+1))/2］中，则在b中确定aij（ij）的位置k的关系为( )。 a) i*(i-1)/2+j b) j*(j-1)/2+i c) i*(i+1)/2+j d) j*(j+1)/2+i
(45) 对稀疏矩阵进行压缩存储目的是（ ）。 a) 便于进行矩阵运算c) 节省存储空间
b) 便于输入和输出 d) 降低运算的时间复杂度
(46) 对广义表l=((a,b),(c,d),(e,f))执行操作tail(tail(l))的结果是( )。
a) (e,f) b) ((e,f)) c) (f) d) ( )
(47) 设广义表l=（（a,b,c）），则l的长度和深度分别为（ ）。 a) 1和1b) 1和3c) 1和2 (48) 树中所有结点的度之和等于所有结点数加（）。 a) 0 b)1 c) -1
d) 2 d) 2和3
(49) 在一棵具有n个结点的二叉链表中，所有结点的空域个数等于（）。 a) n b) n-1 c) n+1 d) 2*n
(50) 某二叉树的先序序列和后序序列正好相反，则该二叉树一定是（）的二叉树。
【篇二：数据结构习题集答案--清华大学版】
下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。
解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。
数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 数据对象是性质相同的数据元素的集合，是数据的一个子集。 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 存储结构是数据结构在计算机中的表示。
数据类型是一个值的集合和定义在这个值集上的一组操作的总称。 抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。是对一般数据类型的扩展。
试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。
解：抽象数据类型包含一般数据类型的概念，但含义比一般数据类型更广、更抽象。一般数据类型由具体语言系统内部定义，直接提供给编程者定义用户数据，因此称它们为预定义数据类型。抽象数
据类型通常由编程者定义，包括定义它所使用的数据和在这些数据上所进行的操作。在定义抽象数据类型中的数据部分和操作部分时，要求只定义到数据的逻辑结构和操作说明，不考虑数据的存储结构和操作的具体实现，这样抽象层次更高，更能为其他用户提供良好的使用接口。 1.3 设有数据结构(d,r)，其中 d??d1,d2,d3,d4?，r??r?，r?
试按图论中图的画法惯例画出其逻辑结构图。 解：
??d1,d2?,?d2,d3?,?d3,d4??
1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。 解： adt complex{
数据对象：d={r,i|r,i为实数} 数据关系：r={r,i} 基本操作： initcomplex(c,re,im)
操作结果：构造一个复数c，其实部和虚部分别为re和im destroycmoplex(c) 操作结果：销毁复数c get(c,k,e)
操作结果：用e返回复数c的第k元的值 操作结果：改变复数c的第k元的值为e put(c,k,e) isascending(c)
操作结果：如果复数c的两个元素按升序排列，则返回1，否则返回0
isdescending(c)
操作结果：如果复数c的两个元素按降序排列，则返回1，否则返回0 操作结果：用e返回复数c的两个元素中值较大的一个 max(c,e) min(c,e)
操作结果：用e返回复数c的两个元素中值较小的一个 }adt complex
adt rationalnumber{
数据对象：d={s,m|s,m为自然数，且m不为0} 数据关系：r={s,m} 基本操作：
initrationalnumber(r,s,m)
操作结果：构造一个有理数r，其分子和分母分别为s和m destroyrationalnumber(r) 操作结果：销毁有理数r
get(r,k,e)
操作结果：用e返回有理数r的第k元的值 操作结果：改变有理数r的第k元的值为e put(r,k,e) isascending(r)
操作结果：若有理数r的两个元素按升序排列，则返回1，否则返回0 操作结果：若有理数r的两个元素按降序排列，则返回1，否则返回0
isdescending(r) max(r,e)
操作结果：用e返回有理数r的两个元素中值较大的一个 min(r,e)
操作结果：用e返回有理数r的两个元素中值较小的一个 }adt rationalnumber
试画出与下列程序段等价的框图。
(1) product=1; i=1; while(i=n){product *= i;i++; } (2) i=0; do {i++;
} while((i!=n) (a[i]!=x)); (3) switch {
case xy: z=y-x; break;case x=y: z=abs(x*y); break;default: z=(x-y)/abs(x)*abs(y); }
在程序设计中，常用下列三种不同的出错处理方式：
(1) 用exit语句终止执行并报告错误； (2) 以函数的返回值区别正确返回或错误返回；
(3) 设置一个整型变量的函数参数以区别正确返回或某种错误返回。 试讨论这三种方法各自的优缺点。
解：(1)exit常用于异常错误处理，它可以强行中断程序的执行，返回操作系统。 (2)以函数的返回值判断正确与否常用于子程序的测试，便于实现程序的局部控制。 (3)用整型函数进行错误处理的优点是可以给出错误类型，便于迅速确定错误。 1.7 在程序设计中，可采用下列三种方法实现输出和输入：
(1) 通过scanf和printf语句； (2) 通过函数的参数显式传递； (3) 通过全局变量隐式传递。 试讨论这三种方法的优缺点。
解：(1)用scanf和printf直接进行输入输出的好处是形象、直观，但缺点是需要对其进行格式控制，较为烦琐，如果出现错误，则会引起整个系统的崩溃。
(2)通过函数的参数传递进行输入输出，便于实现信息的隐蔽，减少出错的可能。
(3)通过全局变量的隐式传递进行输入输出最为方便，只需修改变量的值即可，但过多的全局变量使程序的维护较为困难。
n为正整数。试确定下列各程序段中前置以记号@的语句的频度： (1) i=1; k=0; while(i=n-1){@ k += 10*i;i++; } (2) i=1; k=0; do {
@ k += 10*i;i++; } while(i=n-1); (3) i=1; k=0; while (i=n-1) {i++; @ k += 10*i; } (4) k=0;
for(i=1; i=n; i++) {for(j=i; j=n; j++) @ k++; }
(5) for(i=1; i=n; i++) {for(j=1; j=i; j++) { for(k=1; k=j; k++) @ x += delta; }
(6) i=1; j=0; while(i+j=n) { @ if(ij) j++; else i++; }
(7) x=n; y=0; // n是不小于1的常数 while(x=(y+1)*(y+1)) {@ y++; }
(8) x=91; y=100; while(y0) {
@ if(x100) { x -= 10; y--; }else x++; } 解：(1) n-1 (2) n-1 (3) n-1 (4) n+(n-1)+(n-2)+...+1= n(n?1) 2 n
(5) 1+(1+2)+(1+2+3)+...+(1+2+3+...+n)= ?
i?1n
i(i?1)21 n = 1 n
i(i?1)??(i?22 i?1 i?1 1 n 2 ?i)? 1 i?2 i?1 2 ? i ?2 i?1
= 112
n(n?1)(2n?1)? 14
n(n?1)? 112
n(n?1)(2n?3) (6) n (7)
n? 向下取整 (8) 1100
1.9 假设n为2的乘幂，并且n2，试求下列算法的时间复杂度及变量count的值（以n的函数形式表示）。 int time(int n) {
} 解：o(logcount=log 2
count = 0; x=2; while(xn/2) { } return count; x *= 2; count++; n) n?2 2
1.11 已知有实现同一功能的两个算法，其时间复杂度分别为o2 ??和o?n?，假设现实计算机可连续 n 10
运算的时间为10秒（100多天），又每秒可执行基本操作（根据这些操作来估算算法时间复杂度）10次。试问在此条件下，这两个算法可解问题的规模（即n值的范围）各为多少？哪个算法更适宜？请说明理由。 解：2 n 75 ?10 10 12 12 n=40
n?10 n=16
则对于同样的循环次数n，在这个规模下，第二种算法所花费的代价要大得多。故在这个规模下，第一种算法更适宜。 设有以下三个函数：f?n??21n 4
?n?1000，g?n??15n?500n，h?n??500n 2 4 3 3.5
?nlogn
请判断以下断言正确与否：
(1) f(n)是o(g(n)) (2) h(n)是o(f(n)) (3) g(n)是o(h(n)) (4) h(n)是o(n) (5) h(n)是o(nlogn)
解：(1)对 (2)错 (3)错 (4)对 (5)错 1.13 试设定若干n值，比较两函数n和50nlog大于50nlog 2 2 3.5 2
n的增长趋势，并确定n在什么范围内，函数n的值 2 2
n的值。
n的值较大。
解：n的增长趋势快。但在n较小的时候，50nlog 当n438时，n 2 2
?50nlog 2 n
1.14 判断下列各对函数f?n?和g?n?，当n??时，哪个函数增长更快？
(1) f?n??10n 2
?lnn!?10 2 ?
n 3
?，g?n??2n 2.5 4
?n?7
(2) f?n???ln?n!??5?，g?n??13n(3) f?n??n(4) f?n??2 2.1 2 ?
n?1，g?n???ln?n!???n 4n ?n? 3
??2? 2
，g?n??n ?n? 2 ?n 5
解：(1)g(n)快 (2)g(n)快 (3)f(n)快 (4) f(n)快 1.15 试用数学归纳法证明： n (1) ?i i?1n 2
?n?n?1??2n?1?/6 ?n?0? (2) ?x i?0 i ?x ? n?1
?1/?x?1? ?
?x?1,n?0?
【篇三：数据结构习题参考答案】
1至8题答案略。
9.（1）【解】该逻辑结构为线性结构，其图形表示如下： （2）【解】该逻辑结构为树型结构，其图形表示如下： （3）【解】该逻辑结构为图型结构，其图形表示如下： （4）【解】该逻辑结构为线性结构，其图形表示如下：
10.【解】该图书库存管理系统所要处理的数据对象为图书，所以该问题中涉及的数据元素为图书，设数据元素类型为booktype类型。每个数据元素应包含的数据项有图书编号、书名、作者、出版社、出版日期等。可用一个表格（如下表）的形式表示图书间的逻辑关系，即该问题数学模型可采用简单的线性结构来表示。 ??
根据问题需求功能目标，此模型的所需的主要处理操作有插入、删除、查找和修改等基本操作。 所以，现用抽象数据类型booklist表示问题模型，其逻辑结构与基本操作的定义如下： （1）逻辑结构 booklist=( d, {r} )
d={bi| bi为booktype类型的元素，i=1,2,3, ....., n，n≥0} r={ bki,bi+1| i=1,2,?, n-1, n≥0 } （2）基本操作 ①初始化 操作函数：initbooklist(bl)。 初始条件：图书表bl不存在。
操作结果：构造一个空的图书表bl。 ②求图书表长度
操作函数：booklistlength(bl)。 初始条件：图书表bl已存在。
操作结果：返回图书表bl中所包含的数据元素（图书）的个数。 ③取图书表中元素
操作函数：getbook(bl, i, b)。
初始条件：图书表bl已存在，且1≤i≤booklistlength(bl)。 操作结果：用b返回图书表bl中的第i个数据元素的值。 ④按编号查找 操作函数：locatebyid(bl, id)。
初始条件：图书表bl已存在，id是给定的一个图书编号。
操作结果：返回图书表bl中图书编号为id的数据元素的位序，若这样的数据元素不存在，则返回0。 ⑤按编号查找
操作函数：locatebyname(bl, i, name)。
初始条件：图书表bl已存在，且1≤i≤booklistlength(bl)，name是给定的一个图书名。
操作结果：从图书表bl中第i个元素开始，查找图书名与给定name相等的第一个元素，若找到则返回其位序，否则返回0。 ⑥插入图书
操作函数：insertbook(bl, i, b)。
初始条件：图书表bl已存在，且1≤i≤booklistlength(bl)+1。
操作结果：在图书表bl的第i个位置上插入一个值为b的新元素，使线性表的长度增1。 ⑦删除操作 操作函数：deletebook(bl, i, b)。
初始条件：线性表l已存在，1≤i≤listlength(l)。
操作结果：删除图书表bl的第i个数据元素，并用b返回其值，使线性表的长度减1。
11. （1）【解】函数体内为简单语句，时间复杂度为t(n)=o(1)
（2）【解】选取的基本语句为“if(a[i]a[k]) k=i;”其执行频度为n-1，时间复杂度为t(n)=o(n)。 （3）【解】选取的基本语句为最内层的循环体语句“total+=a[i][j];”，其执行频度为n(n+1)/2，时间复杂度为t(n)=o(n2)。
（4）【解】选取的基本语句为最内层的循环体语句
“c[i][j]+=a[i][k]*b[k][j];”，其执行频度为n3，时间复杂度为t(n)=o(n3)。
（5）【解】函数有两个并列的循环，其问题规模分别为n和m，对于第一个for循环选取的基本语句为“if(a[i]a[max]) max=i;”，其执行频度为n-1；对于第二个for循环选取的基本语句为
“if(b[i]b[min]) min=i;”，其执行频度为m-1。所以该函数的时间复杂度为t(n,m)=o(n+m)。
（6）【解】选取的基本语句为while的循环体，其执行频度为max{k|
?i?n}，时间复杂度 i?1 k 为 )。
12. 【解】算法（1）中有两个并列的循环，每个循环的循环体语句执行次数均为n，故该函数的语句频度为2n。算法（2）只用了一个循环，其循环体语句执行次数为n，即该函数的语句频度为n。
所以算法（1）与算法（2）相比较，算法（1）的时间效率更好。但它们的时间复杂度都为o（n），这说明：随着n值的增大，这两个
函数执行时间的增长率相同，都是线性增长的。 13. 【解】由题意，设计程序如下： #include stdio.h #include stdlib.h struct stuinfo{ int num;
char name[18]; int score; };
void inputinfo(struct stuinfo stus[], int n){ //输入n个同学信息存于数组stus中 int i; for(i=0;in;i++)
{ printf(输入%d个学生信息：\\n, i+1);
printf(学号：); scanf(%d, stus[i].num); printf(姓名：); scanf(%s, stus[i].name); printf(成绩：); scanf(%d, stus[i].score); } } void sortbyscore(struct stuinfo stus[], int n){
//将数组stus中n个同学信息按成绩进行递减排序 int i,j,k; struct stuinfo temp; for(i=0;in-1;i++) { k=i; for(j=i+1;jn;j++)
if(stus[j].scorestus[k].score) k=j;
if(k!=i) { temp=stus[i]; stus[i]=stus[k];stus[k]=temp; } } }
void outputinfo(struct stuinfo stus[], int n){ //输出数组stus中n个同学信息报表 int i;
printf(%6s %17s %6s\\n, 学号, 姓名, 成绩)； for(i=0;in;i++) printf(%6d %17s %6d\\n, stus[i].num, stus[i].name, stus[i].score); } int main(){ int n;
struct stuinfo *stus;
printf(输入学生数:); scanf(%d, n);
stus=(struct stuinfo*)malloc(n*sizeof(struct stuinfo)); if(!stus) { printf(内存空间溢出！\\n); return -2;} inputinfo(stus, n);
sortbyscore(stus, n); outputinfo(stus, n); system(pause); } 14.【解】由题意，函数设计如下：
status triarea(double a, double b, double c, double area){ double s;
if(a=0||b=0||c=0) return error;
if(a+b=c||a+c=b||b+c=a) return error; s=(a+b+c)/2; area=sqrt(s*(s-a)*(s-b)*(s-c)); return ok; }
15. 【解】由题意，设欲交换的变量为int 类型，则swap函数设计如下： void swap(int a, int b){ int temp; temp=a; a=b; b=t; } 习题2 参考答案
1.属于同一数据对象 2. a 3. 2008 4. c 5. n-i+1、n-i 6. a 7. d
8. （1）s-next=p-next; p-next=s; （2）q=p-next; p-next=q-next; free(p);
（3）q-next=l-next; l-next=q; l-next==null（4）q-next=l; l=q; l==null 9. （1）s-next=p-next；s-pre=p; p-next-pre=s;p-next=s; （2）s-pre=p-pre;s-next=p;p-pre-next=s;p-pre=s; （3）q=p-next;p-next=q-next; q-next-pre=p; free(q); （4）q=ppre; p-pre=q-pre; q-pre-next=p; free(q); （5）p-pre-next =p-next; p-next-pre= p-pre; free(p); （6）s-next=l-next; s-pre=l; l-next-pre =s; l-next=s; 10. 略 11. 【解】算法如下所示：
void union(list la,list lb,list lc){
int i=1,j=1,k=1,m; lelemtype x,y,e; while(!listempty(la)!listempty(lb)) { getelem(la,i,x); getelem(lb,j,y); if(xy) { listinsert(lc,k,x); i++; } else { listinsert(lc,k,y); j++; } k++; } if(listempty(la))
for(m=j;m=listlength(lb);m++)
listinsert(lc,k++,getelem(lb,m,e)); else for(m=i;m=listlength(la);m++)
listinsert(lc,k++,getelem(la,m,e)); }
因篇幅问题不能全部显示，请点此查看更多更全内容