数据结构实用教程(第三版)课后答案

合集下载

数据结构实用教程(第三版)课后答案

数据结构实用教程( 第三版) 课后答案file:///D|/ ------------------ 上架商品---------------------- / 数据结构实用教程( 第三版)课后答案(徐孝凯著)清华大学/第一章绪论.txt第一章绪习题一一、单选题1. 一个数组元数a[i] 与( A ) 的表示等价。

A *(a+i)B a+iC *a+iD &a+i2. 对于两个函数，若函数名相同，但只是( C) 不同则不是重载函数。

A 参数类型B 参数个数C 函数类型3. 若需要利用形参直接访问实参，则应把形参变量说明为(B) 参数。

A 指针B 引用C 值4. 下面程序段的复杂度为(C ) 。

for(int i=0;i<m;i++)for(int j=0;j<n;j++)a[i][j]=i*j;A O(m2)B O(n2)C O(m*n)D O(m+n)5. 执行下面程序段时，执行S语句的次数为(D )。

for(int i=1;i<=n;i++)for(int j=1; j<=i;j++)S;A n2B n2/2C n(n+1)D n(n+1)/26. 下面算法的时间复杂度为( B) 。

int f(unsigned int n){if(n==0||n==1) return 1;Else return n*f(n-1);}A O(1)B O(n)C O(n2)D O(n!)二、填空题1. 数据的逻辑结构被除数分为集合结构、线性结构、树型结构和图形结构四种。

2. 数据的存储结构被分为顺序结构、结构、索引结构和散列结构四种。

3. 在线性结构、树型结构和图形结构中，前驱和后继结点之间分别存在着1 对1 、1 对N 和M对N的关系。

4. 一种抽象数据类型包括数据和操作两个部分。

5. 当一个形参类型的长度较大时，应最好说明为引用，以节省参数值的传输时间和存储参数的空间。

6. 当需要用一个形参访问对应的实参时，则该形参应说明为引用。

数据结构(第3版)习题及实验参考答案14438

附录习题及实验参考答案习题1参考答案1.1.选择题(1). A. (2). A. (3). A. (4). B.,C. (5). A. (6). A. (7). C. (8). C. (9). B. (10.)A.1.2.填空题(1). 数据关系(2). 逻辑结构物理结构(3). 线性数据结构树型结构图结构(4). 顺序存储链式存储索引存储散列表（Hash）存储(5). 变量的取值范围操作的类别(6). 数据元素间的逻辑关系数据元素存储方式或者数据元素的物理关系(7). 关系网状结构树结构(8). 空间复杂度和时间复杂度(9). 空间时间(10). Ο(n)1.3 名词解释如下：数据：数据是信息的载体，是计算机程序加工和处理的对象，包括数值数据和非数值数据。

数据项：数据项指不可分割的、具有独立意义的最小数据单位，数据项有时也称为字段或域。

数据元素：数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理，一个数据元素可由若干个数据项组成。

数据逻辑结构：数据的逻辑结构就是指数据元素间的关系。

数据存储结构：数据的物理结构表示数据元素的存储方式或者数据元素的物理关系。

数据类型：是指变量的取值范围和所能够进行的操作的总和。

算法：是对特定问题求解步骤的一种描述，是指令的有限序列。

1.4 语句的时间复杂度为：(1) Ο(n2)(2) Ο(n2)(3) Ο(n2)(4) Ο(n-1)(5) Ο(n3)1.5 参考程序：main(){int X,Y,Z；scanf(“%d, %d, %d”,&X,&Y,Z)；if (X>=Y)if(X>=Z)if (Y>=Z){ printf(“%d, %d, %d”,X,Y,Z);}else{ printf(“%d, %d, %d”,X,Z,Y);}else{ printf(“%d, %d, %d”,Z,X,Y);}elseif(Z>=X)if (Y>=Z){ printf(“%d, %d, %d”,Y,Z,X);}else{ printf(“%d, %d, %d”,Z,Y,X);}else{ printf(“%d, %d, %d”,Y,X,Z);}}1.6 参考程序：main(){int i,n;float x,a[],p;printf(“\nn=”);scanf(“%f”,&n);printf(“\nx=”);scanf(“%f”,&x);for(i=0;i<=n;i++)scanf(“%f ”,&a[i]);p=a[0];for(i=1;i<=n;i++){ p=p+a[i]*x;x=x*x;}printf(“%f”,p)’}习题2参考答案2.1选择题(1). C. (2). B. (3). B. (4). B. 5. D. 6. B. 7. B. 8. A. 9. A. 10. D.2.2.填空题(1). 有限序列(2). 顺序存储和链式存储(3). Ｏ(n) O(n)(4). n-i+1 n-i(5). 链式(6). 数据指针(7). 前驱后继(8). Ο(1) Ο(n)(9). s->next=p->next; p->next=s ;(10). s->next2.3. 解题思路：将顺序表A中的元素输入数组a，若数组a中元素个数为n,将下标为0，1,2,…,（n-1）/2的元素依次与下标为n,n-1,…, （n-1）/2的元素交换，输出数组a的元素。

数据结构c语言版第三版习题解答

数据结构c语言版第三版习题解答数据结构 C 语言版第三版习题解答在学习计算机科学与技术的过程中，数据结构是一门非常重要的基础课程。

而《数据结构C 语言版第三版》更是众多教材中的经典之作。

其中的习题对于我们理解和掌握数据结构的概念、原理以及算法实现起着至关重要的作用。

接下来，我将为大家详细解答这本书中的一些典型习题。

首先，让我们来看一道关于线性表的习题。

题目是这样的：设计一个算法，从一个有序的线性表中删除所有其值重复的元素，使表中所有元素的值均不同。

对于这道题，我们可以采用双指针的方法来解决。

定义两个指针 p和 q，p 指向线性表的开头，q 从 p 的下一个位置开始。

当 q 所指向的元素与 p 所指向的元素相同时，我们就将 q 所指向的元素删除，并将 q 向后移动一位。

当 q 所指向的元素与 p 所指向的元素不同时，我们将 p 向后移动一位，并将 q 所指向的元素赋值给 p 所指向的位置，然后再将 q 向后移动一位。

当 q 超出线性表的范围时，算法结束。

下面是用 C 语言实现的代码：｀｀｀cvoid removeDuplicates(int arr, int n) ｛int p ＝ 0, q ＝ 1;while （q ＜ n) ｛if （arrp ＝＝ arrq) ｛for （int i ＝ q; i ＜ n 1; i+＋）｛arri ＝ arri ＋ 1;｝（n)；｝ else ｛p+＋；arrp ＝ arrq;｝q+＋；｝｝｀｀｀再来看一道关于栈的习题。

题目是：利用栈实现将一个十进制数转换为八进制数。

我们知道，将十进制数转换为八进制数可以通过不断除以 8 取余数的方法来实现。

