return 0;
}
double polynomail(int a[],int i,double x,int n)
{
if(i>0) return a[n-i]+polynomail(a,i-1,x,n)*x;
else return a[n];
}
本算法的时间复杂度为o(n)。
第2章线性表
2.1 描述以下三个概念的区别:头指针,头结点,首元结点(第一个元素结点)。
解:头指针是指向链表中第一个结点的指针。首元结点是指链表中存储第一个数据元素的结点。头结点是在首元结点之前附设的一个结点,该结点不存储数据元素,其指针域指向首元结点,其作用主要是为了方便对链表的操作。它可以对空表、非空表以及首元结点的操作进行统一处理。
2.2 填空题。
解:(1) 在顺序表中插入或删除一个元素,需要平均移动表中一半元素,具体移动的元素个数与元素在表中的位置有关。
(2) 顺序表中逻辑上相邻的元素的物理位置必定紧邻。单链表中逻辑上相邻的元素的物理位置不一定紧邻。
(3) 在单链表中,除了首元结点外,任一结点的存储位置由其前驱结点的链域的值指示。
(4) 在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。
2.3 在什么情况下用顺序表比链表好?
解:当线性表的数据元素在物理位置上是连续存储的时候,用顺序表比用链表好,其特点是可以进行随机存取。
2.4 解:
2.5 解:
2.6 解:a. (4) (1)
b. (7) (11) (8) (4) (1)
c. (5) (12)
d. (9) (1) (6)
2.7 解:a. (11) (3) (14)
b. (10) (12) (8) (3) (14)
c. (10) (12) (7) (3) (14)
d. (12) (11) (3) (14)
e. (9) (11) (3) (14)
2.8 解:a. (7) (3) (6) (12)
b. (8) (4) (5) (13)
c. (15) (1) (11) (18)
d. (16) (2) (10) (18)
e. (14) (9) (17)
2.9 解:(1) 如果L的长度不小于2,将L的首元结点变成尾元结点。
(2) 将单循环链表拆成两个单循环链表。
2.10 解:
Status DeleteK(SqList &a,int i,int k)
{
//从顺序存储结构的线性表a中删除第i个元素起的k个元素
//注意i的编号从0开始
int j;
if(i<0||i>a.length-1||k<0||k>a.length-i) return INFEASIBLE;
for(j=0;j<=k;j++)
a.elem[j+i]=a.elem[j+i+k];
a.length=a.length-k;
return OK;
}
2.11 设顺序表va中的数据元素递增有序。试写一算法,将x插入到顺序表的适当位置上,以保持该表的有序性。
解:
Status InsertOrderList(SqList &va,ElemType x)
{
//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法
int i;
if(va.length==va.listsize)return(OVERFLOW);
for(i=va.length;i>0,xva.elem[i]=va.elem[i-1];
va.elem[i]=x;
va.length++;
return OK;
}
2.12
Status CompareOrderList(SqList &A,SqList &B)
{
int i,k,j;
k=A.length>B.length?A.length:B.length;
for(i=0;iif(A.elem[i]>B.elem[i]) j=1;
if(A.elem[i]}
if(A.length>k) j=1;
if(B.length>k) j=-1;
if(A.length==B.length) j=0;
return j;
}
2.13 试写一算法在带头结点的单链表结构上实现线性表操作Locate(L,x);
解:
int LocateElem_L(LinkList &L,ElemType x)
{
int i=0;
LinkList p=L;
while(p&&p->data!=x){
p=p->next;
i++;
}
if(!p) return 0;
else return i;
}
2.14 试写一算法在带头结点的单链表结构上实现线性表操作Length(L)。
解:
//返回单链表的长度
int ListLength_L(LinkList &L)
{
int i=0;
LinkList p=L;
if(p) p=p-next;
while(p){
p=p->next;
i++;
}
return i;
}
2.15解:
void MergeList_L(LinkList &ha,LinkList &hb,LinkList &hc)
{
LinkList pa,pb;
pa=ha;
pb=hb;
while(pa->next&&pb->next){
pa=pa->next;
pb=pb->next;
}
if(!pa->next){
hc=hb;
while(pb->next) pb=pb->next;
pb->next=ha->next;
}
else{
hc=ha;
while(pa->next) pa=pa->next;
pa->next=hb->next;
}
}
2.16 已知指针la和lb分别指向两个无头结点单链表中的首元结点。下列算法是从表la中删除自第i个元素起共len个元素后,将它们插入到表lb中第i个元素之前。试问此算法是否正确?若有错,请改正之。
Status DeleteAndInsertSub(LinkedList la,LinkedList lb,int i,int j,int len)
{
if(i<0||j<0||len<0) return INFEASIBLE;
p=la; k=1;
while(knext; k++; }
q=p;
while(k<=len){ q=q->next; k++; }
s=lb; k=1;
while(knext; k++; }
s->next=p; q->next=s->next;
return OK;
}
解:
Status DeleteAndInsertSub(LinkList &la,LinkList &lb,int i,int j,int len) {
LinkList p,q,s,prev=NULL;
int k=1;
if(i<0||j<0||len<0) return INFEASIBLE;
// 在la表中查找第i个结点
p=la;
while(p&&k
prev=p;
p=p->next;
k++;
}
if(!p)return INFEASIBLE;
// 在la表中查找第i+len-1个结点
q=p; k=1;
while(q&&kq=p->next;
k++;
}
if(!q)return INFEASIBLE;
// 完成删除,注意,i=1的情况需要特殊处理
if(!prev) la=q->next;
else prev->next=q->next;
// 将从la中删除的结点插入到lb中
if(j=1){
q->next=lb;
lb=p;
}
else{
s=lb; k=1;
while(s&&ks=s->next;
k++;
}
if(!s)return INFEASIBLE;
q->next=s->next;
s->next=p; //完成插入
}
return OK;
}
2.19 解:
Status ListDelete_L(LinkList &L,ElemType mink,ElemType maxk)
{
LinkList p,q,prev=NULL;
if(mink>maxk)return ERROR;
p=L;
prev=p;
p=p->next;
while(p&&p->dataif(p->data<=mink){
prev=p;
p=p->next;
}
else{
prev->next=p->next;
q=p;
p=p->next;
free(q);
}
}
return OK;
}
2.20 同2.19题条件,试写一高效的算法,删除表中所有值相同的多余元素(使得操作后的线性表中所有元素的值均不相同),同时释放被删结点空间,并分析你的算法的时间复杂度。
解:
void ListDelete_LSameNode(LinkList &L)
{
LinkList p,q,prev;
p=L;
prev=p;
p=p->next;
while(p){
prev=p;
p=p->next;
if(p&&p->data==prev->data){
prev->next=p->next;
q=p;
p=p->next;
free(q);
}
}
}
2.21
解:
// 顺序表的逆置
Status ListOppose_Sq(SqList &L)
{
int i;
ElemType x;
for(i=0;ix=L.elem[i];
L.elem[i]=L.elem[L.length-1-i];
L.elem[L.length-1-i]=x;
}
return OK;
}
2.22 试写一算法,对单链表实现就地逆置。
解:
// 带头结点的单链表的逆置
Status ListOppose_L(LinkList &L)
{
LinkList p,q;
p=L;
p=p->next;
L->next=NULL;
while(p){
q=p;
p=p->next;
q->next=L->next;
L->next=q;
}
return OK;
}
2.23 解:
// 将合并后的结果放在C表中,并删除B表
Status ListMerge_L(LinkList &A,LinkList &B,LinkList &C) {
LinkList pa,pb,qa,qb;
pa=A->next;
pb=B->next;
C=A;
while(pa&&pb){
qa=pa; qb=pb;
pa=pa->next; pb=pb->next;
qb->next=qa->next;
qa->next=qb;
}
if(!pa)qb->next=pb;
pb=B;
free(pb);
return OK;
}
2.24 解:
// 将合并逆置后的结果放在C表中,并删除B表
Status ListMergeOppose_L(LinkList &A,LinkList &B,LinkList &C) {
LinkList pa,pb,qa,qb;
pa=A;
pb=B;
qa=pa; // 保存pa的前驱指针
qb=pb; // 保存pb的前驱指针
pa=pa->next;
pb=pb->next;
A->next=NULL;
C=A;
while(pa&&pb){
if(pa->datadata){
qa=pa;
pa=pa->next;
qa->next=A->next; //将当前最小结点插入A表表头
A->next=qa;
}
else{
qb=pb;
pb=pb->next;
qb->next=A->next; //将当前最小结点插入A表表头
A->next=qb;
}
}
while(pa){
qa=pa;
pa=pa->next;
qa->next=A->next;
A->next=qa;
}
while(pb){
qb=pb;
pb=pb->next;
qb->next=A->next;
A->next=qb;
}
pb=B;
free(pb);
return OK;
}
2.25解:
// 将A、B求交后的结果放在C表中
Status ListCross_Sq(SqList &A,SqList &B,SqList &C)
{
int i=0,j=0,k=0;
while(iif(A.elem[i]else
if(A.elem[i]>B.elem[j]) j++;
else{
ListInsert_Sq(C,k,A.elem[i]);
i++;
k++;
}
}
return OK;
}
2.26 要求同2.25题。试对单链表编写求C的算法。
解:
// 将A、B求交后的结果放在C表中,并删除B表
Status ListCross_L(LinkList &A,LinkList &B,LinkList &C) {
LinkList pa,pb,qa,qb,pt;
pa=A;
pb=B;
qa=pa; // 保存pa的前驱指针
qb=pb; // 保存pb的前驱指针
pa=pa->next;
pb=pb->next;
C=A;
while(pa&&pb){
if(pa->datadata){
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
else
if(pa->data>pb->data){
pt=pb;
pb=pb->next;
qb->next=pb;
free(pt);
}
else{
qa=pa;
pa=pa->next;
}
}
while(pa){
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
while(pb){
pt=pb;
pb=pb->next;
qb->next=pb;
free(pt);
}
pb=B;
free(pb);
return OK;
}
2.27 解:
(1)
// A、B求交,然后删除相同元素,将结果放在C表中
Status ListCrossDelSame_Sq(SqList &A,SqList &B,SqList &C) {
int i=0,j=0,k=0;
while(iif(A.elem[i]else
if(A.elem[i]>B.elem[j]) j++;
else{
if(C.length==0){
ListInsert_Sq(C,k,A.elem[i]);
k++;
}
else
if(C.elem[C.length-1]!=A.elem[i]){
ListInsert_Sq(C,k,A.elem[i]);
k++;
}
i++;
}
}
return OK;
}
(2)
// A、B求交,然后删除相同元素,将结果放在A表中
Status ListCrossDelSame_Sq(SqList &A,SqList &B)
{
int i=0,j=0,k=0;
while(iif(A.elem[i]else
if(A.elem[i]>B.elem[j]) j++;
else{
if(k==0){
A.elem[k]=A.elem[i];
k++;
}
else
if(A.elem[k]!=A.elem[i]){
A.elem[k]=A.elem[i];
k++;
}
i++;
}
}
A.length=k;
return OK;
}
2.28
解:
(1)
// A、B求交,结果放在C表中,并删除相同元素
Status ListCrossDelSame_L(LinkList &A,LinkList &B,LinkList &C) {
LinkList pa,pb,qa,qb,pt;
pa=A;
pb=B;
qa=pa; // 保存pa的前驱指针
qb=pb; // 保存pb的前驱指针
pa=pa->next;
pb=pb->next;
C=A;
while(pa&&pb){
if(pa->datadata){
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
else
if(pa->data>pb->data){
pt=pb;
pb=pb->next;
qb->next=pb;
free(pt);
}
else{
if(pa->data==qa->data){
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
else{
qa=pa;
pa=pa->next;
}
}
}
while(pa){
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
while(pb){
pt=pb;
pb=pb->next;
qb->next=pb;
free(pt);
}
pb=B;
free(pb);
return OK;
}
(2)
// A、B求交,结果放在A表中,并删除相同元素
Status ListCrossDelSame_L(LinkList &A,LinkList &B) {
LinkList pa,pb,qa,qb,pt;
pa=A;
pb=B;
qa=pa; // 保存pa的前驱指针
qb=pb; // 保存pb的前驱指针
pa=pa->next;
pb=pb->next;
while(pa&&pb){
if(pa->datadata){
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
else
if(pa->data>pb->data){
pt=pb;
pb=pb->next;
qb->next=pb;
free(pt);
}
else{
if(pa->data==qa->data){
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
else{
qa=pa;
pa=pa->next;
}
}
}
while(pa){
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
while(pb){
pt=pb;
pb=pb->next;
qb->next=pb;
free(pt);
}
pb=B;
free(pb);
return OK;
}
2.29 解:
// 在A中删除既在B中出现又在C中出现的元素,结果放在D中
Status ListUnion_Sq(SqList &D,SqList &A,SqList &B,SqList &C)
{
SqList Temp;
InitList_Sq(Temp);
ListCross_L(B,C,Temp);
ListMinus_L(A,Temp,D);
}
2.30 要求同2.29题。试对单链表编写算法,请释放A表中的无用结点空间。
解:
// 在A中删除既在B中出现又在C中出现的元素,并释放B、C
Status ListUnion_L(LinkList &A,LinkList &B,LinkList &C)
{
ListCross_L(B,C);
ListMinus_L(A,B);
}
// 求集合A-B,结果放在A表中,并删除B表
Status ListMinus_L(LinkList &A,LinkList &B)
{
LinkList pa,pb,qa,qb,pt;
pa=A;
pb=B;
qa=pa; // 保存pa的前驱指针
qb=pb; // 保存pb的前驱指针
pa=pa->next;
pb=pb->next;
while(pa&&pb){
if(pb->datadata){
pt=pb;
pb=pb->next;
qb->next=pb;
free(pt);
}
else
if(pb->data>pa->data){
qa=pa;
pa=pa->next;
}
else{
pt=pa;
pa=pa->next;
qa->next=pa;
free(pt);
}
}
while(pb){
pt=pb;
pb=pb->next;
qb->next=pb;
free(pt);
}
pb=B;
free(pb);
return OK;
}
2.31 解:
// 在单循环链表S中删除S的前驱结点
Status ListDelete_CL(LinkList &S)
{
LinkList p,q;
if(S==S->next)return ERROR;
q=S;
p=S->next;
while(p->next!=S){
q=p;
p=p->next;
}
q->next=p->next;
free(p);
return OK;
}
2.32 解:
// 建立一个空的循环链表
Status InitList_DL(DuLinkList &L)
{
L=(DuLinkList)malloc(sizeof(DuLNode));
if(!L) exit(OVERFLOW);
L->pre=NULL;
L->next=L;
return OK;
}
// 向循环链表中插入一个结点
Status ListInsert_DL(DuLinkList &L,ElemType e) {
DuLinkList p;
p=(DuLinkList)malloc(sizeof(DuLNode));
if(!p) return ERROR;
p->data=e;
p->next=L->next;
L->next=p;
return OK;
}
// 将单循环链表改成双向链表
Status ListCirToDu(DuLinkList &L)
{
DuLinkList p,q;
q=L;
p=L->next;
while(p!=L){
p->pre=q;
q=p;
p=p->next;
}
if(p==L) p->pre=q;
return OK;
}
2.33 解:
// 将单链表L划分成3个单循环链表
Status ListDivideInto3CL(LinkList &L,LinkList &s1,LinkList &s2,LinkList &s3)
{
LinkList p,q,pt1,pt2,pt3;
p=L->next;
pt1=s1;
pt2=s2;
pt3=s3;
while(p){
if(p->data>='0' && p->data<='9'){
q=p;
p=p->next;
q->next=pt1->next;
pt1->next=q;
pt1=pt1->next;
}
else
if((p->data>='A' && p->data<='Z') ||
(p->data>='a' && p->data<='z')){
q=p;
p=p->next;
q->next=pt2->next;
pt2->next=q;
pt2=pt2->next;
}
else{
q=p;
p=p->next;
q->next=pt3->next;
pt3->next=q;
pt3=pt3->next;
}
数据结构C语言版(第2版)严蔚敏人民邮电出版社课后习题答案
数据结构(C语言版)(第2版) 课后习题答案 李冬梅 2015.3
目录 第1章绪论 (1) 第2章线性表 (5) 第3章栈和队列 (13) 第4章串、数组和广义表 (26) 第5章树和二叉树 (33) 第6章图 (43) 第7章查找 (54) 第8章排序 (65)
第1章绪论 1.简述下列概念:数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。 答案: 数据:是客观事物的符号表示,指所有能输入到计算机中并被计算机程序处理的符号的总称。如数学计算中用到的整数和实数,文本编辑所用到的字符串,多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。 数据元素:是数据的基本单位,在计算机中通常作为一个整体进行考虑和处理。在有些情况下,数据元素也称为元素、结点、记录等。数据元素用于完整地描述一个对象,如一个学生记录,树中棋盘的一个格局(状态)、图中的一个顶点等。 数据项:是组成数据元素的、有独立含义的、不可分割的最小单位。例如,学生基本信息表中的学号、姓名、性别等都是数据项。 数据对象:是性质相同的数据元素的集合,是数据的一个子集。例如:整数数据对象是集合N={0,±1,±2,…},字母字符数据对象是集合C={‘A’,‘B’,…,‘Z’,‘a’,‘b’,…,‘z’},学生基本信息表也可是一个数据对象。 数据结构:是相互之间存在一种或多种特定关系的数据元素的集合。换句话说,数据结构是带“结构”的数据元素的集合,“结构”就是指数据元素之间存在的关系。 逻辑结构:从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。因此,数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。 存储结构:数据对象在计算机中的存储表示,也称为物理结构。 抽象数据类型:由用户定义的,表示应用问题的数学模型,以及定义在这个模型上的一组操作的总称。具体包括三部分:数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。 2.试举一个数据结构的例子,叙述其逻辑结构和存储结构两方面的含义和相互关系。 答案: 例如有一张学生基本信息表,包括学生的学号、姓名、性别、籍贯、专业等。每个学生基本信息记录对应一个数据元素,学生记录按顺序号排列,形成了学生基本信息记录的线性序列。对于整个表来说,只有一个开始结点(它的前面无记录)和一个终端结点(它的后面无记录),其他的结点则各有一个也只有一个直接前趋和直接后继。学生记录之间的这种关系就确定了学生表的逻辑结构,即线性结构。 这些学生记录在计算机中的存储表示就是存储结构。如果用连续的存储单元(如用数组表示)来存放这些记录,则称为顺序存储结构;如果存储单元不连续,而是随机存放各个记录,然后用指针进行链接,则称为链式存储结构。 即相同的逻辑结构,可以对应不同的存储结构。 3.简述逻辑结构的四种基本关系并画出它们的关系图。
数据结构复习题集答案(c语言版严蔚敏)
人生难得几回搏,此时不搏更待何时? 第1章绪论 1.1 简述下列术语:数据 数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型 解:数据是对客观事物的符号表示 在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称 数据元素是数据的基本单位 在计算机程序常作为一个整体进行考虑和处理 数据对象是性质相同的数据元素的集合 是数据的一个子集 数据结构是相互之间存在一种或多种特定关系的数据元素的集合 存储结构是数据结构在计算机中的表示 数据类型是一个值的集合和定义在这个值集上的一组操作的总称 抽象数据类型是指一个数学模型以及定义在该模型上的一组操作 是对一般数据类型的扩展 1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别 解:抽象数据类型包含一般数据类型的概念 但含义比一般数据类型更广、更抽象 一般数据类型由具体语言系统部定义 直接提供给编程者定义用户数据 因此称它们为预定义数据类型 抽象数据类型通常由编程者定义 包括定义它所使用的数据和在这些数据上所进行的操作 在定义抽象数据类型中的数据部分和操作部分时 要求只定义到数据的逻辑结构和操作说明 不考虑数据的存储结构和操作的具体实现 这样抽象层次更高 更能为其他用户提供良好的使用接口 1.3 设有数据结构(D R) 其中
试按图论中图的画法惯例画出其逻辑结构图 解: 1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义(有理数是其分子、分母均为自然数且分母不为零的分数) 解: ADT Complex{ 数据对象:D={r i|r i为实数} 数据关系:R={} 基本操作: InitComplex(&C re im) 操作结果:构造一个复数C 其实部和虚部分别为re和im DestroyCmoplex(&C) 操作结果:销毁复数C Get(C k &e) 操作结果:用e返回复数C的第k元的值 Put(&C k e) 操作结果:改变复数C的第k元的值为e IsAscending(C) 操作结果:如果复数C的两个元素按升序排列 则返回1 否则返回0 IsDescending(C) 操作结果:如果复数C的两个元素按降序排列 则返回1 否则返回0 Max(C &e) 操作结果:用e返回复数C的两个元素中值较大的一个 Min(C &e) 操作结果:用e返回复数C的两个元素中值较小的一个
数据结构习题集答案(C语言严版)
1.1解:数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。 数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。 数据对象是性质相同的数据元素的集合,是数据的一个子集。 数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 存储结构是数据结构在计算机中的表示。 数据类型是一个值的集合和定义在这个值集上的一组操作的总称。 抽象数据类型是指一个数学模型以及定义在该模型上的一组操作。是对一般数据类型的扩展。 1.2 解:抽象数据类型包含一般数据类型的概念,但含义比一般数据类型更广、更抽象。一般数据类型由具体语言系统内部定义,直接提供给编程者定义用户数据,因此称它们为预定义数据类型。抽象数据类型通常由编程者定义,包括定义它所使用的数据和在这些数据上所进行的操作。在定义抽象数据类型中的数据部分和操作部分时,要求只定义到数据的逻辑结构和操作说明,不考虑数据的存储结构和操作的具体实现,这样抽象层次更高,更能为其他用户提供良好的使用接口。 1.3 解: 1.4 解:ADT Complex{ 数据对象:D={r,i|r,i为实数} 数据关系:R={} 基本操作: InitComplex(&C,re,im) 操作结果:构造一个复数C,其实部和虚部分别为re和im DestroyCmoplex(&C) 操作结果:销毁复数C Get(C,k,&e) 操作结果:用e返回复数C的第k元的值 Put(&C,k,e) 操作结果:改变复数C的第k元的值为e IsAscending(C) 操作结果:如果复数C的两个元素按升序排列,则返回1,否则返回0 IsDescending(C) 操作结果:如果复数C的两个元素按降序排列,则返回1,否则返回0 Max(C,&e) 操作结果:用e返回复数C的两个元素中值较大的一个 Min(C,&e) 操作结果:用e返回复数C的两个元素中值较小的一个 }ADT Complex ADT RationalNumber{ 数据对象:D={s,m|s,m为自然数,且m不为0} 数据关系:R={} 基本操作: InitRationalNumber(&R,s,m) 操作结果:构造一个有理数R,其分子和分母分别为s和m DestroyRationalNumber(&R)
数据结构(c语言版)严蔚敏
第一章概论 1.数据:信息的载体,能被计算机识别、存储和加工处理。 2.数据元素:数据的基本单位,可由若干个数据项组成,数据项是具有独立含义的最小标识单位。 3.数据结构:数据之间的相互关系,即数据的组织形式。 它包括:1)数据的逻辑结构,从逻辑关系上描述数据,与数据存储无关,独立于计算机; 2)数据的存储结构,是逻辑结构用计算机语言的实现,依赖于计算机语言。 3)数据的运算,定义在逻辑结构上,每种逻辑结构都有一个运算集合。常用的运算:检索/插入/删除/更新/排序。 4.数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。数据的存储结构是逻辑结构用计算机语言的实现。 5.数据类型:一个值的集合及在值上定义的一组操作的总称。分为:原子类型和结构类型。 6.抽象数据类型:抽象数据的组织和与之相关的操作。优点:将数据和操作封装在一起实现了信息隐藏。 7. 抽象数据类型ADT:是在概念层上描述问题;类:是在实现层上描述问题;在应用层上操作对象(类的实例)解决问题。 8.数据的逻辑结构,简称为数据结构,有: (1)线性结构,若结构是非空集则仅有一个开始和终端结点,并且所有结点最多只有一个直接前趋和后继。 (2)非线性结构,一个结点可能有多个直接前趋和后继。 9.数据的存储结构有: 1)顺序存储,把逻辑相邻的结点存储在物理上相邻的存储单元内。 2)链接存储,结点间的逻辑关系由附加指针字段表示。 3)索引存储,存储结点信息的同时,建立附加索引表,有稠密索引和稀疏索引。 4)散列存储,按结点的关键字直接计算出存储地址。 10.评价算法的好坏是:算法是正确的;执行算法所耗的时间;执行算法的存储空间(辅助存储空间);易于理解、编码、调试。
严蔚敏版数据结构(c语言版)参考答案
第十章内部排序 10.23 void Insert_Sort1(SqList &L)//监视哨设在高下标端的插入排序算法{ k=L.length; for(i=k-1;i;--i) //从后向前逐个插入排序 if(L.r[i].key>L.r[i+1].key) { L.r[k+1].key=L.r[i].key; //监视哨 for(j=i+1;L.r[j].key>L.r[i].key;++j) L.r[j-1].key=L.r[j].key; //前移 L.r[j-1].key=L.r[k+1].key; //插入 } }//Insert_Sort1 10.24 void BiInsert_Sort(SqList &L)//二路插入排序的算法 { int d[MAXSIZE]; //辅助存储 x=L.r.key;d=x; first=1;final=1; for(i=2;i<=L.length;i++) { if(L.r[i].key>=x) //插入前部 {
for(j=final;d[j]>L.r[i].key;j--) d[j+1]=d[j]; d[j+1]=L.r[i].key; final++; } else //插入后部 { for(j=first;d[j]严蔚敏数据结构题集(C语言版)完整
严蔚敏 数据结构C 语言版答案详解 第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={} 基本操作: InitComplex(&C,re,im) 操作结果:构造一个复数C ,其实部和虚部分别为re 和im DestroyCmoplex(&C) 操作结果:销毁复数C Get(C,k,&e) 操作结果:用e 返回复数C 的第k 元的值 Put(&C,k,e) 操作结果:改变复数C 的第k 元的值为e
数据结构(C语言版)严蔚敏课后习题答案
数据结构(C语言版)严蔚敏 第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={} 基本操作: InitComplex(&C,re,im) 操作结果:构造一个复数C ,其实部和虚部分别为re 和im
数据结构c语言版复习
数据结构c语言版复习公司内部档案编码:[OPPTR-OPPT28-OPPTL98-OPPNN08]
数据结构复习资料 一、填空题 1. 数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和运算等的学科。 2. 数据结构被形式地定义为(D, R),其中D是数据元素的有限集合,R是D上的关系有限集合。 3. 数据结构包括数据的逻辑结构、数据的存储结构和数据的运算这三个方面的内容。 4. 数据结构按逻辑结构可分为两大类,它们分别是线性结构和非线性结构。 5. 线性结构中元素之间存在一对一关系,树形结构中元素之间存在一对多关系,图形结构中元素之间存在多对多关系。 6.在线性结构中,第一个结点没有前驱结点,其余每个结点有且只有 1个前驱结点;最后一个结点没有后续结点,其余每个结点有且只有1个后续结点。 7. 在树形结构中,树根结点没有前驱结点,其余每个结点有且只有1个前驱结点;叶子结点没有后续结点,其余每个结点的后续结点数可以任意多个。 8. 在图形结构中,每个结点的前驱结点数和后续结点数可以任意多个。 9.数据的存储结构可用四种基本的存储方法表示,它们分别是顺序、链式、 索引和散列。 10. 数据的运算最常用的有5种,它们分别是插入、删除、修改、查找、排序。 11. 一个算法的效率可分为时间效率和空间效率。 12. 在顺序表中插入或删除一个元素,需要平均移动表中一半元素,具体移动的元素个数与表长和该元素在表中的位置有关。 13. 线性表中结点的集合是有限的,结点间的关系是一对一的。
14. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时,需向后移动n-i+1 个元素。 15. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时,需向前移动n-i 个元素。 16. 在顺序表中访问任意一结点的时间复杂度均为 O(1),因此,顺序表也称为 随机存取的数据结构。 17. 顺序表中逻辑上相邻的元素的物理位置必定相邻。单链表中逻辑上相邻的元素的物理位置不一定相邻。 18.在单链表中,除了首元结点外,任一结点的存储位置由其直接前驱结点的链域的值指示。 19.在n个结点的单链表中要删除已知结点*p,需找到它的前驱结点的地址,其时间复杂度为O(n)。 20. 向量、栈和队列都是线性结构,可以在向量的任何位置插入和删除元素;对于栈只能在栈顶插入和删除元素;对于队列只能在队尾插入和队首删除元素。 21. 栈是一种特殊的线性表,允许插入和删除运算的一端称为栈顶。不允许插入和删除运算的一端称为栈底。 22. 队列是被限定为只能在表的一端进行插入运算,在表的另一端进行删除运算的线性表。 23. 不包含任何字符(长度为0)的串称为空串;由一个或多个空格(仅由空格符)组成的串称为空白串。 24. 子串的定位运算称为串的模式匹配;被匹配的主串称为目标串,子串 称为模式。 25. 假设有二维数组A 6×8 ,每个元素用相邻的6个字节存储,存储器按字节编址。已知A的起始存储位置(基地址)为1000,则数组A的体积(存储量)为 288 B ;末尾元素A 57的第一个字节地址为 1282 ;若按行存储时,元素A 14 的第 一个字节地址为 (8+4)×6+1000=1072 ;若按列存储时,元素A 47 的第一个字节地址为 (6×7+4)×6+1000)=1276 。 26.由3个结点所构成的二叉树有5种形态。
严蔚敏数据结构(C语言版)知识点总结笔记课后答案
第1章绪论 1.1复习笔记 一、数据结构的定义 数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等的学科。 二、基本概念和术语 数据 数据(data)是对客观事物的符号表示,在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称,它是计算机程序加工的“原料”。 2.数据元素 数据元素(data element)是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。 3.数据对象 数据对象(data object)是性质相同的数据元素的集合,是数据的一个子集。 4.数据结构 数据结构(data structure)是相互之间存在一种或多种特定关系的数据元素的集合。 (1)数据结构的基本结构 根据数据元素之间关系的不同特性,通常有下列四类基本结构: ① 集合。数据元素之间除了“同属于一个集合”的关系外,别无其它关系。 ② 线性结构。数据元素之间存在一个对一个的关系。 ③ 树形结构。数据元素之间存在一个对多个的关系。 ④ 图状结构或网状结构。数据元素之间存在多个对多个的关系。
如图1-1所示为上述四类基本结构的关系图。 图1-1 四类基本结构的关系图 (2)数据结构的形式定义 数据结构的形式定义为:数据结构是一个二元组Data_Structure==(D,S) 其中:D表示数据元素的有限集,S表示D上关系的有限集。 (3)数据结构在计算机中的表示 数据结构在计算机中的表示(又称映象)称为数据的物理结构,又称存储结构。它包括数据元素的表示和关系的表示。 ① 元素的表示。计算机数据元素用一个由若干位组合起来形成的一个位串表示。 ② 关系的表示。计算机中数据元素之间的关系有两种不同的表示方法:顺序映象和非顺序映象。并由这两种不同的表示方法得到两种不同的存储结构:顺序存储结构和链式存储结构。 a.顺序映象的特点是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系。 b.非顺序映象的特点是借助指示元素存储地址的指针(pointer)表示数据元素之间的逻辑关系。 5.数据类型 数据类型(Data type)是一个值的集合和定义在这个值集上的一组操作的总称。按“值”的不同特性,高级程序语言中的数据类型可分为两类:一类是非结构的原子类型,值是不可分解的;另一类是结构类型,值是由若干成分按某种结构