数据结构模拟测试1

farek

于 2024-06-11 09:11:35 发布

阅读量857

点赞数 9

文章标签：数据结构算法 python

本文链接：https://blog.csdn.net/farek/article/details/139586605

版权

1-1

随机题目池 1

(5 选 1)

每题 1 分

1-1-1

若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用顺序表存储最节省时间。

| 参考答案

答案

1-1-2

对于顺序存储的长度为N的线性表，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。

| 参考答案

答案

1-1-3

对于顺序存储的长度为N的线性表，删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。

| 参考答案

答案

1-1-4

线性表L如果需要频繁地进行不同下标元素的插入、删除操作，此时选择顺序存储结构更好。

| 参考答案

答案

1-1-5

在具有N个结点的单链表中，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。

| 参考答案

答案

1-2

随机题目池 2

(3 选 1)

每题 1 分

1-2-1

通过对堆栈S操作：Push(S,1), Push(S,2), Pop(S), Push(S,3), Pop(S), Pop(S)。输出的序列为：123。

| 参考答案

答案

1-2-2

若一个栈的输入序列为{1, 2, 3, 4, 5}，则不可能得到{3, 4, 1, 2, 5}这样的出栈序列。

| 参考答案

答案

1-2-3

若一个栈的输入序列为1，2，3，…，N，输出序列的第一个元素是i，则第j个输出元素是j−i−1。

| 参考答案

答案

1-3

随机题目池 3

(6 选 1)

每题 1 分

1-3-1

若一个结点是某二叉树的中序遍历序列的最后一个结点，则它必是该树的前序遍历序列中的最后一个结点。

| 参考答案

答案

1-3-2

若A和B都是一棵二叉树的叶子结点，则存在这样的二叉树，其前序遍历序列为...A...B...，而中序遍历序列为...B...A...。

| 参考答案

答案

1-3-3

某二叉树的前序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无左孩子。

| 参考答案

答案

1-3-4

已知一棵二叉树的先序遍历结果是ABC,　则CAB不可能是中序遍历结果。

| 参考答案

答案

1-3-5

某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。

| 参考答案

答案

1-3-6

某二叉树的前序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。

| 参考答案

答案

1-4

随机题目池 4

(3 选 1)

每题 1 分

1-4-1

给定一棵树，可以找到唯一的一棵二叉树与之对应。

| 参考答案

答案

1-4-2

将一棵树转成二叉树，根结点没有左子树。

| 参考答案

答案

1-4-3

哈夫曼树的结点个数不能是偶数。

| 参考答案

答案

1-5

随机题目池 5

(2 选 1)

每题 1 分

1-5-1

存在一棵总共有2023个结点的二叉树，其中有16个结点只有一个孩子。

| 参考答案

答案

1-5-2

存在一棵总共有2023个结点的二叉树，其中有39个结点只有一个孩子。

| 参考答案

答案

1-6

随机题目池 6

(3 选 1)

每题 1 分

1-6-1

将一棵完全二叉树存于数组中（根结点的下标为1）。则下标为23和24的两个结点是兄弟。

| 参考答案

答案

1-6-2

一棵有124个结点的完全二叉树，其叶结点个数是确定的。

| 参考答案

答案

1-6-3

完全二叉树中，若一个结点没有左孩子，则它必是树叶。

| 参考答案

答案

1-7

随机题目池 7

(3 选 1)

每题 1 分

1-7-1

Kruskal 算法是通过每步添加一条边及其相连的顶点到一棵树，从而逐步生成最小生成树。

| 参考答案

答案

1-7-2

Prim 算法是通过每步添加一条边及其相连的顶点到一棵树，从而逐步生成最小生成树。

| 参考答案

答案

1-7-3

若图G为连通图，则G必有唯一的一棵最小生成树。

| 参考答案

答案

1-8

随机题目池 8

(3 选 1)

每题 1 分

1-8-1

如果无向图G必须进行两次广度优先搜索才能访问其所有顶点，则G中一定有回路。

