北方工业大学数据结构期末复习题.docx

北方工业大学数据结构期末复习题.docx

《北方工业大学数据结构期末复习题.docx》由会员分享，可在线阅读，更多相关《北方工业大学数据结构期末复习题.docx（15页珍藏版）》请在冰豆网上搜索。

北方工业大学数据结构期末复习题

1.如下为二分查找的非递归算法，试将其填写完整。

IntBinsch（ElemTypeA[],intn,KeyTypeK）

{

intlow=0;

inthigh=n-1;

while（low<=high）

{

intmid=_______________________________；

if（K==A[mid].key）returnmid;//查找成功，返回元素的下标

elseif（K

______________________________________;//在左子表上继续查找

else__________________________________;//在右子表上继续查找

}

return-1;//查找失败，返回-1

}

（low+high）/2high=mid-1low=mid+1

2.                    intPrime（intn）

{

inti=1;

intx=（int）sqrt（n）;

while（++i<=x）

if（n%i==0）break;

if（i>x）return1;

elsereturn0;

}

（1）    指出该算法的功能；

（2）    该算法的时间复杂度是多少？

2.        

（1）判断n是否是素数（或质数）

（2）O（

）

3.已知一个图的顶点集V和边集E分别为：

V={1,2,3,4,5,6,7};E={（1,2）3,（1,3）5,（1,4）8,（2,5）10,（2,3）6,（3,4）15,（3,5）12,（3,6）9,（4,6）4,（4,7）20,（5,6）18,（6,7）25}.用克鲁斯卡尔（Kruskal）算法和prim算法得到最小生成树，试写出在最小生成树中依次得到的各条边。

3.    用克鲁斯卡尔算法得到的最小生成树为：

（1,2）3,（4,6）4,（1,3）5,（1,4）8,（2,5）10,（4,7）20

4.   LinkListmynote（LinkListL）

{//L是不带头结点的单链表的头指针

if（L&&L->next）{

q=L；L=L－>next；p=L；

S1：

while（p－>next）p=p－>next；

S2：

p－>next=q；q－>next=NULL；

}

returnL；

}

请回答下列问题：

（1）说明语句S1的功能；

（2）说明语句组S2的功能；

（3）设链表表示的线性表为（a1,a2,…,an）,写出算法执行后的返回值所表示的线性表。

4.  

（1）查询链表的尾结点

（2）将第一个结点链接到链表的尾部，作为新的尾结点

（3）返回的线性表为（a2,a3,…,an,a1）

5. voidABC（BTNode*BT）

{

ifBT{

ABC（BT->left）;

ABC（BT->right）;

cout<data<<'';

}

}

该算法的功能是：

递归地后序遍历链式存储的二叉树。

6．已知二叉树的存储结构为二叉链表，阅读下面算法。

typedefstructnode{

DateTypedata；

Structnode*next；

}ListNode；

typedefListNode*LinkList；

LinkListLeafhead=NULL；

VoidInorder（BinTreeT）

{

LinkLists；

If（T）{

Inorder（T－>lchild）；

If（（!

T－>lchild）&&（!

T－>rchild））{

s=（ListNode*）malloc（sizeof（ListNode））；

s－>data=T－>data；

s－>next=Leafhead；

Leafhead=s；

}

Inorder（T－>rchild）；

}

}

对于如下所示的二叉树

（1）画出执行上述算法后所建立的结构；

（2）说明该算法的功能。

6.

（1）Leafhead

F

H

G

D

∧

（2）中序遍历二叉树，按遍历序列中叶子结点数据域的值构建一个以Leafhead为头指针的逆序单链表（或按二叉树中叶子结点数据自右至左链接成一个链表）。

7．已知一个无向图的顶点集为{a,b,c,d,e},其邻接矩阵如下所示

a

b

c

d

e

（1）画出该图的图形；

（2）根据邻接矩阵从顶点a出发进行深度优先遍历和广度优先遍历，写出相应的遍历序列。

