数据结构1-4章习题答案
第一章绪论
一、选择题
1.D
2.C
3.C
4.B
5.D
6.C
7.D
8.C
9.A 10.D
11.D 12.B
二、填空题
1. 逻辑结构存储结构运算
2. 集合结构线性结构树形结构图状结构
3. 有穷性. 确定性. 可行性. 输入. 输出
4. 顺序存储. 链式存储
5. 数据元素
6. 线性结构非线性结构
三、简答题
1. 尽管算法的含义与程序非常相似，但两者还是有区别的。首先，一个程序不一定满
有穷性，因为它不是一个算法。其次，程序中的指令必须是计算机可以执行的，而
算法中的指令却无此限制。如果一个算法采用机器可执行的语言来书写，那么它就
是一个程序。
2. 数据结构是指数据对象以及该数据对象集合中的数据元素之间的相互关系（数据元
素的组织形式）。例如：队列的逻辑结构是线性表（先进后出）；队列在计算机中
既可以采用顺序存储也可以采用链式存储；队列可进行删除数据元素. 插入数据元
素. 判断是否为空队列，以及队列置空等操作。
3. 数据元素之间的逻辑关系，也称为数据的逻辑结构。数据元素以及它们之间的相互
关系在计算机存储器内的表示（又称映像）称为数据的存储结构，也称数据的物理
结构。
4. 算法是对特定问题求解步骤的一种描述，它是指令的有限序列，其中每一条指令表
示一个或者多个操作。此外，一个算法还具有下列5个特性：
（1）有穷性：一个算法必须在执行有穷步之后结束，即算法必须在有限时间内完
成。
（2）确定性：算法中每一步必须有明确的含义，不会产生二义性。并且，在任何
条件下，算法只有唯一的一条执行路径，即对于相同的输入只能得出相同的输出。
（3）可行性：一个算法是能执行的，即算法中的每一步都可以通过已经实现的基
本运算执行有限次得以实现。
（4）输入：一个算法有零个或者多个输入，它们是算法开始时对算法给出的初始
量。
（5）输出：一个算法有一个或者多个输出，它们是与输入有特定关系的量
5. 举例说明四种基本结构的区别:
集合: 数据元素之间无任何关系,如集合A={x,5,t,&};
线性结构: 数据元素之间存在一个对一个的关系,如线性表L=（2,3，4,5,7,10）；
树形结构: 数据元素之间存在一个对多个的关系,如文件系统目录管理；
图状结构: 数据元素之间存在多个对多个的关系,如教学计划课程安排顺序图。
四. 算法设计题
1. 执行时间为O（n）
2. 执行时间为O（n3）
3. 时间复杂度为O（log n）。
第二章线性表
一、选择题
1.B
2.A
3.B
4.A
5.C
6.D
7.A
8.C
9.C 10.B
11.A 12.D 13.C 14.A 15.B
16.C 17.A 18.A
二、填空题
1. 没有，1，没有，1
2. 长度，空表
3. 移动
4. 顺序存储结构，链式存储结构
5. 顺序表，链表
6. 移动，指针域
7. 移动，前一个
8. 头指针，指针域（链域）
9. p->next->next
10. p->next，q
11. 链式
12. 不相同
13. 直接前驱，直接后继
14. 运算（或操作）
三、简答题
1. 非空线性表的结构特征为：
①有且只有一个称“第一个结点” a1 ,它无前驱；
②有且只有一个称“最后结点” a n ,它无后继；
③除以上结点外，其余结点均有一个直接前驱和一个直接后继。
2. 线性表的顺序存储结构具有如下两个基本特点：
①线性表中所有元素所占的存储空间是连续的；
②线性表中各数据元素在存储空间中是按逻辑顺序依次存放的。
3. 用一维数组存放线性表时，应注意数组的基本类型，要与线性表中数据元素的类
型相同，而且该一维数组的长度，通常要定义得比线性表的实际长度大一些，以
便对线性表进行各种运算。
4. 线性表顺序存储结构的优点是：简单，存储密度大，空间利用率高，对表中任意
元素可直接确定其存储地址，随机访问存取效率高。
线性表顺序存储结构的缺点是：在顺序表中进行插入与删除操作时，需大量移动数
据元素，时间开销大；再者，在顺序存储结构下，线性表的长度估计困难，并且当
有多个顺序表同时共享计算机的存储空间时，不便于对存储空间进行动态分配。
5. 假设数据结构中的每一个数据结点对应于一个存储单元，这种存储单元称为存储结
点，简称结点。若每个结点由两部分组成：一部分用于存放数据元素值，称为数据
域；另一部分用于存放指针，称为指针域。其中指针用于指向该结点的前一个或后
一个结点（即前驱或后继）。通过每个结点的指针域，将n个结点按其逻辑顺序连
接在一起而构成的数据存储结构，称为链式存储结构。
6.（1）开始结点（首结点）：是指链表中的存储线性表中第一个数据元素a1的结点。
（2）头结点：为了操作方便，通常在链表的开始结点之前附加上一个结点，
称为头结点。一般情况下，头结点的数据域中不存储信息。附设头结点的作用是为
了对链表进行操作时更方便，可以对空表，非空表的情况以及对开始结点进行统一
的处理。
（3）头指针：是指向链表中的第一个结点（可以是头结点，也可以是开始结点）的
指针。若链表中附设了头结点，则不管线性表是否为空，头指针均不为空；若链表
中不设头结点，则线性表为空时，链表的头指针为空。
以上三个概念，对于单链表，循环链表和双向链表都适用。
7. 在单循环链表中，设置尾指针，可以更方便地判断链表是否为空。
8. 算法的功能是把单链表的第一个结点变成末尾结点。返回的L指向原链表的第二个
结点。若原链表表示的线性表是（a1,a2,a3,a4......a n），则操作后表示的线性表
为（a2,a3,a4......a n,a1）。
9. 由于向量中的元素按元素非递减有序排列，值相同的元素必为相邻的元素，因此依
次比较相邻两个元素，若值相等，则删除其中一个，否则继续向后查询。故算法功
能是删除向量中多余的值相同的元素。
10.（1）单链表：当知道指针p指向某结点时，能够根据该指针找到其直接后继，
但是不知道头指针，因此不能找到该结点的直接前驱，故无法删除该结点。
（2）双链表：根据指针p可以找到该结点的直接前驱和直接后继，因此，能够删
除该结点。
（3）单循环链表：和双链表类似，根据指针p也可以找到该结点的直接前驱和直
接后继，因此也可以删除该结点。
四、算法设计题
1.【算法】
void InsertInList(SequenList *L,DataType x)
{
int i;
for(i=0;i Insert(L,i+1,x); /*调用顺序表插入算法*/ } 2.【算法】 LinkList *LinkTueList(LinkList *L1,LinkList *L2) { /*将两个单链表链接在一起*/ LinkList *p,*q; p=L1;q=L2; while(p->next)p=p->next; /*查找终端结点*/ p->next=q->next; free(q); return(L1); /*将L2的开始结点链接在L1之后*/ } 【时间复杂度分析】 因为本算法的主要操作时间花费在查找L1的终端结点上，与L2的长度无关，所 以本算法的时间复杂度为O（m）。 3.【算法】 LinkList *JiaoJi(LinkList *A, LinkList *B) { LinkList *q,*p,*r,*s,*C; C = NULL; r = C; P = A; q = B; while (p&&q) if(p->data else if(p->data==q->data) { s= (LinkList *)malloc(sizeof(LinkList)); s->data=p->data; if(r!=NULL) r->next=s; else C=s; r=s; p=p->next; q=q->next; } else q=q->next; r->next=NULL; return( C ); } 4.【算法】 void ShanChu(LinkList *L,int min,int max) /*设L为带头结点的单链表*/ { LinkList *p,*q,*s,*k; s=L; p=s->next; while(p!=NULL&&p->data>=max) {s=p;p=p->next;} /*p指向第一个值小于max的结点，s指向其前驱*/ if(p!=NULL) { q=p; while(q!=NULL&&q->data>=min) /*q继续下移 */ p=p->next; /* q指向第一个值不大于min的结点*/ s->next=q; /* 删除结点后的链接 */ k=p->next; while(k!=q) /* 删除p结点到 q 结点之间的所有结点 */ { free(p); p=k; k=p->next;} } } 【时间复杂度分析】 前两个while循环和起来最多循环n次，第三个while循环最多循环n次，即删 除n个结点，故算法的时间复杂度为O（n）。 5.【算法】 LinkList *CharFen(LinkList *A) { LinkList *B,*p; /* p 指向A 表中序号为偶数的元素 */ LinkList *ra, *rb; /* ra和rb将分别指向将创建的A表和B表的尾结点 */ B=(LinkList *)malloc(sizeof(LinkList)); /* 创建B表头结点 */ B->next=NULL; /* B表置空 */ ra=A->next; rb=B; p=ra->next; /* p为工作指针，指向待分解的结点 */ while(p!=NULL&&ra!=NULL) { ra->next=p->next; /* 做A表链接 */ ra=p->next; rb->next=p; rb=p; /* p结点链接到B表的表尾，rb指向新的尾结点*/ p=ra->next; /* 将p恢复为指向新的待处理结点 */ } return(B); } 6.【算法】 void Rearrange(SequenList L) /* 本算法利用快速排序的划分重排线性表 */ { int i,j; /* i,j为工作指针（下标），初始指向线性表a的两端 */ int t; i=0; j=Length(L)-1; while(i { while(i if(i L->data[i]=L->data[j]; L->data[j]=t; i++; } /* 将负数前移 */ while(i if(i L->data[i]=L->data[j]; L->data[j]=t; j--; } /* 将正数后移 */ } } 7.【算法】 void Delete_min(LinkList *L) /* L是带头结点的单链表 */ { LinkList *p, *pre, *q; p=L->next; /* p为工作指针。指向待处理的结点 */ pre=L; /* pre指向最小值结点q的直接前驱结点 */ q=p; /* q指向最小值结点，初始假定第一元素结点为最小值结点 */ while(p->next!=NULL) {if(p->next->data p=p->next; /* 指针后移 */ } pre->next=q->next; /* 从链表上删除最小值结点q */ free(q); /* 释放最小值结点所占空间 */ } 8.【算法】 void DelInsert(LinkList *list) { LinkList *p, *pre, *q; p=list->next; /* p为工作指针。指向待处理的结点 */ pre=list; /* pre指向最小值结点q的直接前驱结点 */ q=p; /* q指向最小值结点，初始假定第一元素结点为最小值结点 */ while(p->next!=NULL) {if(p->next->data p=p->next; /* 指针后移 */ } if(q!=list->next) { pre->next=q->next; /* 从原链表上删除最小值结点q */ q->next=list->next; /* 将q 结点插入到链表最前面 */ list->next=q; } } 9.【算法】 void MiniValue(LinkedList *L) /* 设L为带头结点的单链表 */ { LinkList *p, *pre; int t; p=L->next; pre=p; while (p->next!=NULL) { if(p->next->data p=p->next; } printf("最小值＝%d\n", pre->data); if(pre->data%2!=0) /* 处理奇数情况 */ if(pre->next!=NULL) /* 若该结点没有后继，则不必交换 */ { t=pre->data;pre->data=pre->next->data; pre->next->data=t; } else /* 处理偶数情况 */ if(pre->next!=NULL) /* 若最小值结点是最后一个结点，则无删除 */ { p=pre->next;pre->next=p->next;free(p); } } 10.【算法】 void SearchExchangeInsert(SequenList L; DataType x) { int low,high,mid; DataType y; low=0; high=Length(L)-1; /* low和high指向线性表下界和上界的下标 */ while (low<=high) { mid=(low+high)/2; /* 找中间位置 */ if(L->data[mid]==x) break; /* 找到x，退出while循环 */ else if (L->data[mid] else high=mid-1; /* 到中点mid的左部去查 */ } if(L->data[mid]==x&&mid!=Length(L)-1) /* 若x是最后元素，则不交换 */ { y=L-data[mid]; L->data[mid]=L->data[mid+1]; L->data[mid+1]=y;} /* 数值x与其后继位置元素交换 */ if(low>high) /* 查找失败，插入数据元素x */ { for(i=Length(L)-1; i>=low; i--) L->data[i+1]=L->data[i]; /* 后移元素 */ L->data[low]=x; /* 插入x */ } } 11.【算法】 void Reverse(LinkList *L) { LinkList *p, *q, *r; p=L->next; r=L; while(p!=NULL) { q=p->next; /* 保存剩余链表的指针 */ r->next=p; /* 用头插法建表 */ if(r==L) p->next=NULL; /* 表尾结点next为空 */ r=p; p=q; } } 12.【算法】 void Delete_x_pro(LinkList *L, DataType x) /* L是带头结点的单链表 */ { LinkList *p, *pre, *q; p=L->next; /* p为工作指针。指向待处理的结点 */ if(p->data==x) { printf("第一个结点，无前驱\n"); exit(0); } pre=p; /* pre指向x结点的直接前驱结点 */ q=L; /* q指向pre结点的直接前驱结点 */ p=p->next; while(p!=NULL) if(p->data!=x) {q=pre; pre=p; p=p->next; } /* 查值为x的结点 */ else break; /* 找到退出 */ if(p!=NULL) { q->next=p; /* 从链表上删除pre所指结点 */ free(pre); /* 释放pre结点所占空间 */ } } 13.【算法】 intd PD_Sort(SequenList L) /* 判断顺序表是否有序 */ { int i,flag=1; /* 标志flag=0 表示无序，flag=1表示有序*/ for(i=0; i if(L->data[i]<=L->data[i+1]) ; else {flag=0; break;} return(flag); for(i=0; i if(L->data[i]>=L->data[i+1]) ; else {flag=0; break;} return(flag); } 14.【算法】 void Sort(LinkList *L) { LinkList *p, *q, *r, *pre; pre=L; r=L-next; p=r->next; /* p为工作指针。指向待处理的结点 */ r->next=NULL; while(p!=NULL) { q=p->next; /* 保存剩余链表的指针 */ pre=L; r=L-next; /* p结点插入到pre与r结点之间 */ while(r!=NULL&&r->data { pre=r; r=r->next; } if(r!=NULL) { p->next=r; pre->next=p; } else { pre->next=p; p->next=NULL; } p=q; } } 15.【算法】 void Print(DLinkList *L) /* L为带头结点的双向链表 */ { DLinkList *p; p=L->next; while(p->next!=NULL) p=p->next; while(p!=L) { printf("%d\n",p->data); p=p->prior; } } 16.【算法】 typedef struct pnode { float codf; /* 系数域 */ int exp; /* 指数域 */ struct pnode *next; /* 指针域 */ } PolyNode; flaot Value(PolyNode *L, float x) /* L为带头结点的单循环链表 */ { float sum=0,t; int i; PolyNode *p; p=L->next; while(p!=L) { t=1; for(i=0;i t*=x; sum+=p->coef*t; } return(sum); } 17. 【算法】 typedef int DataType; /* DataType代表数据元素类型 */ typedef struct dnode { DataType data; /* data用来存放数据元素的信息 */ struct dnode *prior,*next; /* prior存放其直接前驱的地址 */ } DNode; /* next存放其直接后继的地址 */ （1）向双向循环链表的末尾插入一个值为x的结点 void InsertRear(DNode *DL,DataType x) { DNode *ptr; ptr=(DNode *)malloc(sizeof(DNode)); /* 建立值为x的结点 */ ptr->data=x; ptr->prior=DL->prior; ptr->next=DL; DL->prior->next=ptr; DL->prior=ptr; } （2）从双向循环链表中删除值为x的结点 void Delete_x(DNode *DL, DataType x) { DNode *p; p=DL->next; while(p!=DL) if(p->data==x) break; else p=p->next; } if(p!=DL) /* 删除值为x的结点 */ { p->prior->next=p->next; p->next->prior=p->prior; free(p); } } （3）向双向循环链表的第i个结点位置插入一个值为x的结点。 void Insert(DNode *DL, int i, DataType x) { DNode *p, *ptr; int j=1; if(i<=0) { printf(“i is out range!”); exit(0); } p=DL->next; while(p!=DL && j { p=p->next; j++; } if(p!=DL) { ptr=(DNode *)malloc(sizeof(DNode)); /* 建立值为x的结点 */ ptr->data=x; ptr->prior=p->prior; ptr->next=p; p->prior->next=ptr; p->prior=ptr; } } 第三章栈 一、选择题 1.D 2.A 3.C 4.A 5.B 6.C 7.B 8.B 9.D 10.A 11.C 12.D 13.C 二、填空题 1. 栈顶，栈底 2. 进栈（或入栈），退栈（或出栈） 3. 0，Max 4. 栈顶元素，栈顶指针 5. -1，N-1 6. top->next 7. 6，1 8. 线性表，后进先出，LIFO表 9. 是否栈满 10. 是否栈空 11. 顺序栈 12 栈 三、简答题 1. 栈(stack ) 是限定在一端进行插入与删除的线性表。 栈是按照“先进后出”（FILO，First in Last Out）或“后进先出”（LIFO，Last in First Out）的原则组织数据的。 2. 栈是一种线性表，采用顺序存储方式存储的栈，称为顺序栈；而采用链式存储方式 存储的栈，称为链式栈。 3. 在顺序栈的栈顶插入一个元素时，首先将栈顶指针s->top 加１，以指示新的栈顶 位置，然后将新元素插入到栈顶指针指向的位置。 4. 在链栈中插入一个元素时，首先申请一个结点s，将插入元素放入s的数据域中； 再将原栈顶指针存入s的指针域中，最后将s存入到栈顶指针中。 5. 因为链栈是运算受限制的单链表，其插入和删除操作都限制在表头位置上进行，由 于只能在链表头部进行操作，故链栈不需要设置头结点。 6. 本题利用栈的“后进先出”的特点，有如下几种情况： A进. A出. B进. B出. C进. C出，产生输出序列ABC A进. A出. B进. C进. C出. B出，产生输出序列ACB A进. B进. B出. A出. C进. C出，产生输出序列BAC A进. B进. B出. C进. C出. A出，产生输出序列BCA A进. B进. C进. C出. B出. A出，产生输出序列 CBA 不可能产生输出序列CAB。 7. 可能的次序有CDBAE、CDEBA、CDBEA。 8. 高级语言变量名的定义规则是：以字母开头的字母数字串。入栈次序为123PA，以 A最先出栈的序列为AP321，以P最先出栈的序列为P321A、P32A1、P3A21、PA321。 可以作为高级语言的变量名的序列为AP321、P321A、P32A1、P3A21和PA321。 9. （1）能得到输出顺序为325641的序列，其操作序列为：SSSPPSSPSPPP。 （2）不能得到输出顺序为154623的序列；执行SPSSSSPPSP，得到输出序列1546 后，栈中元素从栈顶到栈底为32，不能让2先出栈，所以得不到输出序列154623。 10. 生活中栈的应用：教师批改作业，食堂里的一叠盘子等。 四、算法设计题 1. 【算法】 int judge(LinkList *head) /* head为不带头结点单链表 */ { SeqStack s; int i=1; LinkList *p; s->top=-1; p=head; while(p!=NULL) /* 链表结点进栈 */ { s->top++; s->data[s->top]=p->data; p=p->next; } p=head; while(p!=NULL) /* 依次出栈与链表结点比较 */ if(p->data==s->data[s->top]) { p=p->next; top--; } else { i=0; break; } return i; ) 2. 【算法】 void Reverse(LinkList *L) /* L为带头结点单链表 */ { LinkList *p, *q; DataType y; LinkStack *S; /* 定义一个不带头节点的链栈 */ p=L->next; S=InitStack(); while(p!=NULL) /* 将p所指节点进栈 */ { S=Push(S, p->data); p=p->next; } p=L->next; /* p再一次指向表的第一个结点 */ while (p!=NULL) //出栈所有节点 { S=Pop(S, &y); p->data=y; p=p->next; } } 3. 【算法】 void Shuchu_M(LinkList *L,int M) /* L为带头结点有序单链表 */ { LinkList *p, *q; DataType y; int n=1; LinkStack *S; /* 定义一个不带头节点的链栈 */ p=L->next; S=InitStack(); while(p!=NULL) /* 将p所指节点进栈 */ { if(p->data>M) S=Push(S, p->data); p=p->next; } while (!EmptyStack(S)) /* 输出栈中所有结点 */ { S=Pop(S, &y); printf("第%d 名：%d\n",n, y); n++; } } 4. 【算法】 DataType GetBottom(SeqStack st) /* st为顺序栈 */ { DataType e,y; SeqStack tmp; /* 定义临时栈tmp */ InitStack(tmp); /* 初始化临时栈 */ while (!EmptyStack (st)) /* 临时栈tmp中存放st栈中的逆转元素 */ { e=Pop(st); Push(tmp,e); } y=GetTop(tmp); while (!StackEmpty(tmp)) /* 恢复st栈中原来的内容 */ { e=Pop(tmp); Push(st,e); } return y; /* 返回st栈的栈底元素 */ } 5. 【算法】 void ReverseDisp(LinkList *L) /* L为带头结点单链表 */ { DataType y; SeqStack S; /* 定义一个顺序栈S */ LinkList *p; p=L->next; InitStack(S); while (p!=NULL) /* 遍历单链表，将所有元素进栈 */ { Push(S, p->data); p=p->next; } while (!EmptyStack(S)) /* 输出栈中所有结点 */ { y=Pop(S); printf("%d\n", y); } } 6. 【算法】 /* L为带头结点单链表 */ LinkList *InitStack1() /* 置空栈 */ { LinkList *L; L=(LinkList *)malloc(sizeof(LinkList)); L->next=NULL; return（L）; } int EmptyStack1(LinkList *L) /* ----判断栈空-- */ { if(L->next==NULL) return(1); else return(0); } void Push1(LinkList *L, DataType x) /* ---进栈--- */ { LinkList *p; p=(LinkList *)malloc(sizeof(LinkList)); p->data=x; p->next=L->next; /* 插入p结点作为第一个数据元素 */ L->next=p; } DataType Pop1(LinkList *L) /* ---出栈--- */ { LinkList *p; DataType y; if(L->next==NULL) /* 栈空的情况 */ { printf("\n链栈是空的!"); exit(0); } p=L->next; /* p指向第一个数据结点 */ y=p->data; L->next=p->next; free(p); return(y); } 7. 【算法】 #define MAX 1000 int stack[MAX]; /* 定义全局数组模拟一个栈 */ #define length 5 /* 定义栈结点大小 */ int Top; /* 栈顶指针 */ void Push2(DataType x[]) /* 进栈 */ { int i; for(i=0; i stack[Top+i+1]=x[i]; Top+=length; } void Pop2(DataType y[]) /* 出栈 */ { int i; Top-=length; for(i=0; i y[i]=stack[Top+i+1]; } 8. 【算法】 递归算法: int akm(int m,int n) { int y; if(m==0) y=n+1; else if(n==0) y=akm(m-1,1); else y=akm(m-1,akm(m,n-1); return y; } 非递归算法: int akm1(int m, int n) { int top,s1[MAX],s2[MAX]; /* 定义两个数组栈 */ int r; top=0;s1[top]=m;s2[top]=n; /* 初始栈，并压入第一个元素 */ do{ while(s1[top]){ /* s1栈顶元素非空将循环 */ while(s2[top]){ /* s2栈顶元素非空将循环 */ top++;s1[top]=s1[top-1]; s2[top]=s2[top-1]-1; } s1[top]--;s2[top]=1; } if(top>0){ top--;s1[top]--; s2[top]=s2[top+1]+1; } }while(top!=0||s1[top]!=0); /* 栈空或栈顶元素为空退出循环 */ r=s2[top]+1; /* 取出栈顶元素 */ top--; return r; /* 返回 */ } 9. 【算法】 void Conver( int N ) { int x; LinkStack *S; S=InitStack(); while( N) { x=N%16; S=Push(S , x); N /= 16 ; } printf("转换后的16进制数值为：" ); while( !EmptyStack(S)) { S=Pop( S, &x); switch(x) { case 10: printf("a");break; case 11: printf("b");break; case 12: printf("c");break; case 13: printf("d");break; case 14: printf("e");break; case 15: printf("f");break; default : printf("%d",x); } } } 10. 【算法】 char Proceed(char x1,char x2) /* 优先级比较算法 */ { char r,m[2]; r=’<’; m[0]=x2; m[1]=0; if((((x1==’+’||x1==’-’)&&strstr(“+-)#”,m)!=NULL)|| ((x1==’*’||x1==’/’)&&strstr(“+-*/)#”,m)!=NULL)|| (x1==’)’&&strstr(“+-*/)#”,m)!=NULL)) r=’>’; ese if((x1==’(‘&&x2==’)’)||(x1==’#’&&x2==’#’)) r=’=’; else if((x1==’(‘&&x2==’#’)||(x1==’)’&&x2=’(’)) r=’’; return(r); } int Postfix(SeqStack *S, char *E) /* 表达式转换算法 */ { char x1,x2,x; int j=0; S->data[0]=’#’; S->top=0; x2=E[j]; if((x1=GetTop(S))==NULL) exit(0); while(1) { if(x2!=’+’&& x2!=’-’&& x2!=’*’&& x2!=’/’&& x2!=’(’&& x2!=’)’&& x2!=’#’) { printf("%c",x2); x2=E[++j]; } else if(Proceed(x1,x2)==’<’) { if(!Push(S,x2)) exit(0); if((x1=GetTop(S))==NULL) exit(0); x2=E[++j]; } else if(Proceed(x1,x2)==’>’) { if((x=Pop(S))==NULL) exit(0); printf("%c",x); if((x1=GetTop(S)==NULL) exit(0); } else if(Proceed(x1,x2)==’=’&& x1=’(‘&& x2==’)’) { if(Pop(S)==NILL) exit(0); if(( x1=GetTop(S))==NULL) exit(0); x2=E[++j]; } else if(Proceed(x1,x2)==’=’&& x1=’#‘&& x2==’#’) return(1); else if(Proceed(x1,x2)==’’) break; } printf("\n错误"); return（0）; } 11. 【算法】 #define M 1000 Typedef int DataType; DataType C[M]; /* 定义全局数组模拟一个栈 */ int Top1, Top2; /* 两个栈的栈顶指针 */ void Push(DataType x, int i) /* 进栈 */ { if(Top1+1==Top2) { printf("溢出\n"); exit(0);} if(i==1) { Top1++; C[Top1]=x; } else if(i==2) { Top2--; C[Top2]=x; } else { printf("i 栈标号错误\n"); exit(0);} } DataType Pop( int i) /* 出栈 */ { if(i==1) { if( Top1<0 ) { printf("栈1下溢出\n"); exit(0);} Top1--; return( C[Top1+1] ); } else if(i==2) { if( Top2>M-1 ) { printf("栈2下溢出\n"); exit(0);} Top2++; return( C[Top2-1] ); } else { printf("i 栈标号错误\n"); exit(0);} } 第四章队列 一、选择题 1.C 2.A 3.C 4.B 5.D 6.C 7.B 8.A 9.A 10.A 二、填空题 1. 线性 ,栈顶 ,队尾 ,队首 2. 进队，出队 3. front==rear，(rear+1)%Max==front 4. (rear-front+Max) % Max 5. p->next=NULL，front=rear=p 6. （front==rear&&front!=NULL或 front==rear&&rear!=NULL） 7. 3 8. 先进先出 9. n-1 10. 假溢出 三、简答题 1. 在循环队列中，仅依据头尾指针相等，无法判断队列是“空”还是“满”。要解 决这个问题，常用两种方法：一是少用一个元素空间，约定入队前，若尾指针加 1后等于头指针，则认为队列满（front所指单元始终为空）；二是使用一个计数器，记录队列中元素的总数（实际上是队列的长度）。 2. 用队列长度计算公式： (N＋r－f)% N ① L=（40＋19－11）% 40=8 ② L=（40＋11－19）% 40=32 3. 相同：都是线性结构，具有相同的逻辑结构。都可以用顺序存储或链式存储来实 现其存储结构。由于栈和队列是两种特殊的线性表，即受限的线性表，只是对插 入和删除运算加以限制。 不同：①运算规则不同，线性表可以随机存取，而栈只允许在一端进行插入、删除运算，因而是后进先出表LIFO；队列只允许在一端进行插入，而另一端 进行删除运算，因而是先进先出表FIFO。 ②用途不同，堆栈用于子程调用和保护现场，队列用于多道作业处理、指 令寄存等特殊用途。 4. 采用顺序存储结构的队列称为顺序队列。与顺序表的存储相同，利用一组地址连 续的存储单元依次存放当前队列中的数据元素。由于队列的队头和队尾均是变化 的，因此要设置两个指针。队列的链式存储，称为链队列。它是限制仅在表头删 除和表尾插入的单链表，该单链表带有头结点。在链队列中，设两个指针：队头 指针front和队尾指针rear。队头指针front指向链队列的头结点；队尾指针 rear指向最后入队元素所在的结点，它没有后继结点。我们从链队列的整体结构 考虑，一般将这两个指针封装在一个结构体中。顺序队列一次性要分配大量保证 够用的空间，效率较高，因为是基于数组的，长度也是固定的。可以实现变长， 但是一般代价较高。链队列基于链表的，要动态创建和删除节点，效率较低，但 是可以动态增长。 5. 队列主要是用于保存中间数据，而且保存的数据满足先产生先处理的特点。非循 环队列可能存在数据溢出，即队列中还有空间，可是队满的条件却成立了，为此 改为循环队列，这样克服了假溢出。但并不能说循环队列一定优于非循环队列， 因为循环队列中出队元素的空间可能被后来进队的元素占用，如果算法要求在队 列操作结束后利用进队的所有元素实现某种功能，这样循环队列就不适合了，这 种情况下需要使用非循环队列，例如利用非循环队列求解迷宫路径就是这种情况。 6. 在队列的顺序存储结构中，设队头指针为front,队尾指针为rear,队的容量（存 储空间的大小）为m。当有元素要加入队列时，若rear＝m（初始时rear＝0）， 则发生队列的上溢现象，该元素不能加入队列。 这里要特别注意的是：队列的假溢出现象，队列中还有空余的空间，但元素不能 进队列。造成这种现象的原因是由于队列的操作方式所致。 解决队列的上溢有以下几种方法： （1）建立一个足够大的存储空间，但这样做往往会造成空间使用的效率低。 （2）当出现假溢出时，可采用以下几种方法： ①采用平移元素的方法。每当执行出队操作时，则依次序移动队列中所有的剩余 数据元素前移一个位置，同时修改队尾指针。这种方法是固定队头指针front永 远指向数据区开始位置，即指向队列中的第一个位置（实际上可以省略）； ②采用循环队列方式。把队头队尾看成是一个首尾相邻的循环结构，头尾指针的 关系不变，我们将其称为循环队列。 7. 购买火车票排队；开车过收费站排队等。 四、算法设计题 1. 【算法】 void Traverse( LinkQueue *Q ) /* Q 为链式队列 */ { LinkList *p; p=Q->front->next; while( p!=NULL ) { printf("%d\t", p->data); p=p->next; } 2. 【算法】 void YangHui( int n ) /* 杨辉三角形的计算和输出 */ { int i; DataType x,y; SeqQueue *Q; /* 使用循环队列 */ InitQueue(Q); InQueue(Q,1); /* 第一行元素进队 */ for(i=2; i<=n; i++) /* 产生第i行元素并进队，打印第i-1行 */ { InQueue(Q,1); /* 第i行的第一个元素进队 */ Chap1 一、选择题 1.算法的计算量的大小称为计算的（）。 A．效率 B.复杂性 C.现实性 D.难度 2.计算机算法指的是（1），它必须具备（2）这三个特性。 (1)A．计算方法 B.排序方法 C.解决问题的步骤序列 D.调度方法 (2)A．可执行性、可移植性、可扩充性 B.可执行性、确定性、有穷性 C.确定性、有穷性、稳定性 D.易读性、稳定性、安全性 3.下面关于算法说法错误的是（）。 A．算法最终必须由计算机程序实现 B.为解决某问题的算法同为该问题编写的程序含义是相同的 C.算法的可行性是指指令不能有二义性 D.以上几个都是错误的 4．从逻辑上可以把数据结构分为（）两大类。 A．动态结构、静态结构B．顺序结构、链式结构 C．线性结构、非线性结构D．初等结构、构造型结构 5．以下数据结构中，哪一个是线性结构（）？ A．广义表 B.二叉树 C.稀疏矩阵 D.串 6．在下面的程序段中，对x的赋值语句的频度为（） FOR i:=1TO n DO FOR j:=1TO n DO x:=x+1; n) A．O(2n)B．O(n)C．O(n2)D．O(log 2 7．程序段FOR i:=n-1DOWNTO1DO FOR j:=1TO i DO IF A[j]>A[j+1] THEN A[j]与A[j+1]对换； 其中n为正整数，则最后一行的语句频度在最坏情况下是（）。 A.O（n） B.O(nlogn) C.O(n3) D.O(n2) 8．以下哪个数据结构不是多型数据类型（） A．栈B．广义表C．有向图D．字符串 9．以下数据结构中，（）是非线性数据结构 A．树B．字符串C．队D．栈 二、判断题 1．健壮的算法不会因非法的输入数据而出现莫名其妙的状态。() 2．算法可以用不同的语言描述，如果用C语言或PASCAL语言等高级语言来描述，则算法实际上就是程序了。() 3．程序一定是算法。() 4．数据的物理结构是指数据在计算机内的实际存储形式。() 5.数据结构的抽象操作的定义与具体实现有关。() 6.顺序存储方式的优点是存储密度大，且插入、删除运算效率高。() 2017年数据结构期末考试题及答案 一、选择题（共计50分，每题2分，共25题） 1 ?在数据结构中，从逻辑上可以把数据结构分为 C 。 A. 动态结构和静态结构B?紧凑结构和非紧凑结构 C.线性结构和非线性结构 D .内部结构和外部结构 2?数据结构在计算机内存中的表示是指 A ° A. 数据的存储结构 B.数据结构 C.数据的逻辑结构 D .数据元 素之间的关系 3.在数据结构中，与所使用的计算机无关的是数据的 A 结构。 A. 逻辑B?存储 C.逻辑和存储 D.物理 4 .在存储数据时，通常不仅要存储各数据元素的值，而且还要存储 C ° A.数据的处理方法B?数据元素的类型 C.数据元素之间的关系 D.数据的存储方法 5. 在决定选取何种存储结构时，一般不考虑 A ° A.各结点的值如何B?结点个数的多少 C?对数据有哪些运算 D.所用的编程语言实现这种结构是否方便。 6. 以下说法正确的是D ° A. 数据项是数据的基本单位 B. 数据元素是数据的最小单位 C. 数据结构是带结构的数据项的集合 D. —些表面上很不相同的数据可以有相同的逻辑结构 7. 在以下的叙述中，正确的是B ° A. 线性表的顺序存储结构优于链表存储结构 B. 二维数组是其数据元素为线性表的线性表 C?栈的操作方式是先进先出 D.队列的操作方式是先进后出 8. 通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着 A. 数据元素具有同一特点 B. 不仅数据元素所包含的数据项的个数要相同，而且对应的数据项的类型要一致 C. 每个数据元素都一样 D. 数据元素所包含的数据项的个数要相等 9 ?链表不具备的特点是 A 。 A.可随机访问任一结点 B.插入删除不需要移动元素 C?不必事先估计存储空间 D.所需空间与其长度成正比 10. 若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一 个结点，则采用 D 存储方式最节省运算时间。 A.单链表B ?给出表头指针的单循环链表 C.双链表D ?带头结点 的双循环链表 11. 需要分配较大空间，插入和删除不需要移动元素的线性表，其存储结构是 B 。 A.单链表B .静态链表 C.线性链表 D .顺序存储结构 12 .非空的循环单链表head的尾结点（由p所指向）满足C 。 A. p—>next 一NULL B. p — NULL C. p—>next == head D. p = = head 13 .在循环双链表的p所指的结点之前插入s所指结点的操作是 D 。 A .p—> prior-> prior=s B .p—> prior-> n ext=s C.s —> prior—> n ext = s D.s —> prior—> prior = s 14 .栈和队列的共同点是C 。 A.都是先进后出 B .都是先进先出 C.只允许在端点处插入和删除元素 D .没有共同点 一、单选题（每题 2 分，共20分） 1. 1.对一个算法的评价，不包括如下（B ）方面的内容。 A．健壮性和可读性B．并行性C．正确性D．时空复杂度 2. 2.在带有头结点的单链表HL中，要向表头插入一个由指针p指向的结 点，则执行( )。 A. p->next=HL->next; HL->next=p; B. p->next=HL; HL=p; C. p->next=HL; p=HL; D. HL=p; p->next=HL; 3. 3.对线性表，在下列哪种情况下应当采用链表表示？( ) A.经常需要随机地存取元素 B.经常需要进行插入和删除操作 C.表中元素需要占据一片连续的存储空间 D.表中元素的个数不变 4. 4.一个栈的输入序列为1 2 3，则下列序列中不可能是栈的输出序列的是 ( C ) A. 2 3 1 B. 3 2 1 C. 3 1 2 D. 1 2 3 5. 5.AOV网是一种（）。 A．有向图B．无向图C．无向无环图D．有向无环图 6. 6.采用开放定址法处理散列表的冲突时，其平均查找长度（）。 A．低于链接法处理冲突 B. 高于链接法处理冲突 C．与链接法处理冲突相同D．高于二分查找 7.7.若需要利用形参直接访问实参时，应将形参变量说明为（）参数。 A．值B．函数C．指针D．引用 8.8.在稀疏矩阵的带行指针向量的链接存储中，每个单链表中的结点都具 有相同的（）。 A．行号B．列号C．元素值D．非零元素个数 9.9.快速排序在最坏情况下的时间复杂度为（）。 A．O(log2n) B．O(nlog2n) C．0(n) D．0(n2) 10.10.从二叉搜索树中查找一个元素时，其时间复杂度大致为( )。 A. O(n) B. O(1) C. O(log2n) D. O(n2) 二、二、运算题（每题 6 分，共24分） 1. 1.数据结构是指数据及其相互之间的______________。当结点之间存在M 对N（M：N）的联系时，称这种结构为_____________________。 2. 2.队列的插入操作是在队列的___尾______进行，删除操作是在队列的 ____首______进行。 3. 3.当用长度为N的数组顺序存储一个栈时，假定用top==N表示栈空，则 表示栈满的条件是___top==0___(要超出才为满)_______________。 4. 4.对于一个长度为n的单链存储的线性表，在表头插入元素的时间复杂度 为_________，在表尾插入元素的时间复杂度为____________。 第1章绪论 1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。 答案： 数据：是客观事物的符号表示，指所有能输入到计算机中并被计算机程序处理的符号的总称。如数学计算中用到的整数和实数，文本编辑所用到的字符串，多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。 数据元素：是数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。在有些情况下，数据元素也称为元素、结点、记录等。数据元素用于完整地描述一个对象，如一个学生记录，树中棋盘的一个格局（状态）、图中的一个顶点等。 数据项：是组成数据元素的、有独立含义的、不可分割的最小单位。例如，学生基本信息表中的学号、姓名、性别等都是数据项。 数据对象：是性质相同的数据元素的集合，是数据的一个子集。例如：整数数据对象是集合N={0，±1，±2，…}，字母字符数据对象是集合C={‘A’，‘B’，…，‘Z’，‘a’，‘b’，…，‘z’}，学生基本信息表也可是一个数据对象。 数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。换句话说，数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。 逻辑结构：从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。因此，数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。 存储结构：数据对象在计算机中的存储表示，也称为物理结构。 抽象数据类型：由用户定义的，表示应用问题的数学模型，以及定义在这个模型上的一组操作的总称。具体包括三部分：数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。 2．试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。 答案： 例如有一张学生基本信息表，包括学生的学号、姓名、性别、籍贯、专业等。每个学生基本信息记录对应一个数据元素，学生记录按顺序号排列，形成了学生基本信息记录的线性序列。对于整个表来说，只有一个开始结点(它的前面无记录)和一个终端结点(它的后面无记录)，其他的结点则各有一个也只有一个直接前趋和直接后继。学生记录之间的这种关系就确定了学生表的逻辑结构，即线性结构。 这些学生记录在计算机中的存储表示就是存储结构。如果用连续的存储单元(如用数组表示)来存放这些记录，则称为顺序存储结构；如果存储单元不连续，而是随机存放各个记录，然后用指针进行链接，则称为链式存储结构。 即相同的逻辑结构，可以对应不同的存储结构。 3．简述逻辑结构的四种基本关系并画出它们的关系图。 数据结构试题及答案 数据结构试题(,)参考答案班别学号姓名成绩一、单项选择(每小题2分，共24分) 1.若某线性表的常用操作是取第i个元素及其前趋元素，则采用( A )存储方式最节省时间 A.顺序表 B.单链表 C.双链表 D.单向循环 B ) 2.串是任意有限个( A.符号构成的序列 B.字符构成的序列 C.符号构成的集合 D.字符构成的集合 3.设矩阵A(aij,1<=i,j<=10)的元素满足: aij<>0(i>=j,1<=i,j<=10),aij =0 (i A.64 B.63 C.31 D.32 7.将含100个结点的完全二叉树从根这一层开始，每层从左至右依次对结点编号，根结点的编号为1。编号为47的结点X的双亲的编号为( C ) A.24 B.25 C.23 D.2无法确定 8.设有一个无向图G=(V,E)和G'=(V',E')，如果G'为G的生成树，则下面不正确的说法是( D ) A.G'为G的子图 B.G'为G的一个无环子图 C.G'为G的极小连通子图且V'=V D.G'为G的连通分量 1 9.用线性探测法查找闭散列上，可能要探测多个散列地址，这些位置上的键值( D ) A.一定都是同义词 B.一定都不是同义词 C.都相同 D.不一定都是同义词 10.二分查找要求被查找的表是( C ) A.键值有序的链接表 B.链接表但键值不一定有序表 C.键值有序的顺序表 D.顺序表但键值不一定有序表 11.当初始序列已经按键值有序，用直接插入法对其进行排序，需要比较的次数为( B ) 2 A. n B. n-1 C. logn D. nlogn 22 12.堆是一个键值序列{K1,K2,...,Ki,...,Kn},对i=1,2,...,n/2 ，满足 ( A ) ? ? A. Ki<=K2i且Ki<=K2i+1(2i+1<=n) B.Ki 数据结构考试题库 绪论 一、填空题 1.数据的逻辑结构被分为集合、(线性结构)、(树形结构)和(图状结构)四种。 2.物理结构是数据结构在计算机中的表示，又称为(存储结构)。 3.数据元素的逻辑结构包括( 线性)、(树)和图状结构3种类型，树形结构和图状结构合称为(非线性结构)。 4.(数据元素)是数据的基本单位，(数据项)是数据不可分割的最小单位。 5.线性结构中元素之间存在(一个对一个)关系，树形结构中元素之间存在(一个对多个)关系，图状结构中元素之间存在(多个对多个)关系。 ？6.数据结构是一门研究非数值计算的程序设计问题中：计算机的(数据元素)以及它们之间的(关系)和(运筹)等的学科。 7.算法的五个重要特性为有穷性、确定性、(输入)、(输出)和(可行性)。 二、选择题 1.数据的不可分割的基本单位是(D)。 A.元素 B.结点 C.数据类型 D.数据项 *2.线性表的逻辑顺序与存储顺序总是一致的，这种说法(B)。 A.正确 B.不正确 C.不确定 D.无法选择 3.线性结构是指数据元素之间存在一种(D)。 精心整理，用心做精品2 A.一对多关系 B.多对多关系 C.多对一关系 D.一对一关系 4.在数据结构中，从逻辑上可以把数据结构分成(A)。 A.动态结构和静态结构 B.紧凑结构和非紧凑结构 C.线性结构和非线性结构 D.内部结构和外部结构 5.线性表若采用链式存储结构时，要求内存中可用存储单元的 地址( D)。 A.必须是连续的 B.部分地址必须是连续的 C.一定是不连续的 D.连续不连续都可以 三、简答题 1.算法的特性是什么。 答：有穷性确定性可行性有0或多个输入有1或多个输出线性结构 一、填空题 1.在一个长度为n的线性表中删除第i个元素（1≤i≤n）时，需向前移动(n-i)个元素。 2.从循环队列中删除一个元素时，其操作是(先移动队首指针，后取出元素)。 3.在线性表的单链接存储中，若一个元素所在结点的地址为p，则其后继结点的地址为(p->next)。 4.在一个单链表中指针p所指向结点的后面插入一个指针q所指向的结点时，首先把(p->next)的值赋给q->next，然后(q->date)的值赋给p->next。 5.从一个栈删除元素时，首先取出(栈顶元素)，然后再使(栈顶指针)减1。 6.子串的定位操作通常称做串的(模式匹配)。 精心整理，用心做精品3 第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、研究数据结构就是研究（D ）。 A. 数据的逻辑结构 B. 数据的存储结构 C. 数据的逻辑结构和存储结构 D. 数据的逻辑结构、存储结构及其基本操作（研究非数值计算的程序设计问题中，计算机操作对象以及他们之间的关系和操作） 2、算法分析的两个主要方面是（ A ）。 A. 空间复杂度和时间复杂度 B. 正确性和简单性 C. 可读性和文档性 D. 数据复杂性和程序复杂性 3、具有线性结构的数据结构是（ D ）。（线性结构就是：在非空有限集合中，存在为一个被称为第一个的数据元素和最后一个元素，有除了第一个元素，集合中每一个元素均只有一个前驱，除了最后一个元素有唯一后继）（链表、栈、队列、数组、串） A. 图 B. 树 C. 广义表（线性表的推广） D. 栈 4、计算机中的算法指的是解决某一个问题的有限运算序列，它必须具备输入、输出、（B ）等5个特性。 A. 可执行性、可移植性和可扩充性 B. 可执行性、有穷性和确定性 C. 确定性、有穷性和稳定性 D. 易读性、稳定性和确定性 5、下面程序段的时间复杂度是（ C ）。 for(i=0;i 6、算法是（D ）。为了解决某一问题而规定的一个有限长的操作序列 A. 计算机程序 B. 解决问题的计算方法 C. 排序算法 D. 解决问题的有限运算序列 7、某算法的语句执行频度为（3n+nlog2n+n2+8）,其时间复杂度表示（C ）。 A. O(n) B. O(nlog2n) C. O(n2) D. O(log2n) 8、下面程序段的时间复杂度为（ C ）。 i=1; while(i<=n) i=i*3; A. O(n) B. O(3n) C. O(log3n) D. O(n3) 9、数据结构是一门研究非数值计算的程序设计问题中计算机的数据元素以及它们之间的（B ）和运算等的学科。（关系和操作） A. 结构 B. 关系 C. 运算 D. 算法 10、下面程序段的时间复杂度是（ A ）。 i=s=0; while(s 数据结构期末考试试题及答案 、选择题 评价一个算法时间性能的主要标准是()。1. A、算法易于调试 B、算法易于理解 C、算法的稳定性和正确性 D、算法的时间复杂度 )等五个特性。计算机算法具备有输入、输出、 2. A、可行性、可移植性和可扩充性 B、可行性、确定性和有穷性 C、确定性、有穷性和稳定性 D、XX、稳定性和XX 。带头结点的单链表head为空的判定条件是()3. A、h ead==NULL B、h ead->next==NULL C、head->next==head D、head！=NULL 以下关于线性表的说法不正确的是()。4. A、线性表中的数据元素可以是数字、字符、记录等不同类型。 B、线性表中包含的数据元素个数不是任意的。 C、线性表中的每个结点都有且只有一个直接前趋和直接后继。 D、存在这 样的线性表：表中各结点都没有直接前趋和直接后继。 在顺序表中，只要知道()，就可在相同时间内求出任一结点的存储地址。 5.A、基地址 B、结点大小 C、向量大小 D、基地址和结点大小 ()运算中，使用顺序表比链表好。6. A、插入 B、删除 C、根据序号查找 D、根据元素值查找一个长度为n的顺序表中，向第i个元素之前插入一个新元素时，需要向后移动()个元素7.A、n-i B、n-i+1 C、n-i-1 D、i ()适合作为经常在首尾两端操作线性表的存储结构。8. A、顺序表 B、单链表 C、循环链表 D、双向链表 栈和队列的共同点是() 9. A、都是先进后出 B、都是先进先出 C、只允许在端点处插入和删除元素 D、没有共同点 一个队列的入列序列是1234，则队列的输出序列是()。10. A 、4321 B 、12 3 4 C 、1432 D 、 3241队列与一般的线性表的区别在于()。11. A、数据元素的类型不同 B、运算是否受限制 C、数据元素的个数不同 D、逻辑结构不同 假上溢”现象会出现在()中。12. A、循环队列 B、队列 C、链队列 、顺序队列D.二、填空 第 1 章绪论 课后习题讲解 1. 填空 ⑴（）是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 【解答】数据元素 ⑵（）是数据的最小单位，（）是讨论数据结构时涉及的最小数据单位。 【解答】数据项，数据元素 【分析】数据结构指的是数据元素以及数据元素之间的关系。 ⑶从逻辑关系上讲，数据结构主要分为（）、（）、（）和（）。 【解答】集合，线性结构，树结构，图结构 ⑷数据的存储结构主要有（）和（）两种基本方法，不论哪种存储结构，都要存储两方面的内容：（）和（）。 【解答】顺序存储结构，链接存储结构，数据元素，数据元素之间的关系 ⑸算法具有五个特性，分别是（）、（）、（）、（）、（）。 【解答】有零个或多个输入，有一个或多个输出，有穷性，确定性，可行性 ⑹算法的描述方法通常有（）、（）、（）和（）四种，其中，（）被称为算法语言。 【解答】自然语言，程序设计语言，流程图，伪代码，伪代码 ⑺在一般情况下，一个算法的时间复杂度是（）的函数。 【解答】问题规模 ⑻设待处理问题的规模为n，若一个算法的时间复杂度为一个常数，则表示成数量级的形式为（），若为n*log25n，则表示成数量级的形式为（）。 【解答】Ο(1)，Ο(nlog2n) 【分析】用大O记号表示算法的时间复杂度，需要将低次幂去掉，将最高次幂的系数去掉。 2. 选择题 ⑴顺序存储结构中数据元素之间的逻辑关系是由（）表示的，链接存储结构中的数据元素之间的逻辑关系是由（）表示的。 A 线性结构 B 非线性结构 C 存储位置 D 指针 【解答】C，D 【分析】顺序存储结构就是用一维数组存储数据结构中的数据元素，其逻辑关系由存储位置（即元素在数组中的下标）表示；链接存储结构中一个数据元素对应链表中的一个结点，元素之间的逻辑关系由结点中的指针表示。 第一章绪论 选择题 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. 算法的计算量的大小称为计算的（）。【北京邮电大学2000 二、3 （20/8分）】 A．效率 B. 复杂性 C. 现实性 D. 难度 2. 算法的时间复杂度取决于（）【中科院计算所1998 二、1 （2分）】 A．问题的规模 B. 待处理数据的初态 C. A和B 3.计算机算法指的是（1），它必须具备（2）这三个特性。 (1) A．计算方法 B. 排序方法 C. 解决问题的步骤序列 D. 调度方法 (2) A．可执行性、可移植性、可扩充性 B. 可执行性、确定性、有穷性 C. 确定性、有穷性、稳定性 D. 易读性、稳定性、安全性 【南京理工大学1999 一、1（2分）【武汉交通科技大学1996 一、1（4分）】4．一个算法应该是（）。【中山大学1998 二、1（2分）】 A．程序B．问题求解步骤的描述C．要满足五个基本特性D．A和C. 5. 下面关于算法说法错误的是（）【南京理工大学2000 一、1（1.5分）】 A．算法最终必须由计算机程序实现 B. 为解决某问题的算法同为该问题编写的程序含义是相同的 C. 算法的可行性是指指令不能有二义性 D. 以上几个都是错误的 6. 下面说法错误的是（）【南京理工大学2000 一、2 （1.5分）】 (1）算法原地工作的含义是指不需要任何额外的辅助空间 （2）在相同的规模n下，复杂度O(n)的算法在时间上总是优于复杂度O(2n)的算法（3）所谓时间复杂度是指最坏情况下，估算算法执行时间的一个上界 （4）同一个算法，实现语言的级别越高，执行效率就越低 A．(1) B.(1),(2) C.(1),(4) D.(3) 7．从逻辑上可以把数据结构分为（）两大类。【武汉交通科技大学1996 一、4（2分）】 A．动态结构、静态结构B．顺序结构、链式结构 C．线性结构、非线性结构D．初等结构、构造型结构 8．以下与数据的存储结构无关的术语是（）。【北方交通大学2000 二、1（2分）】 A．循环队列 B. 链表 C. 哈希表 D. 栈 9．以下数据结构中，哪一个是线性结构（）？【北方交通大学2001 一、1（2分）】 A．广义表 B. 二叉树 C. 稀疏矩阵 D. 串 2011-2012学年第一学期期末考查 《数据结构》试卷 （答案一律写在答题纸上，在本试卷上做答无效） 一、选择（每题1分，共10分） 1.长度为n的线性表采用顺序存储结构，一个在其第i个位置插入新元素的算法时间复杂度为（D） A.O(0) B.O(1) C.O(n) D.O(n2) 2.六个元素按照6，5，4，3，2，1的顺序入栈，下列哪一个是合法的出栈序列？（D） A.543612 B.453126 C.346512 D.234156 3.设树的度为4，其中度为1、2、3、4的结点个数分别是4、2、1、2，则树中叶子个数为（B ） A.8 B.9 C.10 D.11 4.设森林F对应的二叉树B有m个结点，B的右子树结点个数为n，森林F中第一棵树的结点个数是（ B ） A. m-n B.m-n-1 C.n+1 D.m+n 5.若一棵二叉树具有10个度为2的结点，5个度为1的结点，则度为0的结点个数是（B） A.9 B.11 C.15 D.不确定 6.下列哪一个方法可以判断出一个有向图是否有环。（A） A.深度优先遍历 B.拓扑排序 C.求最短路径 D.求关键路径 7.第7层有10个叶子结点的完全二叉树不可能有（B ）个结点。 A.73 B.234 C.235 D.236 8.分别用以下序列构造二叉排序树，与用其他三个序列构造的结果不同的是（B） A.（100,80,90,60,120,110,130） B.（100, 120, 110,130,80, 60,90） C.（100,60,80,90,120,110,130） D.（100,80, 60,90, 120, 130,110） 9.对一组数据（84，47，25，15，21）排序，数据的排列次序在排序过程中变化如下：（1）84 47 25 15 21 （2）15 47 25 84 21 （3）15 21 25 84 47（4）15 21 25 47 84则采用的排序方法是（B ） A.选择排序 B.起泡排序 C.快速排序 D.插入排序 10.对线性表进行折半查找时，要求线性表必须（D） A.以顺序方式存储 B.以顺序方式存储，且数据元素有序 数据结构习题集含答案 目录 选择题 第一章绪论 1.数据结构这门学科是针对什么问题而产生的（A ） A、针对非数值计算的程序设计问题 B、针对数值计算的程序设计问题 C、数值计算与非数值计算的问题都针对 D、两者都不针对 2.数据结构这门学科的研究内容下面选项最准确的是（D ） A、研究数据对象和数据之间的关系 B、研究数据对象 C、研究数据对象和数据的操作 D、研究数据对象、数据之间的关系和操作 3.某班级的学生成绩表中查得张三同学的各科成绩记录，其中数据结构考了90分，那 么下面关于数据对象、数据元素、数据项描述正确的是（C ） A、某班级的学生成绩表是数据元素，90分是数据项 B、某班级的学生成绩表是数据对象，90分是数据元素 C、某班级的学生成绩表是数据对象，90分是数据项 D、某班级的学生成绩表是数据元素，90分是数据元素 4.*数据结构是指（A ）。 A、数据元素的组织形式 B、数据类型 C、数据存储结构 D、数据定义 5.数据在计算机存储器内表示时，物理地址与逻辑地址不相同，称之为（C ）。 A、存储结构 B、逻辑结构 C、链式存储结构 D、顺序存储结构 6.算法分析的目的是（C ） A、找出数据的合理性 B、研究算法中的输入和输出关系 C、分析算法效率以求改进 D、分析算法的易懂性和文档型性 7.算法分析的主要方法（A ）。 A、空间复杂度和时间复杂度 B、正确性和简明性 C、可读性和文档性 D、数据复杂性和程序复杂性 8.计算机内部处理的基本单元是（B ） A、数据 B、数据元素 C、数据项 D、数据库 9.数据在计算机内有链式和顺序两种存储方式，在存储空间使用的灵活性上，链式存储 比顺序存储要（B ）。 A、低 B、高 C、相同 D、不好说 10.算法的时间复杂度取决于（ C ） A 、问题的规模B、待处理数据的初始状态 C、问题的规模和待处理数据的初始状态 D、不好说 11.数据结构既研究数据的逻辑结构，又研究物理结构，这种观点（B ）。 A、正确 B、错误 C、前半句对，后半句错 D、前半句错，后半句对 12.在数据结构中，从逻辑上可以把数据结构分成（ C ） A、动态结构和静态结构 B、紧凑结构和非紧凑结构 C、线性结构和非线性结构 D、内部结构和外部结构 13.线性表的顺序存储结构是一种( )的存储结构，线性表的链式存储结构是一种（ A ） 存储结构。 A、随机存取 B、顺序存取 C、索引存取 D、散列存取 14.*下列程序的时间复杂度是（A ） for (i=1; i<=n; ++i){ for (j=1; j<=n; ++j){ c [i][j]=0; 第2章自测卷答案姓名班级 一、填空（每空1分，共13分） 1. 【严题集 2.2①】在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与表长和该元素在表中的位置有关。 2. 线性表中结点的集合是有限的，结点间的关系是一对一的。 3. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动n-i+1 个元素。 4. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时，需向前移动n-i 个元素。 5. 在顺序表中访问任意一结点的时间复杂度均为O(1)，因此，顺序表也称为随机存取的数据结构。 6. 【严题集2.2①】顺序表中逻辑上相邻的元素的物理位置必定相邻。单链表中逻辑上相邻的元素的物理位置不一定相邻。 7. 【严题集2.2①】在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点的链域的值指示。 8．在n个结点的单链表中要删除已知结点*p，需找到它的前驱结点的地址，其时间复杂度为O（n）。 二、判断正误（在正确的说法后面打勾，反之打叉）（每小题1分，共10分）（×）1. 链表的每个结点中都恰好包含一个指针。 答：错误。链表中的结点可含多个指针域，分别存放多个指针。 例如，双向链表中的结点可以含有两个指针域，分别存放指向其 直接前趋和直接后继结点的指针。 （×）2. 链表的物理存储结构具有同链表一样的顺序。 错，链表的存储结构特点是无序，而链表的示意图有序。 （×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。 错，链表的结点不会移动，只是指针内容改变。 （×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 错，混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序 表，也能存放记录型数据。 （×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。 数据结构考试及答案（） 作者: 日期: 2 数据结构试题 一、单选题 1、在数据结构的讨论中把数据结构从逻辑上分为（C） A 内部结构与外部结构 B 静态结构与动态结构 C 线性结构与非线性结构 D 紧凑结构与非紧凑结构。 2、采用线性链表表示一个向量时，要求占用的存储空间地址（D） A 必须是连续的B部分地址必须是连续的 C 一定是不连续的D可连续可不连续 3、采用顺序搜索方法查找长度为n的顺序表时，搜索成功的平均搜索长度为 （D ）。 An B n/2 C （n-1）/2 D （n+1）/2 4、在一个单链表中，若q结点是p结点的前驱结点，若在q与p之间插入结点s，则执行（D ）o A s—link = p—link ；p—link = s； B p—link = s; s—link = q; C p—link = s—link ；s—link = p； D q—link = s; s—link = p; 5、如果想在4092个数据中只需要选择其中最小的5个，采用（C ）方法最好。 A 起泡排序 B 堆排序C锦标赛排序 D 快速 排序 6、设有两个串t和p，求p在t中首次出现的位置的运算叫做（B ）o A 求子串B模式匹配C 串替换 D 串连接 7、在数组A中，每一个数组元素A[i][j] 占用3个存储字，行下标i从1到8, 列下标j从1到10。所有数组元素相继存放于一个连续的存储空间中，则存放 该数组至少需要的存储字数是（ C ）。 A 80 B 100 C 240 D 270 8、将一个递归算法改为对应的非递归算法时，通常需要使用（ A ）。 A 栈B队列C循环队列D优先队列 9、一个队列的进队列顺序是1,2, 3, 4 ，则出队列顺序为（C ）。 10、在循环队列中用数组A[0.. m-1]存放队列元素，其队头和队尾指针分别为front和rear，则当前队列中的元素个数是（ D ）。 A （ front - rear + 1） % m B （rear - front + 1） %m C （ front - rear + m） % m D （ rear - front + n） % m 11、一个数组元素a[i]与（A ）的表示等价。 A * （a+i） B a+i C *a+i D &a+i 12、若需要利用形参直接访问实参，则应把形参变量说明为（ B ）参数 A指针 B 引用C值 D 变量 13、下面程序段的时间复杂度为（C) for (i nt i=0;i 第二章习题 1.描述以下三个概念的区别：头指针，头结点，首元素结点。 2.填空： （1）在顺序表中插入或删除一个元素，需要平均移动元素，具体移动的元素个数与有关。 （2）在顺序表中，逻辑上相邻的元素，其物理位置相邻。在单链表中，逻辑上相邻的元素，其物理位置相邻。 （3）在带头结点的非空单链表中，头结点的存储位置由指示，首元素结点的存储位置由指示，除首元素结点外，其它任一元素结点的存储位置由指示。3．已知L是无表头结点的单链表，且P结点既不是首元素结点，也不是尾元素结点。按要求从下列语句中选择合适的语句序列。 a. 在P结点后插入S结点的语句序列是：。 b. 在P结点前插入S结点的语句序列是：。 c. 在表首插入S结点的语句序列是：。 d. 在表尾插入S结点的语句序列是：。 供选择的语句有： （1）P->next=S; （2）P->next= P->next->next; （3）P->next= S->next; （4）S->next= P->next; （5）S->next= L; （6）S->next= NULL; （7）Q= P; （8）while(P->next!=Q) P=P->next; （9）while(P->next!=NULL) P=P->next; （10）P= Q; （11）P= L; （12）L= S; （13）L= P; 4.设线性表存于a(1:arrsize)的前elenum个分量中且递增有序。试写一算法，将X插入到线性表的适当位置上，以保持线性表的有序性。 5.写一算法，从顺序表中删除自第i个元素开始的k个元素。 6.已知线性表中的元素（整数）以值递增有序排列，并以单链表作存储结构。试写一高效算法，删除表中所有大于mink且小于maxk的元素（若表中存在这样的元素），分析你的算法的时间复杂度（注意：mink和maxk是给定的两个参变量，它们的值为任意的整数）。 7.试分别以不同的存储结构实现线性表的就地逆置算法，即在原表的存储空间将线性表（a1, a2..., an）逆置为（an, an-1,..., a1）。 （1）以一维数组作存储结构，设线性表存于a(1:arrsize)的前elenum个分量中。 （2）以单链表作存储结构。 8.假设两个按元素值递增有序排列的线性表A和B，均以单链表作为存储结构，请编写算法，将A表和B表归并成一个按元素值递减有序排列的线性表C，并要求利用原表（即A 表和B表的）结点空间存放表C。 2012年数据结构期末考试题及答案 一、选择题 1．在数据结构中，从逻辑上可以把数据结构分为C。 A．动态结构和静态结构B．紧凑结构和非紧凑结构 C．线性结构和非线性结构D．内部结构和外部结构 2．数据结构在计算机内存中的表示是指A。 A．数据的存储结构B．数据结构C．数据的逻辑结构D．数据元素之间的关系 3．在数据结构中，与所使用的计算机无关的是数据的A结构。 A．逻辑B．存储C．逻辑和存储D．物理 4．在存储数据时，通常不仅要存储各数据元素的值，而且还要存储C。 A．数据的处理方法B．数据元素的类型 C．数据元素之间的关系D．数据的存储方法 5．在决定选取何种存储结构时，一般不考虑A。 A．各结点的值如何B．结点个数的多少 C．对数据有哪些运算D．所用的编程语言实现这种结构是否方便。 6．以下说法正确的是D。 A．数据项是数据的基本单位 B．数据元素是数据的最小单位 C．数据结构是带结构的数据项的集合 D．一些表面上很不相同的数据可以有相同的逻辑结构 7．算法分析的目的是C，算法分析的两个主要方面是A。 （1）A．找出数据结构的合理性B．研究算法中的输入和输出的关系 C．分析算法的效率以求改进C．分析算法的易读性和文档性 （2）A．空间复杂度和时间复杂度B．正确性和简明性 C．可读性和文档性D．数据复杂性和程序复杂性 8．下面程序段的时间复杂度是O（n2）。 s ＝0； for（I ＝0；i＜n；i＋＋） for（j＝0；j＜n；j＋＋） s ＋＝B[i][j]； sum ＝s ； 9．下面程序段的时间复杂度是O（n*m）。 for（i ＝0；i＜n；i＋＋） for（j＝0；j＜m；j＋＋） A[i][j] ＝0； 10．下面程序段的时间复杂度是O（log3n）。 i ＝0； while（i＜＝n） i ＝i * 3； 11．在以下的叙述中，正确的是B。 A．线性表的顺序存储结构优于链表存储结构 B．二维数组是其数据元素为线性表的线性表 C．栈的操作方式是先进先出 D．队列的操作方式是先进后出 12．通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着B 。 A．数据元素具有同一特点 B．不仅数据元素所包含的数据项的个数要相同，而且对应的数据项的类型要一致 C．每个数据元素都一样 D．数据元素所包含的数据项的个数要相等 13．链表不具备的特点是A。 A．可随机访问任一结点B．插入删除不需要移动元素 C．不必事先估计存储空间D．所需空间与其长度成正比 14．不带头结点的单链表head为空的判定条件是A。数据结构第一章试题
2017年数据结构期末考试题及答案A
数据结构试题及答案(免费)
数据结构课后习题答案
数据结构试题及答案
数据结构考试题库
严蔚敏版数据结构课后习题答案-完整版
数据结构试题答案
数据结构期末考试试题及答案
数据结构习题与答案
数据结构习题及答案——严蔚敏_课后习题答案 精品
数据结构第一章考试题库(含答案)
《数据结构》期末考试题及答案
数据结构考试题库含答案
数据结构 第二章自测题答案
数据结构考试及答案()
(完整版)数据结构课后习题及解析第二章
2015年数据结构期末考试题及答案