| 参考答案

答案

1-8-2

如果无向图G必须进行两次广度优先搜索才能访问其所有顶点，则G一定有2个连通分量。

| 参考答案

答案

1-8-3

图的深度优先遍历非递归算法通常采用栈实现，广度优先遍历非递归算法通常采用队列实现。

| 参考答案

答案

1-9

随机题目池 9

(3 选 1)

每题 1 分

1-9-1

用邻接表法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。

| 参考答案

答案

1-9-2

无向图中的一条边，在其邻接表存储结构中对应两个弧结点。

| 参考答案

答案

1-9-3

用邻接矩阵法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。

| 参考答案

答案

1-10

随机题目池 10

(3 选 1)

每题 1 分

1-10-1

对N个记录进行快速排序，在最坏的情况下，其时间复杂度是O(NlogN)。

| 参考答案

答案

1-10-2

快速排序是稳定的算法。

| 参考答案

答案

1-10-3

希尔排序是稳定的算法。

| 参考答案

答案

单选题30 分

2-1

随机题目池 1

(5 选 1)

每题 2 分

2-1-1

在数据结构中，从逻辑上可以把数据结构分成（）。

动态结构和静态结构

紧凑结构和非紧凑结构

线性结构和非线性结构

内部结构和外部结构

| 参考答案

答案

2-1-2

以下数据结构中，（）是非线性数据结构。

树

字符串

队列

栈

| 参考答案

答案

2-1-3

与数据元素本身的形式、内容、相对位置、个数无关的是数据的（）。

存储结构

存储实现

逻辑结构

运算实现

| 参考答案

答案

2-1-4

下列属于线性数据结构的是( )。

队列

树

图

二叉树

| 参考答案

答案

2-1-5

以下说法正确的是（）。

数据元素是数据的最小单位

数据项是数据的基本单位

数据结构是带有结构的各数据项的集合

一些表面上很不相同的数据可以有相同的逻辑结构

| 参考答案

答案

2-2

随机题目池 2

(7 选 1)

每题 2 分

2-2-1

对于一个具有N个结点的单链表，在给定值为x的结点后插入一个新结点的时间复杂度为

O(1)

O(N/2)

O(N)

O(N2)

| 参考答案

答案

2-2-2

在单链表中，要删除某一指定结点，必须先找到该结点的（）。

直接前驱

自身位置

直接后继

直接后继的后继

| 参考答案

答案

2-2-3

线性表若采用链式存储结构时，要求内存中可用存储单元的地址

必须是连续的

连续或不连续都可以

部分地址必须是连续的

一定是不连续的

| 参考答案

答案

2-2-4

在具有N个结点的单链表中，实现下列哪个操作，其算法的时间复杂度是O(N)？

在地址为p的结点之后插入一个结点

删除开始结点

遍历链表和求链表的第i个结点

删除地址为p的结点的后继结点

| 参考答案

答案

2-2-5

以下关于链式存储结构的叙述中，（）是不正确的。

结点除自身信息外还包括指针域，因此存储密度小于顺序存储结构

逻辑上相邻的结点物理上不必邻接

可以通过计算直接确定第i个结点的存储地址

插入、删除运算操作方便，不必移动结点

| 参考答案

答案

2-2-6

若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用哪种存储方式最节省时间？

双链表

单循环链表

带头结点的双循环链表

顺序表

| 参考答案

答案

2-2-7

线性表L在什么情况下适用于使用链式结构实现？

需不断对L进行删除插入

需经常修改L中的结点值

L中含有大量的结点

L中结点结构复杂

| 参考答案

答案

2-3

随机题目池 3

(3 选 1)

每题 2 分

2-3-1

某队列允许在其两端进行入队操作，但仅允许在一端进行出队操作。若元素a、b、c、d、e依次入此队列后再进行出队操作，则不可能得到的出队序列是：

b a c d e

d b a c e

e c b a d

d b c a e