7．该图的图形为：

深度优先遍历序列为：

abdce

广度优先遍历序列为：

abedc

8．已知一个散列表如下图所示：

35

20

33

48

59

0123456789101112

其散列函数为h（key）=key%13,处理冲突的方法为双重散列法，探查序列为：

hi=（h（key）+

*h1（key））%m

=0,1,…，m－1

其中

h1（key）=key%11+1

回答下列问题：

（1）对表中关键字35，20，33和48进行查找时，所需进行的比较次数各为多少？

（2）该散列表在等概率查找时查找成功的平均查找长度为多少？

8．（１）对关键字35、20、33和48进行查找的比较次数为３、２、１、１；

（２）平均查找长度

9．下列算法的功能是比较两个链串的大小，其返回值为：

comstr（s1,s2）=

请在空白处填入适当的内容。

intcomstr（LinkStrings1,LinkStrings2）

{//s1和s2为两个链串的头指针

while（s1&&s2）{

if（s1－>datadata）return－1；

if（s1－>data>s2－>data）return1；

①；

②；

}

if（③）return－1；

if（④）return1；

⑤；

}

9．①S1=S1－>next

②s2=s2－>next

③s2（或s2!

=NULL或s2&&!

s1）

④s1（或s1!

=NULL或s1&&!

s2）

⑤return0

1．算法指的是（）

A．计算机程序B．解决问题的计算方法

C．排序算法D．解决问题的有限运算序列

2．线性表采用链式存储时，结点的存储地址（）

A．必须是不连续的

B．连续与否均可

C．必须是连续的

D．和头结点的存储地址相连续

1.下面程序段的时间复杂度是（D）

for（i=0;I

for（j=1;j

A[i][j]=0；

A.O（n）B.O（m+n+1）C.O（m+n）D.O（m*n）

2.在单链表中，指针p指向元素为x的结点，实现“删除x的后继”的语句是（B）A.p=p->next;B.p->next=p->next->next;

C.p->next=p;D.p=p->next->next;

3.在头指针为head且表长大于1的单循环链表中，指针p指向表中某个结点，若p->next->next=head,则（D）

A.p指向头结点B.p指向尾结点

C.*p的直接后继是头结点D.*P的直接后继是尾结点

7.一棵含18个结点的二叉树的高度至少为（C）

D.6

8.已知二叉树的先序序列为ABDECF，中序序列为DBEAFC，则后序序列为（D）

9.无向图中一个顶点的度是指图中（B）

A.通过该顶点的简单路径数B.与该顶点相邻接的顶点数

C.通过该顶点的回路数D.与该顶点连通的顶点数

10.已知一个图如下所示，从顶点a出发进行广度优先遍历可能得到的序列为（C）

A.acefbdB.acbdfeC.acbdefD.acdbfe

16．数据的逻辑结构是从逻辑关系上描述数据，它与数据的无关，是独立于计算机的。

17．在一个带头结点的单循环链表中，p指向尾结点的直接前驱，则指向头结点的指针head可用p表示为head=。

18．栈顶的位置是随着操作而变化的。

19．在串S=“structure”中，以t为首字符的子串有个。

22．已知一个图的广度优先生成树如右图所示，则与此相

应的广度优先遍历序列为。

24．在有序表（12，24，36，48，60，72，84）中二分查找关键字72时所需进行的关键字比较次数为。

16．存储（或存储结构）17.p－＞next－＞next

18．进栈和退栈19．1222．abefcdg24．２

10．阅读下列函数arrange（）

intarrange（inta[],int1,inth,intx）

{//1和h分别为数据区的下界和上界

inti,j,t；

i=1；j=h；

while（i

while（i=x）j--；

while（i=x）i++；

if（i

{t=a[j]；a[j]=a[i]；a[i]=t；}

}

if（a[i]

elsereturni－1；

}

（1）写出该函数的功能；

（2）写一个调用上述函数实现下列功能的算法：

