数据结构笔试题答案.docx

数据结构笔试题答案.docx

《数据结构笔试题答案.docx》由会员分享，可在线阅读，更多相关《数据结构笔试题答案.docx（76页珍藏版）》请在冰豆网上搜索。

数据结构笔试题答案

数据结构笔试题答案

一、选择题

1.C 

插入排序从后面插入的时候，只要把8和9交换一下就行了，遍历到前面都不再有任何操作。

 冒泡排序第一次循环把9沉到最后面，然后第二次循环发现没有任何交换操作，说明已经排好序了。

2.A

3.D

已知前序和后序不能唯一确定

4.B

5.D

二、填空题

1. 

（1）!

=null 

（2）p->next （3）r!

=null （4）r->datadata （5）r->next （6）p->next 

题中p指向无序区第一个记录，q指向最小值结点，一趟排序结束，p和q所指结点值交换，同时向后移p指针。

2.EACBDGF

3.

sort_b_tree（&（（*tree）->right）,s）

sort_b_tree（&（（*tree）->left）,s）

三、简答题

1.数组和链表的区别，请详细解释。

从逻辑结构来看：

a）数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。

当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费；数组可以根据下标直接存取。

b）链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。

（数组中插入、删除数据项时，需要移动其它数据项，非常繁琐）链表必须根据next指针找到下一个元素

从内存存储来看：

a）（静态）数组从栈中分配空间,对于程序员方便快速,但是自由度小

b）链表从堆中分配空间,自由度大但是申请管理比较麻烦

从上面的比较可以看出，如果需要快速访问数据，很少或不插入和删除元素，就应该用数组；相反，如果需要经常插入和删除元素就需要用链表数据结构了。

2.排序算法有哪些？

排序算法有很多，每种算法有不同的时间和空间复杂度，效率也有差别，那么针对使用上也有不同的场合。

原则上说，数据结构是一门领域，跟语言没有绝对的联系，很多时候同样的算法可以用很多种语言实现。

下面列一些常见的算法：

插入排序，冒泡排序，选择排序，快速排序，堆排序，归并排序，基数排序，希尔排序等。

3.怎么理解哈希表,哈希表是什么

摘自XX：

散列表（Hashtable，也叫哈希表），是根据关键码值（Keyvalue）而直接进行访问的数据结构。

也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。

这个映射函数叫做散列函数，存放记录的数组叫做散列表。

给定表M，存在函数f（key），对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希（Hash）表，函数f（key）为哈希（Hash）函数

4.请写出以下算法的时间复杂度

冒泡排序法插入排序法堆排序法二叉树排序法

O（n^2）O（n^2） O（nlog2n）最差O（n2）平均O（n*log2n）

快速排序法希尔排序法

最差O（n2）平均O（n*log2n）O（nlog n）不稳定

5.数据结构，二叉树的相关知识，开销量，为何使用二叉树等。

在计算机科学中，二叉树是每个结点最多有两个子树的有序树。

通常根的子树被称作“左子树”（leftsubtree）和“右子树”（rightsubtree）。

二叉树常被用作二叉查找树和二叉堆或是二叉排序树。

二叉树的每个结点至多只有二棵子树（不存在出度大于2的结点），二叉树的子树有左右之分，次序不能颠倒。

文件系统和数据库系统一般都采用树（特别是B树）的数据结构数据，主要为排序和检索的效率。

二叉树是一种最基本最典型的排序树，用于教学和研究树的特性，本身很少在实际中进行应用，因为缺点太明显了（看看教科书怎么说的）。

就像冒泡排序一样，虽然因为效率问题并不实用，单不失一种教学例子的好手段。

四、编程题

1.编写一个程序，把一个有序整数数组放在二叉树中。

#include

#include

#include

structstudent

{

intvalue;

structstudent*lchild;

structstudent*rchild;

};

voidarraytotree（int*a,intlen,structstudent**p）

{

if（len）

{

*p=（structstudent*）malloc（sizeof（structstudent））;

（*p）->value=a[len/2];

arraytotree（a,len/2,&（（*p）->lchild））;

arraytotree（a+len/2+1,len-len/2-1,&（（*p）->rchild））;

}

else

{

*p=NULL;

}

}

voiddisplay_tree（structstudent*head）

{

if（head->lchild）display_tree（head->lchild）;

printf（"%d,",head->value）;

if（head->rchild）display_tree（head->rchild）;

}

intmain（）

{

inta[]={1,2,3,4,9,10,33,56,78,90};

structstudent*tree;

arraytotree（a,sizeof（a）/sizeof（a[0]）,&tree）;

printf（"Afterconvert:

\n"）;

display_tree（tree）;

printf（"\n"）;

return0;

}