| 参考答案

答案

2-3-2

已知初始为空的队列 Q 的一端仅能进行入队操作，另外一端既能进行入队操作又能进行出队操作。若 Q 的入队序列是 1、2、3、4、5，则不能得到的出队序列是：

5、4、3、1、2

5、3、1、2、4

4、2、1、3、5

4、1、3、2、5

| 参考答案

答案

2-3-3

现有队列 Q 与栈 S，初始时 Q 中的元素依次是{ 1, 2, 3, 4, 5, 6 }（1在队头），S 为空。若允许下列3种操作：（1）出队并输出出队元素；（2）出队并将出队元素入栈；（3）出栈并输出出栈元素，则不能得到的输出序列是：

1, 2, 5, 6, 4, 3

2, 3, 4, 5, 6, 1

3, 4, 5, 6, 1, 2

6, 5, 4, 3, 2, 1

| 参考答案

答案

2-4

随机题目池 4

(3 选 1)

每题 2 分

2-4-1

若元素a、b、c、d、e、f依次进栈，允许进栈、退栈操作交替进行，但不允许连续三次进行退栈工作，则不可能得到的出栈序列是？

b c a e f d

c b d a e f

d c e b f a

a f e d c b

| 参考答案

答案

2-4-2

有六个元素以6、5、4、3、2、1的顺序进栈，问哪个不是合法的出栈序列？

2 3 4 1 5 6

3 4 6 5 2 1

5 4 3 6 1 2

4 5 3 1 2 6

| 参考答案

答案

2-4-3

将5个字母ooops按此顺序入栈，则有多少种不同的出栈顺序可以仍然得到ooops？

| 参考答案

答案

2-5

随机题目池 5

(4 选 1)

每题 2 分

2-5-1

具有1102个结点的完全二叉树一定有__个叶子结点。

551

1063

不确定

| 参考答案

答案

2-5-2

具有65个结点的完全二叉树其深度为（根的深度为1）：

| 参考答案

答案

2-5-3

对一棵满二叉树，m个树叶，n个结点，深度为h，则（）。

n=h+m

h+m=2n

m=h-1

n=2h-1

| 参考答案

答案

2-5-4

一个具有1025个结点的二叉树的高h为（）个。

11至1025之间

10至1024之间

| 参考答案

答案

2-6

随机题目池 6

(3 选 1)

每题 2 分

2-6-1

已知字符集{ a, b, c, d, e, f, g, h }。若各字符的哈夫曼编码依次是 0100, 10, 0000, 0101, 001, 011, 11, 0001，则编码序列 0100011001001011110101 的译码结果是：

acgabfh

adbagbb

afbeagd

afeefgd

| 参考答案

答案

2-6-2

对 n 个互不相同的符号进行哈夫曼编码。若生成的哈夫曼树共有 115 个结点，则 n 的值是：

| 参考答案

答案

2-6-3

由分别带权为9、2、5、7的四个叶子结点构成一棵哈夫曼树，该树的带权路径长度为：

| 参考答案

答案

2-7

随机题目池 7

(1 选 1)

每题 2 分

2-7-1

若一棵二叉树的后序遍历序列是{ 4, 2, 7, 5, 6, 3, 1 }，中序遍历序列是{ 4, 2, 1, 5, 7, 3, 6 }，则下列哪句是错的？

这不是一棵完全二叉树

前序遍历序列是{ 1, 2, 4, 3, 7, 5, 6 }

2是4的父结点

设定树根的层次是1，则这棵树的树高是4

| 参考答案

答案

2-8

随机题目池 8

(4 选 1)

每题 2 分

2-8-1

后序遍历图示二叉树的结果为。

二叉树.jpg

G，D，E，B，I，F，C，A

G，D，B，E，I，F，C，A

G，D，E，B，F，I，C，A

G，D，B，E，A，C，F，I

| 参考答案

答案

2-8-2

先序遍历图示二叉树的结果为

A，B，C，D，H，E，I，F，G