而栈的特点是后进先出，正好适合存储这些余数。

以下是 C 语言实现的代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>define MAX_SIZE 100typedef struct ｛int top;int dataMAX_SIZE;｝ Stack;／／初始化栈void initStack(Stack s) ｛s>top ＝－1;｝／／判断栈是否为空int isEmpty(Stack s) ｛return s>top ＝＝－1;｝／／判断栈是否已满int isFull(Stack s) ｛return s>top ＝＝ MAX_SIZE 1;｝／／入栈操作void push(Stack s, int element) ｛if （isFull(s)）｛printf(＂Stack Overflow!＼n"）；return;｝s>data+＋s>top ＝ element;｝／／出栈操作int pop(Stack s) ｛if （isEmpty(s)）｛printf(＂Stack Underflow!＼n"）；return －1;｝return s>datas>top;｝／／将十进制转换为八进制void decimalToOctal(int decimal) ｛Stack s;initStack(＆s)；while （decimal!＝ 0) ｛push(＆s, decimal ％ 8)；decimal ／＝ 8;｝while （！isEmpty(＆s)）｛printf(＂％d"， pop(＆s)）；｝printf(＂＼n"）；｝int main(）｛int decimal;printf(＂请输入一个十进制数: ＂）；scanf(＂％d"，＆decimal)；printf(＂转换后的八进制数为: ＂）；decimalToOctal(decimal)；return 0;｝｀｀｀接下来是一道关于队列的习题。

数据结构第三版第九章课后习题参考答案

}
}
设计如下主函数：
void main()
{ BSTNode *bt;
KeyType k=3;
int a[]={5,2,1,6,7,4,8,3,9},n=9;
bt=CreatBST(a,n);
//创建《教程》中图 9.4(a)所示的二叉排序树
printf("BST:");DispBST(bt);printf("\n");
#define M 26 int H(char *s)
//求字符串 s 的哈希函数值
{
return(*s%M);
}
构造哈希表 void Hash(char *s[]) //
{ int i,j;
char HT[M][10]; for (i=0;i<M;i++)
//哈希表置初值
HT[i][0]='\0'; for (i=0;i<N;i++) { j=H(s[i]);
//求每个关键字的位置求 // s[i]的哈希函数值
while (1)
不冲突时直接放到该处 { if (HT[j][0]=='\0') //
,
{ strcpy(HT[j],s[i]);
break;
}
else
//冲突时,采用线性线性探测法求下一个地址
j=(j+1)%M;
}
} for (i=0;i<M;i++)
printf("%2d",path[j]);
printf("\n");
}
else { path[i+1]=bt->key;

数据结构(c语言版)第三版习题解答

数据结构(c语言版)第三版习题解答数据结构（C语言版）第三版习题解答1. 栈(Stack)1.1 栈的基本操作栈是一种具有特定限制的线性表，它只允许在表的一端进行插入和删除操作。

栈的基本操作有：（1）初始化栈（2）判断栈是否为空（3）将元素入栈（4）将栈顶元素出栈（5）获取栈顶元素但不出栈1.2 栈的实现栈可以使用数组或链表来实现。

以数组为例，声明一个栈结构如下：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储栈中的元素int top; // 栈顶指针} Stack;```1.3 栈的应用栈在计算机科学中有广泛的应用，例如计算表达式的值、实现函数调用等。

下面是一些常见的栈应用：（1）括号匹配：使用栈可以检查一个表达式中的括号是否匹配。

（2）中缀表达式转后缀表达式：栈可以帮助我们将中缀表达式转换为后缀表达式，便于计算。

（3）计算后缀表达式：使用栈可以方便地计算后缀表达式的值。

2. 队列(Queue)2.1 队列的基本操作队列是一种按照先进先出（FIFO）原则的线性表，常用的操作有：（1）初始化队列（2）判断队列是否为空（3）将元素入队（4）将队头元素出队（5）获取队头元素但不出队2.2 队列的实现队列的实现一般有循环数组和链表两种方式。

以循环数组为例，声明一个队列结构如下：```c#define MAX_SIZE 100typedef struct {int data[MAX_SIZE]; // 存储队列中的元素int front; // 队头指针int rear; // 队尾指针} Queue;```2.3 队列的应用队列在计算机科学中也有广泛的应用，例如多线程任务调度、缓存管理等。

下面是一些常见的队列应用：（1）广度优先搜索：使用队列可以方便地实现广度优先搜索算法，用于解决图和树的遍历问题。

（2）生产者-消费者模型：队列可以用于实现生产者和消费者之间的数据传输，提高系统的并发性能。

实用数据结构基础(第三版)课后答案

{
if (top= =0)
printf (“堆栈为空栈！”);
else
{
if (top= =1)
{
x=S[top];
top––;
}
else
{
x=S[top];
top=top–M;
}
}
}
（2）设计一个算法，要求判别一个算术表达式中的圆括号配对是否正确。
解：//设表达式在字符数组a[ ]中，使用一堆栈S来帮助判断。
四．分析下述算法的功能
（1）返回结点*p的直接前趋结点地址。
（2）交换结点*p和结点*q（p和q的值不变）。
五．程序填空
（1）已知线性表中的元素是无序的，并以带表头结点的单链表作存储。试写一算法，删除表中所有大于min，小于max的元素，试完成下列程序填空。
Void delete (lklist head; datatype min, max)
}
（2）已知一个单向链表，编写一个函数从单链表中删除自第i个结点起的k个结点。
解：
void Del(node *head,int i,int k)
{
node *p,*q;
int j;
if(i==1)
for(j=1;j<=k;j++) //删除前k个元素
{
p=head; // p指向要删除的结点
head=head->next;
}
return(n);
}
（5）有两个循环单向链表，链头指针分别为head1和head2，编写一个函数将链表head1链接到链表head2，链接后的链表仍是循环链表。
解：//本题的算法思想是：先找到两链表的尾指针，将第一个链表的尾指针与第二个链表的头结点链接起来，使之成为循环的。函数如下：

数据库实用教程答案(第三版)清华大学出版社

数据库实用教程答案(第三版).doc第1、2章1.1 名词解释：◆ DB：数据库〔Database),DB是统一管理的相关数据的集合。

DB能为各种用户共享，具有最小冗余度，数据间联系密切，而又有较高的数据独立性。

◆ DBMS：数据库管理系统〔Database Management System)，DBMS是位于用户与操作系统之间的一层数据管理软件，为用户或应用程序提供访问DB的方法，包括DB的建立、查询、更新及各种数据控制。

DBMS总是基于某种数据模型，可以分为层次型、网状型、关系型、面向对象型DBMS。

◆ DBS：数据库系统〔Database System),DBS是实现有组织地、动态地存储大量关联数据，方便多用户访问的计算机软件、硬件和数据资源组成的系统，即采用了数据库技术的计算机系统。