对一整型数组b[n]中的元素进行重新排列，将所有负数均调整到数组的低下标端，将所有正数均调整到数组的高下标端，若有零值，则置于两者之间，并返回数组中零元素的个数。

10.

（1）该函数的功能是：

调整整数数组a[]中的元素并返回分界值i，使所有＜x的元素均落在a[1..i]上，使所有≥x的元素均落在a[i＋1..h]上。

（2）intf（intb[],intn）或intf（intb[],intn）

{{

intp,q；intp,q；

p=arrange（b,0,n－1,0）；p=arrange（b,0,n－1,1）；

q=arrange（b,p+1,n－1,1）；q=arrange（b,0,p,0）；

returnq－p；returnp－q；

}}

11.假设通信电文使用的字符集为{a,b,c,d,e,f}，名字符在电文中出现的频度分别为：

34，5，12，23，8，18，试为这6个字符设计哈夫曼编码。

请先画出你所构造的哈夫曼树（要求树中左孩子结点的权值小于右孩子结点的权值），然后分别写出每个字符对应的编码。

13．希尔排序的增量序列必须是（　　　）

A．递增的      B．随机的C．递减的      D．非递减的

11．在一个带权连通图G中，权值最小的边一定包含在G的（　　　）A．最小生成树中     B．深度优先生成树中

C．广度优先生成树中    D．深度优先生成森林中

16．下列程序段的时间复杂度为_O（n^2）_

　　product = 1;

　　for （i = n;i>0; i--）

　　　for （j = i+1; j

17．已知指针p指向单链表中某个结点，则语句p -> next =p -> next -> next的作用是________________。

删除*P的直接后继结点

18．假设元素只能按a,b,c,d的顺序依次进栈，且得到的出栈序列中的第一个元素为c，则可能得到的出栈序列为________________，不可能得到的出栈序列为________________1）cbad, cbda, cdba

2）cabd, cadb, cdab

12．设栈S1的入栈序列为1 2 3 4（每个数字为13个元素），则不可能得到出栈序列3142。

但可通过增设栈S2来实现。

例如，按下图中的箭头指示，依次经过栈S1和S2，便可得到序列3 1 4 2。

如果用H1和H2分别表示栈S1和S2的进栈操作，用P1和P2分别表示两个栈的出栈操作，则得到3 1 4 2的一个操作步骤为

　　H1，H1，H1，P1，H2，P2，P1，H2，P1，H2，P2，H1，P1，H2，P2，P2

　　　请仿照上例写出利用两个栈从1 2 3 4得到4 1 3 2的操作步骤。

H1,P1,H2,H1,H1,H1,P1,H2,P2,P2,P1,H2,P2,P1,H2,P2

30．下列函数的功能是，对以带头结点的单链表作为存储结构的两个递增有序表（表中不存在值相同的数据元素）进行如下操作：

将所有在Lb表中存在而La表中不存在的结点插入到La中，其中La和Lb分别为两个链表的头指针。

请在空缺处填入合适内容，使其成为一个完整的算法。

void union （LinkList La, LinkList Lb）

{

  //本算法的功能是将所有Lb表中存在而La表中不存在的结点插入到La表中

  LinkList pre = La, q;

  LinkList pa = La -> next;

  LinkList pb = Lb -> next;

  free （Lb）;

  while （pa && pd）

  {

   if （pa -> data  data）

   {  pre = pa; pa = pa -> next;}

   else if （pa -> data > pb ->data）

   {

（1）       ;

    pre = pb;

    pb = pb -> next;          

（2）       ;

   }

   else

   {

    q = pb; pb = pb -> next; free （q）;

   }

  }

  if （pb）

          （3）         ;

}

（1） pre->next = pb

（2） pre->next = pa

（3） pre->next = pb

33.已知整形数组L［1..8］中的元素依次为（9，8，5，7，6，3，2，1），阅读下列函数，并写出执行函数调用　sort（L, 8）时，对L进行的头两趟（pass分别为0和1）处理结果。