A，B，D，H，I，E，C，F，G

H，D，I，B，E，A，F，C，G

H，I，D，B，E，F，G，A，C

| 参考答案

答案

2-8-3

已知一棵二叉树的先序遍历结果是ABC，则以下哪个序列是不可能的中序遍历结果：

ABC

BAC

CBA

CAB

| 参考答案

答案

2-8-4

以下二叉树的后序遍历序列是（）。

二叉树 .png

DCEBFHGA

CDBEAFGH

ABCDEGFH

ABGCEFHD

| 参考答案

答案

2-9

随机题目池 9

(1 选 1)

每题 2 分

2-9-1

由分别带权为9、2、5、2、7、3的6个叶子结点构成一棵哈夫曼树，该树（树根层次为0）的带权路径长度为：

| 参考答案

答案

2-10

随机题目池 10

(3 选 1)

每题 2 分

2-10-1

对下图进行拓扑排序，可以得到不同的拓扑序列的个数是：

| 参考答案

答案

2-10-2

下图为一个AOV网，其可能的拓扑有序序列为：

ACBDEF

ABCEFD

ABCDFE

ABCEDF

| 参考答案

答案

2-10-3

给定有向图如下。下列哪个选项不是对应的拓扑序列？

abedfc

aedbfc

aedfbc

abdfce

| 参考答案

答案

2-11

随机题目池 11

(5 选 1)

每题 2 分

2-11-1

给定有权无向图如下。关于其最小生成树，下列哪句是对的？

最小生成树不唯一，其总权重为23

最小生成树唯一，其总权重为20

边(B, F)一定在树中，树的总权重为23

边(H, G)一定在树中，树的总权重为20

| 参考答案

答案

2-11-2

给定有权无向图的邻接矩阵如下，其最小生成树的总权重是：

| 参考答案

答案

2-11-3

以下哪个不是给定无向带权图的最小生成树？

| 参考答案

答案

2-11-4

已知无向图 G 如下所示，使用克鲁斯卡尔（Kruskal）算法求图 G 的最小生成树，加入到最小生成树中的边依次是：

(b,f), (b,d), (a,e), (c,e), (b,e)

(b,f), (b,d), (b,e), (a,e), (c,e)

(a,e), (b,e), (c,e), (b,d), (b,f)

(a,e), (c,e), (b,e), (b,f), (b,d)

| 参考答案

答案

2-11-5

给出如下图所示的具有 7 个结点的网 G，采用Prim算法，从4号结点开始，给出该网的最小生成树。下列哪个选项给出了正确的树结点收集顺序？

4501362

4526301

4561023

4563201

| 参考答案

答案

2-12

随机题目池 12

(1 选 1)

每题 2 分

2-12-1

在一棵度为3的树T中，若有20个度为3的结点，19个度为2的结点，20个度为1的结点，则树T的叶结点个数是：

| 参考答案

答案

2-13

随机题目池 13

(9 选 1)

每题 2 分

2-13-1

给定一有向图的邻接表如下。从顶点V1出发按深度优先搜索法进行遍历，则得到的一种顶点序列为：

V1,V5,V4,V7,V6,V2,V3

V1,V5,V4,V7,V6,V3,V2

V1,V2,V3,V4,V7,V6,V5

V1,V5,V6,V4,V7,V2,V3

| 参考答案

答案

2-13-2

给定无向带权图如下，以下哪个是从顶点 a 出发深度优先搜索遍历该图的顶点序列（多个顶点可以选择时按字母序）？

abecdfhg

abcdehgf

abcdefgh

abchgfde

| 参考答案

答案

2-13-3

对下图从顶点C出发进行深度优先搜索，哪个是错误的搜索序列？

CBADEFGH

CDABEHFG

CDAEHGFB

CBAEFGHD

| 参考答案

答案

2-13-4

在用邻接表表示有N个结点E条边的图时，深度优先遍历算法的时间复杂度为：

O(N)