2.在二叉查找树中查找某一个值所在的位置。

intfind_btree（btree*bt,datatypex）

{

if（bt）{

if（bt->key==x）

returnTRUE;

if（!

find_btree（bt->lchild,x））

if（!

find_btree（bt->rchild,x））

returnFALSE;

}

}

3.二叉树，比父节点大的元素，都在右子树，比父节点小的元素都在左子树。

也就是排序二叉树，写出插入一个节点或者删除一个节点。

#include

#include

#include

#include

#defineTRUE1

#defineFALSE0

typedefintstatus;

typedefintdatatype;

typedefstructnode

{

datatypekey;

structnode*lchild,*rchild;

}btree;

voidbst_insert（btree**bt,datatypekey）//二叉排序树的插入

{

if（NULL==*bt）

{

btree*node=malloc（sizeof（btree））;

node->key=key;

node->lchild=node->rchild=NULL;

*bt=node;

}

elseif（key>（*bt）->key）

{

bst_insert（&（*bt）->rchild,key）;

}

else

{

bst_insert（&（*bt）->lchild,key）;

}

}

statusbst_delete（btree**bt,datatypekey）//二叉排序树的删除

{

btree*tmp=NULL;

if（!

*bt）

{

returnFALSE;

}

else

{

if（key<（*bt）->key）//在左子树中找

{

bst_delete（&（*bt）->lchild,key）;

}

elseif（key>（*bt）->key）//在右子树中找

{

bst_delete（&（*bt）->rchild,key）;

}

else//找到了

{

tmp=*bt;

if（!

（*bt）->lchild）//左子树为空

{

*bt=（*bt）->rchild;

}

elseif（!

（*bt）->rchild）//右子树为空

{

*bt=（*bt）->lchild;

}

free（tmp）;

returnTRUE;

}

}

}

voidpreorder_btree（btree*bt）//二叉树的先序遍历

{

if（bt!

=NULL）{

printf（"%d,",bt->key）;

preorder_btree（bt->lchild）;

preorder_btree（bt->rchild）;

}

}

voidinorder_btree（btree*bt）//二叉树的中序遍历

{

if（bt!

=NULL）{

inorder_btree（bt->lchild）;

printf（"%d,",bt->key）;

inorder_btree（bt->rchild）;

}

}

intmain（intargc,char*argv[]）

{

btree*bt=NULL;

intn;

while

（1）

{

scanf（"%d",&n）;

if（n==0）//输入0则结束

{

break;

}

else

{

bst_insert（&bt,n）;

}

}

preorder_btree（bt）;

putchar（'\n'）;

bst_delete（&bt,8）;

preorder_btree（bt）;

putchar（'\n'）;

return0;

}

4.实现单向链表:

创建链表、插入链表、查询链表、删除特定序号链表节点、遍历剩余链表节点

简单的链表操作，这里假设链表无头结点。

可以自己完善有头结点的单向链表。

头文件：

/*list.h--headerfileforasimplelisttype*/

#ifndef__LIST_H_

#define__LIST_H_

#include

#include

#include

#include/*C99feature*/

#ifdef__cplusplus

extern"C"

#endif/*__cplusplus*/

/*program-specificdeclarations*/

typedefintdataType;

/*generaltypedefinitions*/

typedefdataTypeItem;

typedefstructnode

{

Itemitem;

structnode*next;

}Node;

typedefNode*List;

/*functionprototypes*/

voidListCreate（List*plist）;

boolListIsEmpty（constList*plist）;

boolListIsFull（constList*plist）;

unsignedintListItemCount（constList*plist）;

boolAddItem（Itemitem,List*plist）;

voidEmptyTheList（List*plist）;

voidTraverseTheList（List*plist）;

unsignedintListItemSearch（constList*plist,constItemitem）;

voiddeleteTheListNode（List*plist,unsignedintnum）;

#ifdef__cplusplus

}

#endif/*__cplusplus*/

#endif/*__LIST_H_*/

.c文件

/*list.c--functionssupportinglistoperations*/

#include

#include

#include"list.h"

/*localfunctiondefinition*/

staticvoidCopyToNode（constItemitem,Node*pnode）;

staticvoiddisplayTheNOde（constNode*pnode）;

staticboolItemIsEqu（constItemItem,constNode*pnode）;

/*initaemptylist*/

voidListCreate（List*plist）

{

*plist=NULL;

}

/*returnstrueiflistisempty*/

boolListIsEmpty（constList*plist）

{

if（*plist==NULL）

returntrue;

else

returnfalse;

}

/*returnstrueiflistisfull*/

boolListIsFull（constList*plist）

