数据结构期中测验
- 选择题
- 函数题
-
- [6-1 求链式表的表长](#6-1 求链式表的表长)
- [6-2 逆序数据建立链表](#6-2 逆序数据建立链表)
- [6-3 删除单链表偶数节点](#6-3 删除单链表偶数节点)
- [6-4 求二叉树高度](#6-4 求二叉树高度)
- [6-5 先序输出叶结点](#6-5 先序输出叶结点)
为了防止不自觉的朝答案看去，特意用了明黄色字体，如下查看答案：
选择题
2-1
下述程序段的时间复杂度为（ ）
cpp
for（i=0; i<n-1; i++）
for（j=0; j<n-1-i; j++）
t=a[j], a[j]=a[j+1], a[j+1]=t;A.O(1)
B.O(n)
C.O(n^2^)
D.O(n^3^ )、
答案：C。
显然，循环执行的次数是（n-1) +(n-2) + ··· +1， O(n^2^)
2-2
下列对顺序存储的有序表（长度为 n）实现给定操作的算法中，平均时间复杂度为 O(1) 的是：
A.查找包含指定值元素的算法
B.插入包含指定值元素的算法
C.删除第 i（1≤i≤n）个元素的算法
D.获取第 i（1≤i≤n）个元素的算法
答案：D
顺序表获可以通过访问下标取第 i个元素，时间复杂度 O(1)
2-3
将线性表La和Lb头尾连接，要求时间复杂度为O(1)，且占用辅助空间尽量小。应该使用哪种结构？
A.单链表
B.单循环链表
C.带尾指针的单循环链表
D.带头结点的双循环链表
答案：C
线性表La和Lb头尾连接，要先找La的尾和Lb的头。对于带尾指针的单循环链表，尾结点的next即为头结点；而带头结点的双循环链表虽然也可以通过头结点的prev找到尾结点，题目要求占用辅助空间尽量小，选C
2-4
已知头指针 h 指向一个带头结点的非空单循环链表，结点结构为 data | next，其中 next 是指向直接后继结点的指针，p 是尾指针，q 是临时指针。现要删除该链表的第一个元素，正确的语句序列是：
A.h->next=h->next->next; q=h->next; free(q);
B.q=h->next; h->next=h->next->next; free(q);
C.q=h->next; h->next=q->next; if (p!=q) p=h; free(q);
D.q=h->next; h->next=q->next; if (p==q) p=h; free(q);
答案：D
2-5
假设有5个整数以1、2、3、4、5的顺序被压入堆栈，且出栈顺序为3、5、4、2、1，那么为了获得这样的输出，堆栈大小至少为：
A.2
B.3
C.4
D.5
答案：C
2-6
有六个元素以6、5、4、3、2、1的顺序进栈，问哪个不是合法的出栈序列？
A.2 3 4 1 5 6
B.3 4 6 5 2 1
C.5 4 3 6 1 2
D.4 5 3 1 2 6
答案：B
2-7
若栈采用顺序存储方式存储，现两栈共享空间V[m]：top[i]代表第i（i=1或2）个栈的栈顶；栈1的底在V[0]，栈2的底在V[m-1]，则栈满的条件是：
A.|top[2]-top[1]|==0
B.top[1]+top[2]==m
C.top[1] == top[2]
D.top[1]+1==top[2]
答案：D
栈满的条件是两个栈的栈顶指针相遇。因为在顺序存储结构中，当两个栈的栈顶指针相邻时，表示两个栈的空间已经满
2-8
循环队列的队满条件为 ( )
A.(sq.rear+1) % maxsize ==(sq.front+1) % maxsize
B.(sq.front+1) % maxsize ==sq.rear
C.(sq.rear+1) % maxsize ==sq.front
D.sq.rear ==sq.front
答案：C
2-9
表达式a*(b+c)-d的后缀表达式是：
A.a b c + * d -
B. a b c d * + -
C.a b c * + d -
D.- + * a b c d
答案：A
根据选项的后缀表达式还原即可，A是a (b+c)-d；B是a-(b+cd)；C是a+bc-d；D纯扯淡，一眼顶真是前缀*
2-10
数组A[1...5,1...6]每个元素占5个单元，将其按行优先次序存储在起始地址为1000的连续的内存单元中，则元素A[5,5]的地址为：
A.1120
B.1125
C.1140
D.1145
答案：C
如图，自己算
2-11
二叉树中第5层（根的层号为1）上的结点个数最多为：
A.8
B.15
C.16
D.32
答案：C
二叉树中第n层结点数最多为2^n-1^
2-12
一棵二叉树中，双分支结点数为15，单分支结点数为30，则叶子结点数为（）个。
A.15
B.16
C.17
D.47
答案：B
对于n个结点的二叉树，n = n~0~+n~1~+n~2~; n~0~ = n~2~ + 1，带入求解即可
2-13
以二叉链表作为二叉树的存储结构，在具有 n 个结点的二叉链表中（n>0），空链域的个数为 __
A.n+1
B.n
C.n−1
D.无法确定
答案：A
有n个结点，说明有2n个指针域，又因为n个结点的二叉树有n-1条边，那么空指针域就有2n-(n-1)=n+1
2-14
如果二叉树的后序遍历结果是FDEBGCA，中序遍历结果是FDBEACG，那么该二叉树的前序遍历结果是什么？
A.ABCDEFG
B.ABDFEGC
C.ABDFECG
D.ABDEFCG
答案：C
2-15
设每个d叉树的结点有d个指针指向子树，有n个结点的d叉树有多少空链域？
A.nd
B.n(d−1)
C.n(d−1)+1
D.以上都不是
答案：C
跟2-13一模一样
2-16
已知一棵二叉树的树形如下图所示，其后序序列为{ e, a, c, b, d, g, f }。树中与结点a同层的结点是：
A.c
B.d
C.f
D.g
答案：B
2-17
下列线索二叉树中（用虚线表示线索），符合后序线索树定义的是：
A. 
B. 
C. 
D. 
答案：B
因为是后序线索树，选项中树的后序遍历为dbca，因此d的前驱为NULL，排除CD；后继为b，排除A
2-18
具有65个结点的完全二叉树其深度为（根的深度为1）：
A.8
B.7
C.6
D.5
答案：B
具有n个结点的完全二叉树的深度 = ⌊ log~2~n ⌋ +1
2-19
设一段文本中包含字符{a, b, c, d, e}，其出现频率相应为{3, 2, 5, 1, 1}。则经过哈夫曼编码后，文本所占字节数为：
A.40
B.36
C.25
D.12
答案：C
2-20
由分别带权为9、2、5、7的四个叶子结点构成一棵哈夫曼树，该树的带权路径长度为：
A.23
B.37
C.44
D.46
答案：C
同上
函数题
6-1 求链式表的表长
本题要求实现一个函数，求链式表的表长。
函数接口定义：
cint Length( List L );
其中List结构定义如下：
c
typedef struct LNode *PtrToLNode;
struct LNode {
ElementType Data;
PtrToLNode Next;
};
typedef PtrToLNode List;L是给定单链表，函数Length要返回链式表的长度。
裁判测试程序样例：
c
#include <stdio.h>
#include <stdlib.h>
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
ElementType Data;
PtrToLNode Next;
};
typedef PtrToLNode List;
List Read(); /* 细节在此不表 */
int Length( List L );
int main()
{
List L = Read();
printf("%d\n", Length(L));
return 0;
}
/* 你的代码将被嵌在这里 */输入样例：
1 3 4 5 2 -1
输出样例：
5
解：
c
int Length( List L )
{
int ret = 0;
while(L)
{
ret++;
L = L->Next;
}
return ret;
}6-2 逆序数据建立链表
本题要求实现一个函数，按输入数据的逆序建立一个链表。
函数接口定义：
cstruct ListNode *createlist();
函数createlist利用scanf从输入中获取一系列正整数，当读到−1时表示输入结束。按输入数据的逆序建立一个链表，并返回链表头指针。链表节点结构定义如下：
c
struct ListNode {
int data;
struct ListNode *next;
};裁判测试程序样例：
c
#include <stdio.h>
#include <stdlib.h>
struct ListNode {
int data;
struct ListNode *next;
};
struct ListNode *createlist();
int main()
{
struct ListNode *p, *head = NULL;
head = createlist();
for ( p = head; p != NULL; p = p->next )
printf("%d ", p->data);
printf("\n");
return 0;
}
/* 你的代码将被嵌在这里 */输入样例：
1 2 3 4 5 6 7 -1
输出样例：
7 6 5 4 3 2 1
解：
c
struct ListNode* createlist()
{
struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* cur = head;
cur->next = NULL;
int tmp = 0;
scanf("%d",&tmp);
while(tmp != -1)
{
cur->data = tmp;
scanf("%d",&tmp);
struct ListNode* tmp = (struct ListNode*)malloc(sizeof(struct ListNode));
tmp->next = cur;
cur = tmp;
}
return cur->next;
}6-3 删除单链表偶数节点
本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中偶数值的结点删除。链表结点定义如下：
c
struct ListNode {
int data;
struct ListNode *next;
};函数接口定义：
c
struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );函数createlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。
函数deleteeven将单链表head中偶数值的结点删除，返回结果链表的头指针。
裁判测试程序样例：
c
#include <stdio.h>
#include <stdlib.h>
struct ListNode {
int data;
struct ListNode *next;
};
struct ListNode *createlist();
struct ListNode *deleteeven( struct ListNode *head );
void printlist( struct ListNode *head )
{
struct ListNode *p = head;
while (p) {
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int main()
{
struct ListNode *head;
head = createlist();
head = deleteeven(head);
printlist(head);
return 0;
}
/* 你的代码将被嵌在这里 */输入样例：
1 2 2 3 4 5 6 7 -1
输出样例：
1 3 5 7
解：
c
struct ListNode *createlist()
{
struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* cur = head;
cur->data = -1;
cur->next = NULL;
int tmp = 0;
while ( tmp != -1)
{
scanf("%d", &tmp);
if(tmp != -1)
{
struct ListNode* ts = (struct ListNode*)malloc(sizeof(struct ListNode));
cur->next = ts;
ts->data = tmp;
ts->next = NULL;
cur = ts;
}
}
return head->next;
}
struct ListNode *deleteeven( struct ListNode *head )
{
if(head->next == NULL)
{
if(head->data%2 == 0)
return NULL;
else
return head;
}
struct ListNode *ret = head;
while(ret->data%2 == 0)
{
struct ListNode* del = ret;
ret = ret->next;
free(del);
if(ret->next == NULL)
{
if(ret->data%2 == 0)
return NULL;
else
return ret;
}
}
struct ListNode * cur = ret;
while(cur->next)
{
if(cur->next->data%2 == 0)
{
struct ListNode* del = cur->next;
cur->next = cur->next->next;
free(del);
}
else
cur = cur->next;
}
return ret;
}6-4 求二叉树高度
本题要求给定二叉树的高度。
函数接口定义：
c
int GetHeight( BinTree BT );其中BinTree结构定义如下：
c
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
ElementType Data;
BinTree Left;
BinTree Right;
};要求函数返回给定二叉树BT的高度值。
裁判测试程序样例：
c
#include <stdio.h>
#include <stdlib.h>
typedef char ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
ElementType Data;
BinTree Left;
BinTree Right;
};
BinTree CreatBinTree(); /* 实现细节忽略 */
int GetHeight( BinTree BT );
int main()
{
BinTree BT = CreatBinTree();
printf("%d\n", GetHeight(BT));
return 0;
}
/* 你的代码将被嵌在这里 */输出样例（对于图中给出的树）：
4
解：
c
int max(int a,int b)
{
return a>b?a:b;
}
int GetHeight( BinTree BT )
{
if(BT == NULL)
return 0;
return max(GetHeight(BT->Left),GetHeight(BT->Right))+1;
}6-5 先序输出叶结点
本题要求按照先序遍历的顺序输出给定二叉树的叶结点。
函数接口定义：
c
void PreorderPrintLeaves( BinTree BT );其中BinTree结构定义如下：
cpp
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
ElementType Data;
BinTree Left;
BinTree Right;
};函数PreorderPrintLeaves应按照先序遍历的顺序输出给定二叉树BT的叶结点，格式为一个空格跟着一个字符。
裁判测试程序样例：
c
#include <stdio.h>
#include <stdlib.h>
typedef char ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
ElementType Data;
BinTree Left;
BinTree Right;
};
BinTree CreatBinTree(); /* 实现细节忽略 */
void PreorderPrintLeaves( BinTree BT );
int main()
{
BinTree BT = CreatBinTree();
printf("Leaf nodes are:");
PreorderPrintLeaves(BT);
printf("\n");
return 0;
}
/* 你的代码将被嵌在这里 */输出样例（对于图中给出的树）：
Leaf nodes are: D E H I
解：
c
void PreorderPrintLeaves( BinTree BT )
{
if(BT == NULL)
return;
if(BT->Left == NULL && BT->Right == NULL)
{
printf(" %c",BT->Data);
return;
}
PreorderPrintLeaves(BT->Left);
PreorderPrintLeaves(BT->Right);
}