◆ 1：1联系：如果实体集E1中的每个实体最多只能和实体集E2中的一个实体有联系，反之亦然，好么实体集E1对E2的联系称为“一对一联系〞，记为“1：1〞。

◆ 1：N联系：如果实体集E1中每个实体与实体集E2中任意个〔零个或多个〕实体有联系，而E2中每个实体至多和E1中的一个实体有联系，那么E1对E2的联系是“一对多联系〞，记为“1：N〞。

◆ M：N联系：如果实体集E1中每个实体与实体集E2中任意个〔零个或多个〕实体有联系，反之亦然，那么E1对E2的联系是“多对多联系〞，记为“M：N〞。

◆ 数据模型：表示实体类型及实体类型间联系的模型称为“数据模型〞。

它可分为两种类型：概念数据模型和结构数据模型。

◆ 概念数据模型：它是独门于计算机系统的模型，完全不涉及信息在系统中的表示，只是用来描述某个特定组织所关心的信息结构。

◆ 结构数据模型：它是直接面向数据库的逻辑结构，是现实世界的第二层抽象。

这类模型涉及到计算机系统和数据库管理系统，所以称为“结构数据模型〞。

结构数据模型应包含：数据结构、数据操作、数据完整性约束三局部。

数据结构教程第三版第三章课后习题答案