{

Node*pt;

boolfull;

pt=（Node*）malloc（sizeof（Node））;

if（pt==NULL）

full=true;

else

full=false;

free（pt）;

returnfull;

}

/*returnsnumberofnodes*/

unsignedintListItemCount（constList*plist）

{

unsignedintcount=0;

Node*pnode=*plist;

while（pnode!

=NULL）

{

++count;

pnode=pnode->next;

}

returncount;

}

/*searchiteminthelist*/

unsignedintListItemSearch（constList*plist,constItemitem）

{

intnum=0;

Node*pnode=*plist;

while（pnode!

=NULL）

{

num++;

if（ItemIsEqu（item,pnode））

returnnum;

pnode=pnode->next;

}

return0;

}

/*createsnodetoholditemandaddsittotheendoflist*/

boolAddItem（Itemitem,List*plist）

{

Node*pnew=NULL;

Node*scan=*plist;

pnew=（Node*）malloc（sizeof（Node））;

if（pnew==NULL）

returnfalse;

CopyToNode（item,pnew）;

pnew->next=NULL;

if（scan==NULL）/*emptylist,soplace*/

*plist=pnew;/*pnewatheadoflist*/

else

{

while（scan->next!

=NULL）

scan=scan->next;/*findendoflist*/

scan->next=pnew;/*addpnewtoend*/

}

returntrue;

}

/*deletethenodebynum*/

voiddeleteTheListNode（List*plist,unsignedintnum）

{

Node*pnode=*plist;

Node*psave=NULL;

if（ListIsEmpty（plist））

return;

if（1==num）

{

psave=*plist;

*plist=psave->next;

free（psave）;

return;

}

--num;

while（pnode->next!

=NULL&&num>1）

{

--num;

pnode=pnode->next;

}

if（pnode->next!

=NULL&&1==num）

{

psave=pnode->next;

pnode->next=psave->next;

free（psave）;

}

}

/*TraverseTheList*/

voidTraverseTheList（List*plist）

{

Node*pnode=*plist;

while（pnode!

=NULL）

{

displayTheNOde（pnode）;

pnode=pnode->next;

}

putchar（'\n'）;

}

/*freememoryallocatedbymalloc（）*/

voidEmptyTheList（List*plist）

{

Node*psave=NULL;

while（*plist!

=NULL）

{

psave=（*plist）->next;/*saveaddressofnextnode*/

free（*plist）;/*freecurrentnode*/

*plist=psave;/*advancetonextnode*/

}

}

/*localfunctiondefinition*/

/*copiesanitemintoanode*/

staticvoidCopyToNode（constItemitem,Node*pnode）

{

pnode->item=item;/*structurecopy*/

}

/*displayanodedata*/

staticvoiddisplayTheNOde（constNode*pnode）

{

printf（"%d",pnode->item）;

}

/*Todeterminethenode*/

staticboolItemIsEqu（constItemItem,constNode*pnode）

{

returnItem==pnode->item?

true:

false;

}

5.编程实现判断一个链表是否是递增的

假设链表无头结点.若链表为空默认为递增。

思路之前结点的数据与之后的数据依次比较

typedefintdataType;

/*generaltypedefinitions*/

typedefdataTypeItem;

typedefstructnode

{

Itemitem;

structnode*next;

}Node;

typedefNode*List;

boollistItemIsIncrease（List*plist）

{

Node*preptr=*plist;

Node*curptr=NULL;

if（NULL==*plist）

returntrue;

curptr=preptr->next;

while（curptr!

=NULL）

{

if（preptr->item>curptr->item）/*如果是严格递增，则判断用>=*/

break;

preptr=curptr;

curptr=curptr->next;

}

return（curptr==NULL）?

true:

false;

}

6.编程实现删除链表中的重复节点

假设链表无头结点，挨个遍历链表数据，与之后的结点依次比较，发现重复的就删除

typedefintdataType;

/*generaltypedefinitions*/

typedefdataTypeItem;

typedefstructnode

{

Itemitem;

structnode*next;

}Node;

typedefNode*List;

voiddelRepeatedNodeOnce（List*plist）

{

Node*p=*plist,*q,*u,*y;

while（p）

{

q=p->next;

u=p;

while（q）

{

if（q->item==p->item）

{

u->next=q->next;y=q;

q=q->next;

free（y）;

}

else

{

u=q;

q=q->next;

}

}

p=p->next;

}

}

7.只遍历一次链表，实现链表的倒序

假设链表无头节点，链表头插入，直到遍历到链表末尾

typedefintdataType;

/*generaltypedefinitions*/

typedefdataTypeItem;

typedefstructnode

{

Itemitem;

structnode*next;

}Node;

typedefN