数据结构国家开放大学

出自:数据结构国家开放大学

有数据{53,30,37,12,45,24,96}，从空二叉树开始逐个插入数据来形成二叉排序树，若希望高度最小，应该选择的序列是（）。
单选题 (2 分) 2分
A.
45,24,53,12,37,96,30

B.
37,24,12,30,53,45,96

C.
12,24,30,37,45,53,96

D.
30,24,12,37,45,96,53

对于顺序存储的有序表{5,12,20,26,37,42,46,50,64}，若采用折半查找，则查找元素26的比较次数是（）。
单选题 (2 分) 2分
A.
3

B.
6

C.
4

D.
5

在所有的排序方法中，关键字比较的次数与记录初始排列秩序无关的是（）。
单选题 (2 分) 2分
A.
冒泡排序

B.
希尔排序

C.
直接选择排序

D.
直接插入排序

从未排序序列中依次取出元素与已经排好序的序列中的元素作比较。将其放入已排序序列的正确的位置上，此方法称为（）。
单选题 (2 分) 2分
A.
插入排序

B.
选择排序

C.
交换排序

D.
归并排序

依次将每两个相邻的有序表合并成一个有序表的排序方法称为（）。
单选题 (2 分) 2分
A.
插入排序

B.
交换排序

C.
选择排序

D.
归并排序

当两个元素出现逆序的时候就交换位置，这种排序方法称为（）。
单选题 (2 分) 2分
A.
插入排序

B.
交换排序

C.
选择排序

D.
归并排序

每次把待排序的区间划分为左、右两个子区间，其中左区间中记录的关键字均小于等于基准记录的关键字，右区间中记录的关键字均大于等于基准记录的关键字，这种排序称为（）。
单选题 (2 分) 2分
A.
插入排序

B.
快速排序

C.
堆排序

D.
归并排序

一组记录的关键字序列为（46,20,30,79，56，38，40，84,90,110），利用快速排序，以第一个关键字为分割元素，经过一次划分后结果为（）。
单选题 (2 分) 2分
A.
40，20,30,38，46，56，79，84,90,110

B.
20,30,40，38，46，79，56，84,90,100

C.
30,20,40，38，46，84，56，79,90,100

D.
20,30 38，40，46，56，79，84,90,100

在有序表{10,14，34，43，47，64，75，80，90}中，用折半查找法查找值80时，经（）次比较后查找成功。
单选题 (2 分) 2分
A.
4

B.
2

C.
3

D.
5

对序列（49，38，65，97，76，13，47，50）采用直接插入排序法进行排序，要把第七个元素47插入到已排序中，为寻找插入的合适位置需要进行（）次元素间的比较。
单选题 (2 分) 2分
A.
3

B.
4

C.
5

D.
6

排序方法中，从未排序序列中挑选元素，并将其依次放入已排序序列（初始为空）的一端的方法，称为（）排序。
单选题 (2 分) 2分
A.
归并

B.
插入

C.
选择

D.
快速

一组记录的关键字序列为（26，59，36，18，20，25），利用堆排序的方法建立的初始小根堆为（）。
单选题 (2 分) 2分
A.
26，18，59，20，36，25

B.
18，20，25，59，26，36

C.
18，20，36，59，26，25

D.
26，59，36，18，20，25

.一组记录的关键字序列为（25，48，16，35，79，82，23，40，36，72），其中，含有5个长度为2的有序表，按归并排序的方法对该序列进行一趟归并后的结果为（）。
单选题 (2 分) 2分
A.
16，25，35，48，23，40，79，82，36，72

B.
16，25，35，48，79，82，23，36，40，72

C.
16，25，48，35，79，82，23，36，40，72

D.
16，25，35，48，79，23，36，40，82，72

已知10个数据元素为（54，28，16，34，73，62，95，60，26，43），对该数列从小到大排序，经过一趟冒泡排序后的序列为（）。
单选题 (2 分) 2分
A.
16，28，34，54，73，62，60，26，43，95

B.
28，16，34，54，62，73，60，26，43，95

C.
28，16，34，54，62，60，73，26，43，95