Void sort （int R[],int n）

{ int pass = 0, k, exchange, x; do {  k=pass%2+1;  exchange = 0;  while （kR[k+1]）  {   x = R[k]; R[k] = R[k+1]; R[k+1] = x;   exchange =1;

     }

K+=2

         }       

   pass ++;

   }while （exchange = = 1|| pass <=1）;

}第一趟（pass = 0）:

 8 9 5 7 3 6 1 2第二趟（pass = 1）:

 8 5 9 3 7 1 6 2

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

A. （19，23，56，34，78，67，88，92）         B. （23，56，78，66，88，92，19，34）

C. （19，23，34，56，67，78，88，92）         D. （19，23，67，56，34，78，92，88）

30. 阅读下列算法，并回答问题：

（1）设顺序表L=（3,7,11,14,20,51），写出执行f30（&L,15）之后的L；

（2）设顺序表L=（4,7,10,14,20,51），写出执行f30（&L,10）之后的L；

（3）简述算法的功能。

void f30（SeqList*L, DataType x）

{

     int i =0, j;

     while （ilength && x>L->data［i］）i++;

     if（ilength && x==L->data［i］）  {//找到x，则删除x，大于x的数前移

        for（j=i+1;jlength;j++）

            L->data［j-1］=L->data［j］;

        L->length--;

     } else {//没找到，插入x, 大于x的数后移

        for（j=L->length;j>i;j--）

            L->data［j］=L->data［j-1］;

        L->data［i］=x;

        L->length++;

     }

}

（1） L=（3,7,11,14,15,20,51）

（2） L=（4,7,14,20,51）

（3） 在顺序表L中查找数x,

    找到，则删除x，

    没找到，则在适当的位置插入x，插入后，L依然有序.31. 已知图的邻接表表示的形式说明如下：

#define MaxNum   50         //图的最大顶点数

typedef struct node {

  int   adjvex;             //邻接点域

  struct node *next;         //链指针域

} EdgeNode;              //边表结点结构描述

typedef struct {

  char vertex;              //顶点域

  EdgeNode   *firstedge;    //边表头指针

} VertexNode;   //顶点表结点结构描述

typedef struct {

  VertexNode adjlist［MaxNum］;   //邻接表

  int n, e;                       //图中当前的顶点数和边数

} ALGraph;   //邻接表结构描述

    下列算法输出图G的深度优先生成树（或森林）的边。

阅读算法，并在空缺处填入合适的内容，使其成为一个完整的算法。

typedef enum {FALSE, TRUE} Boolean;

Boolean visited［MaxNum］;

void DFSForest（ALGraph *G）{

     int i;     for（i=0;in;i++） visited［i］= ________

（1）;

     for（i=0;in;i++） if （!

visited［i］） DFSTree（G,i）;

}

void DFSTree（ALGraph *G, int i） {

     EdgeNode *p;

     visited［i］=TRUE;

     p=G->adjlist［i］.  firstedge;

     while（p!

=NULL）{

          if（!

visited［p->adjvex］）{

            printf（″<%c,%c>″,G->adjlist［i］. vertex,

                             G->adjlist［p->adjvex］. vertex）;              ________

（2） ;

             }

              ________（3）        ;

     }

}

（1） FALSE //初始化为未访问

（2） DSFTree（ G, p->adjvex ）; //从相邻结点往下继续深度搜索

（3） p = p->next; //下一个未访问的相邻结点

12．快速排序在最坏情况下的时间复杂度是（　　B　）

A．O（n2log2n）        B．O（n2）

C．O（nlog2n）         D．O（log2n）

13．能进行二分查找的线性表,必须以（　A　　）

A．顺序方式存储,且元素按关键字有序

B．链式方式存储,且元素按关键字有序

C．顺序方式存储,且元素按关键字分块有序

D．链式方式存储,且元素按关键字分块有序