O(N+E)

O(N2)

O(N2×E)

| 参考答案

答案

2-13-5

给定一个图的邻接矩阵如下，则从V1出发的深度优先遍历序列（DFS，有多种选择时小标号优先）是：

V1, V2, V4, V3, V6, V8, V10, V9, V7, V5

V1, V2, V3, V4, V5, V6, V7, V9, V8, V10

V1, V2, V4, V6, V8, V10, V9, V7, V5, V3

V1, V2, V3, V5, V7, V9, V10, V6, V8, V4

| 参考答案

答案

2-13-6

下列有关图的叙述中，有几句是对的？

如果e是有权无向图G唯一的一条最短边，那么边e一定会在该图的最小生成树上。
如果无向图的宽度优先搜索的结果为1234....，且顶点1与顶点4之间存在一条边相连，那么顶点1与顶点3之间也一定有边相连。
如果从有向图G（至少有2个顶点）的每一点均能通过深度优先搜索遍历到所有其它顶点，那么该图一定不存在拓扑序列。
若图采用邻接矩阵表示，如果该矩阵不全为0，且矩阵主对角线以下全是0，那么说明该图一定是有向图。

3句

4句

1句

2句

| 参考答案

答案

2-13-7

给定一有向图的邻接表如下。从顶点V1出发按广度优先搜索法进行遍历，则得到的一种顶点序列为：

V1,V2,V3,V4,V5

V1,V2,V3,V5,V4

V1,V3,V2,V4,V5

V1,V4,V3,V5,V2

| 参考答案

答案

2-13-8

对下图从顶点C出发进行广度优先搜索，哪个是正确的搜索序列？

CBDAEFGH

CDABEHFG

CBAEHGFD

CBDAEHFG

| 参考答案

答案

2-13-9

给定一个图的邻接矩阵如下，则从V1出发的宽度优先遍历序列（BFS，有多种选择时小标号优先）是：

V1, V2, V4, V3, V6, V8, V10, V9, V7, V5

V1, V2, V3, V4, V5, V6, V7, V9, V8, V10

V1, V2, V4, V6, V8, V10, V9, V7, V5, V3

V1, V2, V3, V5, V7, V9, V10, V6, V8, V4

| 参考答案

答案

2-14

随机题目池 14

(3 选 1)

每题 2 分

2-14-1

使用迪杰斯特拉（Dijkstra）算法求下图中从顶点1到其他各顶点的最短路径，依次得到的各最短路径的目标顶点是：

2, 5, 3, 4, 6, 7

2, 4, 3, 6, 5, 7

2, 3, 4, 5, 6, 7

5, 2, 6, 3, 4, 7

| 参考答案

答案

2-14-2

使用迪杰斯特拉（Dijkstra）算法求下图中从顶点1到其他各顶点的最短路径，依次得到的各最短路径的目标顶点是：

6, 7, 5, 3, 2, 4

6, 2, 5, 7, 3, 4

2, 3, 4, 5, 6, 7

2, 4, 3, 6, 5, 7

| 参考答案

答案

2-14-3

试利用 Dijkstra 算法求下图中从顶点 A 到其他顶点的最短距离及对应的路径。下列那个序列给出了可能的顶点收集顺序？

ACFEDBG

ACDBFEG

ACDGFBE

ABCDEFG

| 参考答案

答案

2-15

随机题目池 15

(3 选 1)

每题 2 分

2-15-1

使用快速排序算法对数据进行升序排序，若经过一次划分后得到的数据序列是 68, 11, 70, 23, 80, 77, 48, 81, 93, 88，则该次划分的枢轴是：

| 参考答案

答案

2-15-2

对序列{15，9，7，8，20，-1，4} 用希尔排序方法排序，经一趟后序列变为
{15，-l，4，8，20，9，7}，则该次采用的增量是（）。

| 参考答案

答案

2-15-3

对关键字序列(56，23，78，92，88，67，19，34)，进行增量为3的一趟希尔排序的结果为（）。