D.
16，28，34，54，62，60，73，26，43，95

一组记录的关键字序列为（46，79，56，38，40，84），利用快速排序，以第一个关键字为分割元素，经过一次划分后结果为（）。
单选题 (2 分) 2分
A.
40，38，46，79，56，84

B.
40，38，46，56，79，84

C.
40，38，46，84，56，79

D.
38，40，46，56，79，84

一组记录的关键字序列为（80,57,41,39,46,47），利用堆排序（堆顶元素是最小元素）的方法建立的初始堆为（）。
单选题 (2 分) 2分
A.
39，46，41，57，80，47

B.
39，47，46，80，41，57

C.
41，39，46，47，57，80

D.
39，80，46，47，41，57

设线性表以不带头结点的单向链表存储，链表头指针为head，以下程序的功能是输出链表中各结点中的数据域data,完成程序中空格部分。

#define NULL 0

void main( )

{ NODE *head ,*p ;

p=head; /*p为工作指针*/

do

{printf(“%d\n”, __(1)__;

__(2)__;

}while__(3)__;

}
匹配题 (6 分) 6分 (计分规则:按匹配正确项计分)

设有一个头指针为head的不带头结点单向链表，p、q是指向链表中结点类型的指针变量，p指向链表中结点a, （设链表中没有结点的数据域与结点a的数据域相同）,写出相关语句

(1)使该单向链表成为单向循环链表

(2)插入结点s,使它成为a结点的直接前驱

q=p; x=p->data;

while __(1)__）q=q->next;

q->next=head;

q=p; p=p->next;

while(p->data!=x)

{ q=p;

__(2)__

}

s->next=p;

__(3)__

以下函数为链栈的进栈操作，x是要进栈的结点的数据域，top为栈顶指针

struct node

{ ElemType data;

struct node *next;

};

struct node *top ;

void Push(ElemType x)

{

struct node *p;

p=(struct node*)malloc __(1)__;

p->data=x;

__(2)__;

__(3)__;

}

以下函数为链队列的入队操作，x为要入队的结点的数据域的值，front、rear分别链队列的队头、队尾指针

struct node

{ ElemType data;

struct node *next;

};

struct node *front，*rear;

void InQueue(ElemType x)

{

struct node *p;

p= (struct node*) malloc __(1)__;

p->data=x;

p->next=NULL;

__(2)__;

rear= __(3)__;

以下程序是后序遍历二叉树的递归算法的程序，完成程序中空格部分（树结构中左、右指针域分别为left和right，数据域data为字符型，BT指向根结点）。完成程序中空格部分。

void

Inorder (struct BTreeNode *BT)

{

if( BT!=NULL)

{

Inorder(BT->left);

__(1)__

__(2)__

}

利用上述程序对左图进行后序遍历，结果是__(3)__;

1）以3，4，5，8，9，作为叶结点的权，构造一棵哈夫曼树。该树的带权路径长度为 .

A,64 B.65 C. 62 D. 66

权重为3的叶结点的哈夫曼编码为。

A.010 B.0101 C.000 D.0111

（1）以2，3，4，7，8，9作为叶结点的权，构造一棵哈夫曼树，该树的带权路径长度为 1

A,66 B. 80 C. 62 D. 87

权重值为4的叶结点的哈夫曼编码为 2 。

A.0001 B. 1110 C.001 D. 110

已知某二叉树的后序遍历序列是 debca，中序遍历序列是 dbeac，该二叉树的根结点是(
A.e
B.C
C.b
D.a

先序遍历序列是。

A. e,b,c,d,a B. c,a,b,,d,e C. a,b,d,e,c D. a.c,b,d,e

已知某二叉树的先序遍历序列是aecdb，中序遍历序列是eadcb，该二叉树的根结点是 1 ;

A. e B. c C. b D. a

后序遍历序列为 2 。

A. e,d,b,c,a B. c,a,b,,d,e C. a,b,d,e,c D. a.c,b,d,e,

以给定权重值5，6，17，18，25，30，为叶结点，建立一棵哈夫曼树,该树的中序遍历序列为 1

A. 5，11，28，6，17，58，30，101，18，43，25

B. 5，11，6，28，17，58，30，101，18，43，25

C. 5，11，6，28，101，58，30，17，18，43，25

D. 5，11，6，28，17，58，30，101，18，25，43

权重值为6的叶结点的哈夫曼为 .

A. 1001 B. 011 C.001 D.0001

以下函数是二叉排序树的查找算法，若二叉树为空，则返回根结点的指针，否则，返回值是指向树结点的结构指针p（查找成功p指向查到的树结点，不成功p指向为NULL）完成程序中的空格

typedef struct Bnode

{ int key;

struct Bnode *left;

struct Bnode *right;

} Bnode;

Bnode *BSearch(Bnode *bt, int k)

/* bt用于接收二叉排序树的根结点的指针，k用以接收要查找的关键字*/

{ Bnode *p;

if(bt== __(1)__)

return (bt);

p=bt;

while(p->key!= __(2)__)

{ if(k<p->key)

__(3)__;

else __(4)__;

if(p==NULL) break;

}

return(__(5)__;

}

以下程序是折半插入排序的算法

设待排序的记录序列存放在a[1],…a[n]中，以a[0]作为辅助工作单元，程序是要把a[i] 插入到已经有序的序列a[1],…a[i-1]中。

void binsort (NODE a[ ],int n)

{ int x,i,j,s,k,m;

for （i=2；i<=__(1)__;i++）

{ a[0]=a[i];

x= a[i].key;

s=1;

j=i-1;

while (s<=j)

{ m=__(2)__

if( x<a[m].key)

__(3)__

else

__(4)__

}

for ( k=i-1;k>=j+1;k- -)

__(5)__=a[k];

a[j+1]=a[0];

}

}

设查找表为(1,10,11,14,23,27,29,55,68)，出对上述查找表进行折半查找所对应的判定树，为了成功查找
到元素14.需要依次与元素进行比较。
A.23,10.1.148.23.29,27.14C.23.10,11 14 D.23.29.55,14

在等概率条件下，成功查找的平均比较次数为
A.24/9
B.25/9
C.3
D.2.5

(1)一组记录的关键字序列为(47，80，57，39，41，46)，利用堆排序的方法建立的初始堆为
《堆项元素是最小元素,采用树的形式建堆]。
A 39,41 57 80.47 46B.39,41 46.80.47.57
C.39.47.46.80.41 .57D.39.41.57.80.46,47

输出堆顶元素后,调整后的堆为
A.41,47,46.80.57
C.41.57.80.47.46
8.41,57,46.80.47
D.41.80.46.47.57

对关键字序列(56,51,71,54,46,106),利用快速排序，以第一个关键字为分割元素，经过一次划分后结果
为
A.46.51.56.5471106
8.56.51.54.46.71.106
C.46,51 54.56,71 106
D.56.51.46.54.71,106

一组记录的关键字序列为( 60.47，80，57，39，41，46.30，利用归并排序的方法经过(2.2)归并的结果序列为 D。
A.(30.57.60.80.47 39 ,41,46 )
B.(47.60.57.80.30.39,41.46 )
C.(41.57.60.80.30.39.47.46 )
D.(47,57,6080,30,39,41,46 )

(1)对关键字席列(36,69,46,28,30,74)采用快速排序，以第一个关键字为分割元素，经过一次划分后的结果
序列为 D
A.30，28 ,46.36.69 74B.28，30 .36 .46.69 74C.28，30 .46 .36 . 69 74D.30 ,28 36 ,46 ,69 74

用冒泡法对上述序列排序,经两趟冒泡的结果序列为 A
A.36.28.30.46.69.74
C.38.36.30.46.69.74
8.36.46.28.20.69.74
D.28.36.30.46.69.74

一组记录的关键字序列为(45，40，65，43，35，951写出利用快速排序的方法，以第一个记录为基准得到的一趟划分的结果为 C
A35 40 65 45 35 95B.35 40 65 43 45 95
C35 40 43 45 65 95
D 35 40 45 43 65 95

首页 <上一页 1 2 3 4 下一页> 尾页