scanf("%d",&a); if (a>0) { if ((qu->rear+1)%QueueSize==qu->front)
printf(" 队列满,不能入队\n"); else { qu->rear=(qu->rear+1)%QueueSize; //入队
qu->data[qu->rear]=a; } } else if (a<0) { if (qu->rear==qu->front)
QT[x]=s;
之后 //让 QT[x]仍指向尾结点
}
}
void Create(QNode *QH[],QNode *QT[]) //根据用户输入创建队列
{ int n,x,i;
printf("n:");
scanf("%d",&n);
for (i=0;i<n;i++)
{ do
{ printf("输入第%d 个数:",i+1);
{ tail->next=QH[i];
tail=QT[i];
}
}
printf("\n 输出所有元素:");
while (head!=NULL)
{ printf("%d ",head->data);
head=head->next;
}
printf("\n");
}
void main()
{ int i; QNode *QH[MAXQNode],*QT[MAXQNode]; //各队列的队头 QH 和队尾指针 QT for

数据结构教程(第三版)课后答案

数据结构教程(第三版)课后答案/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType; typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L) {L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L) {free(L);}int ListEmpty(SqList *L) {return(L->length==0); }int ListLength(SqList *L) {return(L->length);}void DispList(SqList *L) {int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e) {if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->elem[i]!=e) i++; if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e) {int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/ L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}/*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType; typedef struct LNode /*定义单链表结点类型*/ {ElemType data;struct LNode *next; } LinkList;void InitList(LinkList *&L) {L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L) {return(L->next==NULL); }int ListLength(LinkList *L) {LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L) {LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e) {int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}/*文件名:algo2-3.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType; typedef struct DNode /*定义双链表结点类型*/ { ElemType data;struct DNode *prior; /*指向前驱结点*/struct DNode *next; /*指向后继结点*/ } DLinkList;void InitList(DLinkList *&L) {L=(DLinkList *)malloc(sizeof(DLinkList)); /*创建头结点*/L->prior=L->next=NULL; }void DestroyList(DLinkList *&L) {DLinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(DLinkList *L) { return(L->next==NULL); }int ListLength(DLinkList *L) {DLinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(DLinkList *L) { DLinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(DLinkList *L,int i,ElemType &e) {int j=0;DLinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(DLinkList *L,ElemType e) {int n=1;DLinkList *p=L->next;while (p!=NULL && p->data!=e){n++;p=p->next;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(DLinkList *&L,int i,ElemType e) {int j=0;DLinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/if (p->next!=NULL) p->next->prior=s;s->prior=p;p->next=s;return 1;}}int ListDelete(DLinkList *&L,int i,ElemType &e){int j=0;DLinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/if (q==NULL) return 0; /*不存在第i个结点*/p->next=q->next; /*从单链表中删除*q结点*/if (p->next!=NULL) p->next->prior=p;free(q); /*释放*q结点*/return 1;}}void Sort(DLinkList *&head) /*双链表元素排序*/{DLinkList *p=head->next,*q,*r;if (p!=NULL) /*若原双链表中有一个或以上的数据结点*/{r=p->next; /*r保存*p结点后继结点的指针*/p->next=NULL; /*构造只含一个数据结点的有序表*/p=r;while (p!=NULL){r=p->next; /*r保存*p结点后继结点的指针*/q=head;while (q->next!=NULL && q->next->data<p->data) /*在有序表中找插入*p 的前驱结点*q*/q=q->next;p->next=q->next; /*将*p插入到*q之后*/if (q->next!=NULL) q->next->prior=p;q->next=p;p->prior=q;p=r;}}}/*文件名:algo2-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/ { ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L) {L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/ L->next=L;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L) { return(L->next==L); }int ListLength(LinkList *L) { LinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(LinkList *L) { LinkList *p=L->next;while (p!=L){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p;if (L->next!=L) /*单链表不为空表时*/{if (i==1){e=L->next->data;return 1;}else /*i不为1时*/{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}}else /*单链表为空表时*/return 0;}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=L && p->data!=e){p=p->next;n++;}if (p==L)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e) {int j=0;LinkList *p=L,*s;if (p->next==L || i==1) /*原单链表为空表或i==1时*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}else{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}}}int ListDelete(LinkList *&L,int i,ElemType &e) {int j=0;LinkList *p=L,*q;if (p->next!=L) /*原单链表不为空表时*/{if (i==1) /*i==1时*/{q=L->next; /*删除第1个结点*/L->next=q->next;free(q);return 1;}else /*i不为1时*/{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}}else return 0;}/*文件名:algo2-5.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType; typedef struct DNode /*定义双链表结点类型*/ { ElemType data;struct DNode *prior; /*指向前驱结点*/struct DNode *next; /*指向后继结点*/ } DLinkList;void InitList(DLinkList *&L) {L=(DLinkList *)malloc(sizeof(DLinkList)); /*创建头结点*/L->prior=L->next=L;}void DestroyList(DLinkList *&L) { DLinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(DLinkList *L) { return(L->next==L);}int ListLength(DLinkList *L){DLinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(DLinkList *L){DLinkList *p=L->next;while (p!=L){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(DLinkList *L,int i,ElemType &e) {int j=0;DLinkList *p;if (L->next!=L) /*双链表不为空表时*/{if (i==1){e=L->next->data;return 1;}else /*i不为1时*/{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}}else /*双链表为空表时*/return 0;}int LocateElem(DLinkList *L,ElemType e) {int n=1;DLinkList *p=L->next;while (p!=NULL && p->data!=e){n++;p=p->next;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(DLinkList *&L,int i,ElemType e){int j=0;DLinkList *p=L,*s;if (p->next==L) /*原双链表为空表时*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/ s->data=e;p->next=s;s->next=p;p->prior=s;s->prior=p;return 1;}else if (i==1) /*原双链表不为空表但i=1时*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next;p->next=s; /*将*s插入到*p之后*/s->next->prior=s;s->prior=p;return 1;}else{p=L->next;while (j<i-2 && p!=L){ j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/if (p->next!=NULL) p->next->prior=s;s->prior=p;p->next=s;return 1;}}}int ListDelete(DLinkList *&L,int i,ElemType &e) {int j=0;DLinkList *p=L,*q;if (p->next!=L) /*原双链表不为空表时*/{if (i==1) /*i==1时*/{q=L->next; /*删除第1个结点*/L->next=q->next;q->next->prior=L;free(q);return 1;}else /*i不为1时*/{p=L->next;while (j<i-2 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/if (q==NULL) return 0; /*不存在第i个结点*/ p->next=q->next; /*从单链表中删除*q结点*/ if (p->next!=NULL) p->next->prior=p;free(q); /*释放*q结点*/return 1;}}}else return 0; /*原双链表为空表时*/}/*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType; typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s) {s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s) { free(s);}int StackLength(SqStack *s) { return(s->top+1);}int StackEmpty(SqStack *s) {return(s->top==-1);}int Push(SqStack *&s,ElemType e) { if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e) {if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;}int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s) {int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h> typedef char ElemType; typedef struct linknode { ElemType data; /*数据域*/struct linknode *next; /*指针域*/ } LiStack;void InitStack(LiStack *&s) {s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s) {LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s) {int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s) { return(s->next==NULL); }void Push(LiStack *&s,ElemType e) {LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/ s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType; typedef struct {ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q) {q=(SqQueue *)malloc (sizeof(SqQueue)); q->front=q->rear=0;}void ClearQueue(SqQueue *&q) {free(q);}int QueueEmpty(SqQueue *q) {return(q->front==q->rear); }int QueueLength(SqQueue *q) {return (q->rear-q->front+MaxSize)%MaxSize;}int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}/*文件名:algo3-4.cpp*/ #include <stdio.h> #include <malloc.h> typedef char ElemType; typedef struct qnode {ElemType data;struct qnode *next; } QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue)); q->front=q->rear=NULL; }void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/ {r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q) {if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/ q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/ q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/ {t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/ typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/int len; /*标记当前实际串长*/ } SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ { int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/ same=0;}return same;}int StrLength(SqString s) {return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0],s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0],t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j) {SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i],s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0],s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0],s2.ch[s2.len-1]复制到str*/ str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1],s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j) {int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0],s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1],ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0],s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0],t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1],ch[s.len-1]复制到str*/ str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str) {int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}/*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]) { int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t) { LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t) { LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data) {p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t) { LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString)); str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j) {int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t) {int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j) {int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t) { int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s) {LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}/*文件名:algo7-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data; /*数据元素*/struct node *lchild; /*指向左孩子*/struct node *rchild; /*指向右孩子*/} BTNode;void CreateBTNode(BTNode *&b,char *str) /*由str串创建二叉链*/ { BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL; /*建立的二叉树初始时为空*/ch=str[j];。

数据结构(C语言版)第三版__清华大学出版社_习题参考答案

数据结构(C语言版)第三版__清华大学出版社_习题参考答案数据结构(C语言版)第三版__清华大学出版社_习题参考答案引言：数据结构是计算机科学的基础，对于学习和理解数据结构的相关概念和算法非常重要。

本文将对清华大学出版社出版的《数据结构(C语言版)第三版》中的习题进行参考答案的提供。

通过正确的理解和掌握这些习题的解答，读者可以加深对数据结构的认识，并提高自己的编程能力。

第一章：绪论1.1 数据结构的定义与作用数据结构是指数据对象以及数据对象之间的关系、运算和存储结构的总称。

数据结构的作用是在计算机中高效地组织和存储数据，同时支持常见的数据操作和算法。

1.2 算法的定义与特性算法是解决特定问题的一系列步骤和规则。

算法具有确定性、有穷性、可行性和输入输出性等特点。

第二章：线性表2.1 线性表的定义和基本操作线性表是同类型数据元素的一个有限序列。

线性表的基本操作包括初始化、查找、插入、删除和遍历等。

2.2 顺序存储结构顺序存储结构是将线性表中的元素按顺序存放在一块连续的存储空间中。

顺序存储结构的特点是随机存取、插入和删除操作需要移动大量元素。

2.3 链式存储结构链式存储结构通过结点之间的指针链表来表示线性表。

链式存储结构的特点是插入和删除操作方便，但查找操作需要遍历整个链表。

第三章：栈和队列3.1 栈的定义和基本操作栈是只能在一端进行插入和删除操作的线性表。

栈的基本操作包括初始化、入栈、出栈和获取栈顶元素等。

3.2 队列的定义和基本操作队列是只能在一端插入操作，在另一端进行删除操作的线性表。

队列的基本操作包括初始化、入队、出队和获取队头元素等。

第四章：串4.1 串的定义和基本操作串是由零个或多个字符组成的有限序列。

串的基本操作包括初始化、串的赋值、串的连接和串的比较等。

第五章：树5.1 树的基本概念和术语树是n（n>=0）个结点的有限集。

树的基本概念包括根结点、子树、深度和高度等。

5.2 二叉树二叉树是每个结点最多有两个子树的树结构。

数据结构(第3版)习题答案

g是f的一个上限（不考虑常数因子c）。在为函数f提供一个上限函数g时，通常使用比较
简单的函数形式。比较典型的形式是含有n的单个项（带一个常数系数）。表1-1列出了一些
常用的g函数及其名称。对于表1-1中的对数函数logn，没有给出对数基，原因是对于任何大
于1的常数a和b都有logan =logbn/logba,所以logan和logbn都有一个相对的乘法系数1/logba，
合。
1.3两个数据结构的逻辑结构和存储结构都相同，但是它们的运算集合中有一个运算的定义不
一样，它们是否可以认作是同一个数据结构？为什么？
【答】：不能，运算集合是数据结构的重要组成部分，不同的运算集合所确定的数据结构是不
一样的，例如，栈与队列它们的逻辑结构与存储结构可以相同，但由于它们的运算集合不一样，
if (L->data[i]==x) c++;
return c;
}
2.4设计一个算法，将一个顺序表倒置。即，如果顺序表各个结点值存储在一维数组a中，倒
置的结果是使得数组a中的a[0]等于原来的最后一个元素，a[1]等于原来的倒数第2个元
素，…，a的最后一个元素等于原来的第一个元素。
【答】：顺序表的存储结构定义同题2.3，实现顺序表倒置的算法程序如下：
【答】：顺序表的存储结构定义如下（文件名seqlist.h）：
#include <stdio.h>
#define N 100
typedef int datatype;
typedef struct {
datatype data[N];
int length;
} seqlist;
/*预定义最大的数据域空间*/

数据结构教程习题答案李蓉蓉安杨等编著第三版第三章答案

资料范本本资料为word版本，可以直接编辑和打印，感谢您的下载数据结构教程习题答案李蓉蓉安杨等编著第三版第三章答案地点：__________________时间：__________________说明：本资料适用于约定双方经过谈判，协商而共同承认，共同遵守的责任与义务，仅供参考，文档可直接下载或修改，不需要的部分可直接删除，使用时请详细阅读内容3.3/********************************************题目：假设表达式中允许包含三种括号，圆括号，方括号和大括号，编写一个算法判断表达式中的括号是不是匹配实践:狼影时间：2012.9.19************************************************/# include <stdio.h># include <stdlib.h># define size 256//定义节点typedef struct{char ex[size];int top;}STACK;//函数声明STACK *init_stack(void);bool is_match(char *exp);bool pop_stack(STACK *stack, char *ch);void push_stack(STACK *stack, char e);main(){char exp[256];printf("输入表达式\n");scanf("%s", exp);if(is_match(exp)){printf("此表达式匹配\n");}else{printf("此表达式不匹配\n");}}//栈的初始化STACK *init_stack(void){STACK *stack = (STACK *)malloc(sizeof(STACK)); if(NULL == stack){printf("内存分配失败\n");exit(-1);}stack->top = -1;return stack;}//判断是不是匹配bool is_match(char *exp){int i = 0;char ch;STACK *stack;stack = init_stack();while(exp[i] != '\0'){if('('==exp[i] || '['==exp[i] || '{'==exp[i]){push_stack(stack, exp[i]);}else if(')'==exp[i] || ']'==exp[i] || '}'==exp[i]) {//线面是匹配的三种情况，switch(exp[i]){case ')':if(pop_stack(stack, &ch)){if(ch != '(')return false;}elsereturn false;break;case ']':if(pop_stack(stack, &ch)) {if(ch != '[')return false;}elsereturn false;break;case '}':if(pop_stack(stack, &ch)) {if(ch != '{')return false;}elsereturn false;break;default:break;}}i++;}if(-1 == stack->top) return true;elsereturn false;}//入栈的操作void push_stack(STACK *stack, char e){stack->top++;stack->ex[stack->top] = e;}//出栈的操作bool pop_stack(STACK *stack, char *ch){if(-1 == stack->top)return false;else{*ch = stack->ex[stack->top];stack->top--;}return true;}/*********************************************** 输入表达式(((1+2+3*5{{{[[[234]]]}}})))此表达式匹配Press any key to continue**********************************************/3.4/*************************************************题目;设从键盘输入一整数序列，编写程序，当ai大于零时，ai进队，当ai小于零时，将对首元素出队当ai等于零时，将表示输入结束，要求用环形队列，进队与出队单独编写算法，并在异常情况下打印出错实践：狼影时间;2012.9.20***************************************************************/ # include <stdio.h># include <stdlib.h># define size 100typedef struct{int node[size];int front;int rear;}QUEUE;//函数声明QUEUE *init_queue(void);bool en_queue(QUEUE *queue, int e);bool out_queue(QUEUE *queue);void print_queue(QUEUE *queue); main(){QUEUE *queue;int arry[size];int n;int i;queue = init_queue();printf("输入数字的个数\n"); scanf("%d", &n);printf("请输入数据\n");for(i = 0; i<n; i++){scanf("%d", &arry[i]);}i = 0;while(i<n){if(arry[i]>0){if(!en_queue(queue, arry[i])) {printf("进队出错\n");break;}if(arry[i]<0)if(!out_queue(queue)){printf("出队错误\n");break;}if(arry[i] == 0){break;}i++;}printf("队列内容是\n");print_queue(queue);printf("\n");}//初始化队列QUEUE *init_queue(void){QUEUE *queue = (QUEUE *)malloc(sizeof(QUEUE)); if(NULL == queue){printf("内存分配错误\n");exit(-1);queue->front = queue->rear = -1;return queue;}//进队的操作bool en_queue(QUEUE *queue, int e){if(queue->front == (queue->rear+1)%size) return false;else{queue->rear = (queue->rear+1)%size; queue->node[queue->rear] = e;}return true;}//进行出队操作bool out_queue(QUEUE *queue){if(queue->rear == queue->front)return false;elsequeue->front = (queue->front+1)%size; return true;}//打印队列void print_queue(QUEUE *queue){if(queue->front == queue->rear){printf("队列为空\n");return;}else{while(queue->front != queue->rear){queue->front = (queue->front+1)%size; printf("%d ", queue->node[queue->front]); }}}/***************************输入数字的个数5请输入数据1 2 3 -1 4队列内容是2 3 4Press any key to continue****************************/3.5/****************************************************题目：编写一个算法，将一个环形队列（容量为n，元素下标从1到n）的元素倒置（具体的图请参考课本p88）设计;狼影时间：2012.9.20********************************************/# include <stdio.h># include <stdlib.h>/******************************************解此题的思路是将队列中的数据先转到栈中，然后再把栈中的数据转到另一个队列中，实现倒置对照书中给的图来初始化两个队列图参考课本88页也有其他简单的方法，如果你想到告诉我一声啊，，共同学习吗！************************************************/typedef struct{char c[20];int top;}STACK;typedef struct{char ch[20];int rear;int front;}QUEUE;//函数声明void creat_queue(QUEUE *queue);QUEUE *init_queue1(void);void traverse(QUEUE *queue1, QUEUE *queue2, STACK *stack); STACK *init_stack(void);QUEUE *init_queue2(void);void creat_queue(QUEUE *queue);void print_queue(QUEUE *queue);main(){QUEUE *queue1, *queue2;STACK *stack;stack = init_stack();queue1 = init_queue1();queue2 = init_queue2();creat_queue(queue1);traverse(queue1, queue2, stack);print_queue(queue2);}//初始化队列QUEUE *init_queue1(void){if(NULL == queue){printf("内存分配错误\n");exit(-1);}queue->front = 8;queue->rear = 8;return queue;}//栈的初始化STACK *init_stack(void){STACK *stack = (STACK *)malloc(sizeof(STACK)); if(NULL == stack){printf("内存分配错误\n");exit(-1);}stack->top = -1;return stack;}//队列的初始化QUEUE *init_queue2(void){if(NULL == queue){printf("内存分配错误\n");exit(-1);}queue->front = 10;queue->rear = 0;return queue;}//创建队列void creat_queue(QUEUE *queue){char c;for(c = 'a'; c<='f'; c++){queue->rear = (queue->rear)%10+1;queue->ch[queue->rear] = c;}}//数的转置void traverse(QUEUE *queue1, QUEUE *queue2, STACK *stack) {queue1->front = (queue1->front)%10+1;//将队列中的数出队放到栈中{stack->top++;stack->c[stack->top] = queue1->ch[queue1->front]; queue1->front = (queue1->front)%10+1;}stack->top++;stack->c[stack->top] = queue1->ch[queue1->front]; free(queue1);//将元素出栈，放到队列中queue2->rear = (queue2->rear)%10+1;while(stack->top != -1){queue2->ch[queue2->rear] = stack->c[stack->top]; stack->top--;queue2->rear = (queue2->rear)%10+1;}}//打印队列中的内容void print_queue(QUEUE *queue){queue->front = (queue->front)%10+1;while(queue->front != queue->rear){printf("%c ", queue->ch[queue->front]);}printf("\n");}3.6/***************************************题目:输入n个10以内的数每输入i（0<=i<=9)就把它插入到第i号队列，最后把10个队中非空队列，按队列号从小到大的顺序串接成一条链，并输出该链的所有元素设计：狼影时间：2012.9.20***************************************************************** */# include <stdio.h># include <stdlib.h>//在这里用链表的形式来创建队列typedef struct node{int data;struct node *pNext;}NODE;typedef struct{NODE *front;NODE *rear;}QUEUE;//函数的声明NODE *init_link(void);QUEUE *init_queue(void);void en_queue(QUEUE *queue, int i);void print_link(NODE *pHead);void en_queue(QUEUE *queue, int i);bool is_empty(QUEUE *queue);void put_link(QUEUE *queue, NODE *pHead); main(){int n, i, j;QUEUE *queue[10];NODE *pHead;//初始化化链表pHead = init_link();//初始化10个队列for(j = 0; j<10; j++){queue[j] = init_queue();}//输入输入数的个数printf("请输入数的个数n\n");scanf("%d", &n);printf("请输入i值(0<=i<=9)\n");for(j = 0; j<n; j++){do{scanf("%d", &i);if(i<0 || i>=10){printf("你输入第%d个数据错误, 请重新输入\n", j+1); }}while(i<0 || i>=10); //当i值满足条件时，循环结束//将i值放入相应的队列中switch(i){case 0: en_queue(queue[0], i);break;case 1: en_queue(queue[1], i);break;case 2: en_queue(queue[2], i);break;case 3: en_queue(queue[3], i);break;case 4: en_queue(queue[4], i);break;case 5: en_queue(queue[5], i);break;case 6: en_queue(queue[6], i); break;case 7: en_queue(queue[7], i); break;case 8: en_queue(queue[8], i); break;case 9: en_queue(queue[9], i); break;default:break;}}//将队列中的内容放入链表for(i = 0; i<10; i++){if(!is_empty(queue[i])){put_link(queue[i], pHead);}}//打印链表printf("链表中的内容是\n"); print_link(pHead);}//初始化队列QUEUE *init_queue(void){QUEUE *queue;queue = (QUEUE *)malloc(sizeof(QUEUE));if(NULL == queue){printf("内存分配错误\n");exit(-1);}queue->front = (NODE *)malloc(sizeof(NODE)); if(NULL == queue->front){printf("内存分配错误\n");exit(-1);}queue->front->pNext = NULL;queue->rear = queue->front;return queue;}//链表的初始化NODE *init_link(void){NODE *pHead = (NODE *)malloc(sizeof(NODE)); if(NULL == pHead){printf("内存分配错误\n");exit(-1);}pHead->pNext = NULL;return pHead;}//进队列的操作void en_queue(QUEUE *queue, int i){NODE *pNew;pNew = (NODE *)malloc(sizeof(NODE));if(NULL == pNew){printf("内存分配错误\n");exit(-1);}pNew->pNext = NULL;pNew->data = i;queue->rear->pNext = pNew;queue->rear = pNew;}//将队列中的数据放入链表中void put_link(QUEUE *queue, NODE *pHead) {NODE *pNow = queue->front->pNext;NODE *pNew = pHead;while(NULL != pNew->pNext)pNew = pNew->pNext;pNew->pNext = queue->front->pNext; queue->front = queue->rear = NULL; free(queue);}//打印链表void print_link(NODE *pHead){NODE *pNow = pHead->pNext;if(NULL == pNow){printf("链表为空\n");return;}while(NULL != pNow){printf("%d ", pNow->data);pNow = pNow->pNext;}printf("\n");}//判断是不是空bool is_empty(QUEUE *queue){if(queue->front == queue->rear)return true;elsereturn false;}/*****************************************请输入数的个数n6请输入i值(0<=i<=9)1 3 4 102 3你输入第4个数据错误, 请重新输入3链表中的内容是1 2 3 3 3 4Press any key to continue********************************************************/。

数据结构与算法第三版第1章参考答案

一．选择题.从逻辑上可以把数据结构分为（)两大类..动态结构、静态结构.顺序结构、链式结构.线性结构、非线性结构.初等结构、构造型结构.在下面地程序段中，对地斌值语句地频度为（).( ＝；＜＝＋＋）（＜＝; ＋＋）十；. () . () . ()．. （)文档来自于网络搜索.采用顺序存储结构表示数据时，相邻地数据元素地存储地址（)..一定连续．一定不连续.不一定连续.部分连续，部分不连续.下面关于算法说法正确地是（）..算法地时间复杂度一般与算法地空间复杂度成正比.解决某问题地算法可能有多种，但肯定采用相同地数据结构.算法地可行性是指算法地指令不能有二义性.同一个算法，实现语言地级别越高，执行效率就越低.在发生非法操作时，算法能够作出适当处理地特性称为（）..正确性.健壮性.可读性.可移植性二、判断题.数据地逻辑结构是指数据地各数据项之间地逻辑关系.（√）.顺序存储方式地优点是存储密度大，且插人、删除运算效率高.（×）.数据地逻辑结构说明数据元素之间地次序关系，它依赖于数据地存储结构.（×）.算法地优劣与描述算法地语言无关，但与所用计算机地性能有关.（×）.算法必须有输出，但可以没有输人.（√）三、筒答题．常见地逻辑结构有哪几种，各自地特点是什么？常用地存储结构有哪几种，各自地特点是什么？【答】常见地四种逻辑结构：①集合结构：数据元素之间是“属于同一个集合”②线性结构：数据元素之间存在着一对一地关系③树结构：数据元素之间存在着一对多地关系④结构：数据元素之间存在着多对多地关系.常见地四种存储结构有：①顺序存储：把逻辑上相邻地元素存储在物理位置相邻地存储单元中.顺序存储结构是一种最基本地存储表示方法，通常借助于程序设计语言中地数组来实现.文档来自于网络搜索②链接存储：对逻辑上相邻地元素不要求物理位置相邻地存储单元，元素间地逻辑关系通过附设地指针域来表示.③索引存储：通过建立索引表存储结点信息地方法，其中索引表一般存储结点关键字和一个地点信息，可通过该地址找到结点地其他信息.文档来自于网络搜索④散列存储：根据结点地关键字直接计算出该结点地存储地址地方法.．简述算法和程序地区别.【解答】一个算法若用程序设计语言来描述，则它就是一个程序.算法地含义与程序十分相似，但又有区别.一个程序不一定满足有穷性.例如，操作系统，只要整个系统不遭破坏，它将永远不会停止，即使没有作业需要处理，它仍处于动态等待中.因此，操作系统不是一个算法.另一方面，程序中地指令必须是机器可执行地，而算法中地指令则无此限制.算法代表了对问题地解，而程序则是算法在计算机上地特定地实现.文档来自于网络搜索.试举一个数据结构地例子，叙述其逻辑结构、存储结构、运算这方面地内容.【解答】略..运算是数据结构地一个重要方面.试举例说明两个数据结构地逻辑结构和存储方式完全相同，只是对于运算地定义不同，使得两个结构具有显著不同地特性.文档来自于网络搜索【解答】比如顺序栈和循环队列，二者地逻辑结构都是线性结构，都采用顺序存储方式存储，但它们地运算不同，栈限定元素地插入和删除在栈顶进行，队列限定元素在队尾插入、在队首删除，因此它们是截然不同地数据结构.文档来自于网络搜索．分析下列程序段中带标号“＃’’语句地执行频度(为正整数）.（) ＝；;（<）{＋＋；＋; ／*＃*／【解答】（）；；；{；＋＝*；／*＃*／}!(< <)；【解答】（）＝；(＝；＜；＋＋）(＝＜＋＋）＋＋；／＊＃＊／【解答】(＋)() ；;（＋＜＝）{( ＜）；／＊＃＊／；}［解答］（）＝；＝；（>){ (>) {; ;} ／＊＃＊／＋＋;}［解答].写出下列各程序段关于地时间复杂度.（）＝；＝；（＜）{＋;*＝；}[解答］()（）设是偶数.（，＝；＜＝；＋＋）（*；＜＝；＋＋）＋＋；［解答］（）（）（；＜；＋＋）{＝；(＋；＜＋＋）([]＞[＋]）＝；＝［］；［］［］；［］；}［解答］（）.计算一元次多项式( ，）＋＋＋．．＋“地值，输人，，，…，，输出多项式(，)地值.设计算法求解，请选择合适地输人、输出格式，要求算法具有较好地时间性能.文档来自于网络搜索【解答】①将一元次多项式做如下改写：( ，）＋＋＋．．＋＋(＋＋．．＋)……＋(＋(＋(．．(＋)…))))②按指数递减次序输人各系数，即输人次序为，，…，，③算法如下：( ){＝;(”" );(; >；）{ (" ”）；*；}（”（）”，）；}④分析：该算法仅使用了次乘法和次加法，来完成一元次多项式地求值问题，具有较好地时间和空间性能.。

算法数数据结构第3版绪论课后答案

算法与数据结构---C语言描述（第三版）第1章绪论1、解释以下概念：逻辑结构，存储结构，操作，数据结构，数据结构的表示，数据结构的实现，抽象数据类型，算法，算法的时间代价，算法的空间代价，大O表示法，贪心法，回溯法，分治法。

答：(1)逻辑结构（数学模型）：①指数据元素之间地逻辑关系。

②具体解释：指数学模型（集合，表，树，和图）之间的关系。

③描述方式：B = <K,R>, K是节点的有穷集合，R是K上的一个关系。

(2)存储结构（物理结构）：数据的逻辑结构在计算机存储器中的映射（或表示）。

(3) 操作（行为）：指抽象数据类型关心的的各种行为在不同的存储结构上的具体算法（或程序）。

(4) 数据结构：①传统观念：数据结构是计算机中表示（存储）的、具有一定逻辑关系和行为特征的一组数据。

②根据面向对象的观点：数据结构是抽象数据类型的物理实现。

(5) 数据结构的表示：(6) 数据结构的实现：(7) 抽象数据类型：(8) 算法：是由有穷规则构成（为解决某一类问题）的运算序列。

-算法可以有若干输入（初始值或条件）。

-算法通常又有若干个输出（计算结果）。

-算法应该具有有穷性。

一个算法必须在执行了有穷步之后结束。

-算法应该具有确定性。

算法的每一步，必须有确切的定义。

-算法应该有可行性。

算法中国的每个动作，原则上都是能够有机器或人准确完成的。

(9) 算法的时间代价：(10) 算法的空间代价：(11) 大O表示法：-更关注算法复杂性的量级。

-若存在正常数c和n0，当问题的规模n>=c*f(n), 则说改算法的时间（或空间）代价为O（f(n)）(12) 贪心法：当追求的目标是一个问题的最优解是，设法把整个问题的求解工作分成若干步来完成。

在其中的每一个阶段都选择都选择从局部来看是最优的方案，以期望通过各个阶段的局部最有选择达到整体的最优。

例如：着色问题：先用一种颜色尽可能多的节点上色，然后用另一种颜色在为着色节点中尽可能多的节点上色，如此反复直到所有节点都着色为止；(13) 回溯法有一些问题，需要通过彻底搜索所有的情况寻找一个满足某些预定条件的最优解。

《实用数据结构基础》第三版课后参考答案(陈元春王中...

单元练习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 的函数。

数据结构C语言第三版习题6参考答案

习题6参考答案6.1 选择题（1）C （2）A （3）B（4）C（5）B（6）B（7）A（8）A（9）B（10）A （11）A（12）A（13）B（14）D（15）B（16）A（17）C6.2 填空（1） 4（2） 1对多 ; 多对多（3） n-1 ; n（4） 0_（5）有向图（6） 1（7）两倍（8）两倍（9）___第i个链表中边表结点数___（10）___第i个链表中边表结点数___（11）深度优先遍历；广度优先遍历（12）O（n2）（13）___无回路6.3（1）邻接矩阵:（2）邻接链表：（3）每个顶点的度：顶点度V1 3V2 3V3 2V4 3V5 36.4（1）邻接链表：（2）逆邻接链表：（3）顶点入度出度V1 3 0V2 2 2V3 1 2V4 1 3V5 2 1V6 2 36.5（1）深度优先查找遍历序列：V1 V2 V3 V4 V5; V1 V3 V5 V4 V2; V1 V4 V3 V5 V2 （1）广度优先查找遍历序列：V1 V2 V3 V4 V5; V1 V3 V2 V4 V5; V1 V4 V3 V2 V56.6有两个连通分量：6.7最小生成树的示意图如下：6.8拓扑排序结果： V3→ V1 → V4 → V5 → V2 → V66.9（1）建立无向图邻接矩阵算法：提示：参见算法6.1因为无向图的邻接矩阵是对称的，所以有for (k=0; k<G ->e; k++) /*输入e 条边，建立无向图邻接矩阵*/ { scanf("\n%d,%d",&i,&j);G ->edges[i][j]= G ->edges[j][i]=1; }(2)建立无向网邻接矩阵算法: 提示：参见算法6.1 。

初始化邻接矩阵：#define INFINITY 32768 /* 表示极大值*/for(i=0;i<G->n;i++)for(j=0;j<G->n;j++) G->edges[i][j]= INFINITY;输入边的信息：不仅要输入边邻接的两个顶点序号，还要输入边上的权值for (k=0; k<G ->e; k++) /*输入e条边，建立无向网邻接矩阵*/{ scanf("\n%d,%d,%d",&i,&j,&cost); /*设权值为int型*/G ->edges[i][j]= G ->edges[j][i]=cost;/*对称矩阵*/}(3)建立有向图邻接矩阵算法:提示：参见算法6.1。

数据库实用教程答案(第三版)董健全清华大学出版社之欧阳术创编

数据库实用教程答案(第三版).doc第1、2章1.1名词解释：◆DB：数据库（Database),DB是统一管理的相关数据的集合。

DB能为各种用户共享，具有最小冗余度，数据间联系密切，而又有较高的数据独立性。

◆DBMS：数据库管理系统（Database Management System)，DBMS是位于用户与操作系统之间的一层数据管理软件，为用户或应用程序提供访问DB的方法，包括DB的建立、查询、更新及各种数据控制。

DBMS总是基于某种数据模型，可以分为层次型、网状型、关系型、面向对象型DBMS。

◆DBS：数据库系统（Database System),DBS是实现有组织地、动态地存储大量关联数据，方便多用户访问的计算机软件、硬件和数据资源组成的系统，即采用了数据库技术的计算机系统。

◆1：1联系：如果实体集E1中的每个实体最多只能和实体集E2中的一个实体有联系，反之亦然，好么实体集E1对E2的联系称为“一对一联系”，记为“1：1”。

◆1：N联系：如果实体集E1中每个实体与实体集E2中任意个（零个或多个）实体有联系，而E2中每个实体至多和E1中的一个实体有联系，那么E1对E2的联系是“一对多联系”，记为“1：N”。

◆M：N联系：如果实体集E1中每个实体与实体集E2中任意个（零个或多个）实体有联系，反之亦然，那么E1对E2的联系是“多对多联系”，记为“M：N”。

◆数据模型：表示实体类型及实体类型间联系的模型称为“数据模型”。

它可分为两种类型：概念数据模型和结构数据模型。

◆概念数据模型：它是独门于计算机系统的模型，完全不涉及信息在系统中的表示，只是用来描述某个特定组织所关心的信息结构。

◆结构数据模型：它是直接面向数据库的逻辑结构，是现实世界的第二层抽象。

这类模型涉及到计算机系统和数据库管理系统，所以称为“结构数据模型”。

结构数据模型应包含：数据结构、数据操作、数据完整性约束三部分。

它主要有：层次、网状、关系三种模型。

数据结构c语言版第三版习题解答

数据结构c语言版第三版习题解答数据结构是计算机科学中非常重要的一门学科，它研究如何在计算机中存储和组织数据，以便有效地进行检索和操作。

数据结构的知识对于编写高效的程序和解决复杂的问题至关重要。

在学习和理解数据结构的过程中，解决习题是一种非常有效的方法。

本文将为读者提供《数据结构C语言版（第三版）》习题的解答。

1. 第一章：绪论第一章主要介绍了数据结构的基本概念和内容，包括算法和数据结构的概念、抽象数据类型（ADT）以及算法的评价等。

习题解答中，我们可以通过分析和讨论的方式对这些概念进行加深理解。

2. 第二章：算法分析第二章主要介绍了算法的基本概念和分析方法，包括时间复杂度和空间复杂度的计算方法。

习题解答中，我们可以通过具体的算法实例来计算其时间和空间复杂度，加深对算法分析的理解。

3. 第三章：线性表第三章主要介绍了线性表的概念和实现，包括顺序表和链表两种实现方式。

习题解答中，我们可以通过编写代码实现线性表的基本操作，并分析其时间和空间复杂度。

4. 第四章：栈和队列第四章主要介绍了栈和队列的概念和实现，包括顺序栈、链栈、顺序队列和链队列四种实现方式。

习题解答中，我们可以通过编写代码实现栈和队列的基本操作，并分析其时间和空间复杂度。

5. 第五章：串第五章主要介绍了串的概念和实现，包括顺序串和链串两种实现方式。

习题解答中，我们可以通过编写代码实现串的基本操作，并分析其时间和空间复杂度。

6. 第六章：树第六章主要介绍了树的概念和实现，包括二叉树、哈夫曼树和赫夫曼编码等内容。

习题解答中，我们可以通过编写代码实现树的基本操作，并分析其时间和空间复杂度。

7. 第七章：图第七章主要介绍了图的基本概念和实现，包括图的表示方法和图的遍历算法等。

习题解答中，我们可以通过编写代码实现图的基本操作，并分析其时间和空间复杂度。

8. 第八章：查找第八章主要介绍了查找算法的基本概念和实现，包括顺序查找、二分查找、哈希查找等内容。

数据结构第三版第七章作业参考答案

if (b==NULL) t=NULL;
else { t=(BTNode *)malloc(sizeof(BTNode));
t->data=b->data; t1=Swap(b->lchild); t2=Swap(b->rchild); t->lchild=t2; t->rchild=t1; } return t; }
}
7.7 假设二叉树采用二叉链存储结构，t 指向根结点，p 所指结点为任一给定的结点，设计一个算法，输出从根结点到p 所指结点之间路径。
解：本题可以采用《教程》中例 7.8 的方法（只需对该算法作简单修改即
可
）
。
这
里
介
绍另一种方法，即非递归后序遍历树t（参见《教程》7.4.3 小节后序遍历非
递
归
二叉树树形表示。
答：由《教程》7.6 节的构造算法得到的二叉树的构造过程和二叉树如图 7.3 所示。
b 左:c 右:ed
a 左:cbed 右:hgijf
f 左:hgij 右:空
c 左:空右:空
d
g
左:e
左:h
右:空右:ij
e 左:空右:空
h 左:空右:空
i 左:空右:j
j 左:空右:空
图 7.3 二叉树的构造过程
7.3 设给定权集 w={2,3,4,7,8,9}，试构造关于 w 的一棵哈夫曼树，并求其带权路径长度 WPL。
答：本题的哈夫曼树如图 7.4 所示。
33
18
15
9
97
8
5
4
2
3
图 7.4 一棵哈夫曼树
其带权路径长度WPL=(9+7+8)×2+4×3+(2+3)×4=80。

数据结构实用教程(第三版)课后答案