(19，23，56，34，78，67，88，92)

(23，56，78，66，88，92，19，34)

(19，23，34，56，67，78，88，92)

(19，23，67，56，34，78，92，88)

| 参考答案

答案

6-2 顺序表的插入操作（Python语言描述）

分数 10

作者柴本成

单位浙江万里学院

本题要求实现一个顺序表SeqList的方法，在顺序表SeqList第i个位置（从1开始）前插入元素x。插入成功返回True，否则返回False。

假设线性表长度为n，则插入位置i须满足1≤i≤n+1
方法接口定义：

#在顺序表SeqList第i个位置（从1开始）前插入元素x。插入成功返回True，否则返回False。

def insert(self,i,x):

其中顺序表SeqList的类定义如下：

class SqList:

    #0.构造方法

    def __init__(self):

        self.initcapcity = 10            #初始容量

        self.capcity = self.initcapcity  #最大存储

        self.data = [None] * self.capcity#顺序表的数据，列表

        self.size = 0                    #顺序表的长度

    #0.顺序表的最大容量修改为n

    def __resize(self,n):

        assert n >= 0

        #备份原来的数据

        a = self.data

        self.data = [None] * n

        for i in range(self.size):

            self.data[i] = a[i]

    #1.创建顺序表,数据源是列表a

    def create(self,a):

        for i in range(len(a)):

            if self.size == self.capcity:#顺序表满了，2倍扩容

                self.__resize(self.capcity * 2)

            self.data[i] = a[i]

            self.size += 1

    #2.输出顺序表

    def print(self):

        print("the Length of SqList:",self.size)

        print("the Elements of SqList:",*self.data[:self.size])

    #3.你的代码将被嵌在这里，注意整个方法的代码都要缩进4个空格（类里面的方法）

裁判测试程序样例：

sq = SqList()   #创建顺序表

a = list(map(int,input().split())) #输入数据到列表a

i,x = map(int,input().split())    #输入插入位置i和元素x

sq.create(a)        #根据列表a整体创建顺序表sq

if sq.insert(i,x):   #位置i前插入元素x成功

    print("Insert Success")

    sq.print()

else:               #插入失败

    print("Insert Fail,Index is Error!")

输入样例1：

输入共有2行，第1行表示顺序表的元素，第2行表示插入的位置和元素

2 6 4
1 3

输出样例1：

插入成功，按样例格式输出。

Insert Success
the Length of SqList: 4
the Elements of SqList: 3 2 6 4

输入样例2：

输入共有2行，第1行表示顺序表的元素，第2行表示插入的位置和元素

2 6 4
0 8

输出样例2：

插入失败，按样例格式输出。

Insert Fail,Index is Error!

答案

 # 在顺序表SeqList第i个位置（从1开始）前插入元素x
    def insert(self, i, x):
        if i < 1 or i > self.size + 1:
            return False
        if self.size == self.capcity:
            self.__resize(self.capcity * 2)
        for j in range(self.size, i - 1, -1):
            self.data[j] = self.data[j - 1]
        self.data[i - 1] = x
        self.size += 1
        return True

6-3 求链表的长度（Python语言描述）

分数 10

作者柴本成

单位浙江万里学院

本题要求实现一个链表类LinkList的方法，求链表（含有带头结点）的长度。

方法接口定义：

#求链表的长度，空表返回0

def length(self):

其中链表结点类LinkNode和链表类LinkList的定义如下：

class LinkNode:
    def __init__(self,x = None):
        self.data = x        #数据域
        self.next = None     #指针域初始化为空
#单链表类
class LinkList:
    #0.构造方法
    def __init__(self):
        self.head = LinkNode()  #创建一个带头结点
    #1.输出单链表
    def print(self):
        p = self.head.next  #p指向链表的第一个有效结点
        if p is None:
            print("空链表")
        else:
            while p.next is not None:
                print(p.data,"->",sep = "",end = "")
                p = p.next
            print(p.data)
    #2.创建单链表-尾插法
    def createTail(self,a):
        tail = self.head   #p指向链表的带头结点
        #遍历列表a
        for x in a:
            #根据x创建新结点
            p = LinkNode(x)
            #新结点p链接到链表的尾部
            tail.next = p
            tail = p
    #3.创建单链表-头插法
    def createHead(self,a):
        for x in a:
            p = LinkNode(x)
            p.next = self.head.next
            self.head.next = p
    #4.你的代码将被嵌在这里，注意整个方法的代码都要缩进4个空格（类里面的方法）

裁判测试程序样例：

h = LinkList()   #创建链表

a = list(map(int,input().split())) #输入数据到列表a

h.createTail(a)     #尾插法创建单链表

print(h.length())   #输出链表的长度

输入样例：

输入共有1行，数据之间用空格分隔

2 0 2 3 0 5 0 4

输出样例：

输出链表的长度

6-13 统计二叉树叶子结点的个数（Python语言描述）

分数 10

作者柴本成

单位浙江万里学院

本题要求计算二叉树中有多少片树叶，输出格式见样例。

函数接口定义：

#树叶统计

def leafCount(T)

其中二叉树类的定义如下：

#二叉树的存储-二叉链表

class BinaryTree:

    #1.构造方法

    def __init__(self,newValue):

        self.key = newValue     #树根

        self.left = None        #左子树初始化为空

        self.right = None       #右子树初始化为空

    #2.访问左子树

    def getLeft(self):

        return self.left

    #3.访问右子树

    def getRight(self):

        return self.right

    #4.修改树根的值

    def setRoot(self,newValue):

        self.key = newValue

    #5.访问树根的值

    def getRoot(self):

        return self.key

裁判测试程序样例：

T = createBT()   #创建二叉树，实现细节不表

print(leafCount(T))

#你的代码将被嵌在这里

输入样例：

ABDFECGHI
DBEFAGHCI

输出样例（对于图中给出的树）：

def leafCount(T):
    if not T:
        return 0 
    x=0
    if not T.getLeft() and not T.getRight():
        x+=1
    return x+leafCount(T.getLeft())+leafCount(T.getRight())

7-2 括号匹配

分数 10

作者李廷元

单位中国民用航空飞行学院

给定一串字符，不超过100个字符，可能包括括号、数字、字母、标点符号、空格，编程检查这一串字符中的( ) ,[ ],{ }是否匹配。

输入格式:

输入在一行中给出一行字符串，不超过100个字符，可能包括括号、数字、字母、标点符号、空格。

输出格式:

如果括号配对，输出yes，否则输出no。

输入样例1:

sin(10+20)

输出样例1:

yes

输入样例2:

{[}]

输出样例2:

no

7-10 插入排序

分数 10

作者魏峻

单位陕西理工大学

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

输入格式:

输入在第1行中给出N（1<N≤100），在第2行中给出N个待排序的整数，数字间以空格分隔，并保证数字没有重复的出现。

输出格式:

给出插入排序每一遍后的中间结果数列，数字间以空格分隔，但末尾不得有多余空格。

输入样例:

7
4 5 7 6 3 2 1

输出样例:

4 5 7 6 3 2 1
4 5 7 6 3 2 1
4 5 6 7 3 2 1
3 4 5 6 7 2 1
2 3 4 5 6 7 1
1 2 3 4 5 6 7

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
        print(" ".join(map(str, arr)))

# 读取输入
N = int(input())
input_list = list(map(int, input().split()))

# 插入排序
insertion_sort(input_list)

farek

关注

9
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
数据结构模拟测试1

树叶统计其中二叉树类的定义如下：#二叉树的存储-二叉链表#1.构造方法self.key = newValue #树根self.left = None #左子树初始化为空self.right = None #右子树初始化为空#2.访问左子树#3.访问右子树#4.修改树根的值#5.访问树根的值。
复制链接

扫一扫