算法与数据结构试卷
A. 求《算法与数据结构考研试题精析第三版》全文免费下载百度网盘资源,谢谢~
《算法与数据结构考研试题精析第三版》网络网盘pdf最新全集下载:
链接: https://pan..com/s/1hdJxho2NwiuZLzCNLVmA5A
简介：《算法与数据结构考研试题精析（第4版）》可以作为高等院校计算机及相关专业数据结构课程的参考书，也可作为相关专业硕士研究生考试的参考书，同时适用于讲授该课程的教师以及希望学习数据结构课程的其他人员。
B. 求数据结构试题…重点
这是我们老师要求的重点，即考点。打印出来，背一下就行了，准过！
第一章：绪论
1.1：数据结构课程的任务是：讨论数据的各种逻辑结构、在计算机中的存储结构以及各种操作的算法设计。
1.2：数据：是客观描述事物的数字、字符以及所有的能输入到计算机中并能被计算机接收的各种集合的统称。
数据元素：表示一个事物的一组数据称作是一个数据元素，是数据的基本单位。
数据项：是数据元素中有独立含义的、不可分割的最小标识单位。
数据结构概念包含三个方面：数据的逻辑结构、数据的存储结构的数据的操作。
1.3数据的逻辑结构指数据元素之间的逻辑关系，用一个数据元素的集合定义在此集合上的若干关系来表示，数据结构可以分为三种：线性结构、树结构和图。
1.4：数据元素及其关系在计算机中的存储表示称为数据的存储结构，也称为物理结构。
数据的存储结构基本形式有两种：顺序存储结构和链式存储结构。
2.1：算法：一个算法是一个有穷规则的集合，其规则确定一个解决某一特定类型问题的操作序列。算法规则需满足以下五个特性：
输入——算法有零个或多个输入数据。
输出——算法有一个或多个输出数据，与输入数据有某种特定关系。
有穷性——算法必须在执行又穷步之后结束。
确定性——算法的每个步骤必须含义明确，无二义性。
可行性——算法的每步操作必须是基本的，它们的原则上都能够精确地进行，用笔和纸做有穷次就可以完成。
有穷性和可行性是算法最重要的两个特征。
2.2：算法与数据结构：算法建立数据结构之上，对数据结构的操作需用算法来描述。
算法设计依赖数据的逻辑结构，算法实现依赖数据结构的存储结构。
2.3：算法的设计应满足五个目标：
正确性：算法应确切的满足应用问题的需求，这是算法设计的基本目标。
健壮性：即使输入数据不合适，算法也能做出适当的处理，不会导致不可控结
高时间效率：算法的执行时间越短，时间效率越高。 果。
高空间效率：算法执行时占用的存储空间越少，空间效率越高。
可读性：算法的可读性有利于人们对算法的理解。
2.4：度量算法的时间效率，时间复杂度，（课本39页）。
2.5：递归定义：即用一个概念本身直接或间接地定义它自己。递归定义有两个条件：
至少有一条初始定义是非递归的，如1！=1.
由已知函数值逐步递推计算出未知函数值，如用（n-1）！定义n！。
第二章：线性表
1.1线性表：线性表是由n(n>=0)个类型相同的数据元素a0,a1,a2,…an-1,组成的有限序列,记作： LinearList = (a0,a1,a2,…an-1)
其中，元素ai可以是整数、浮点数、字符、也可以是对象。n是线性表的元素个数，成为线性表长度。若n=0，则LinearList为空表。若n>0，则a0没有前驱元素，an-1没有后继元素，ai（0<i<n-1）有且仅有一个直接前驱元素ai-1和一个直接后继元素ai+1。
1.2线性表的顺序存储是用一组连续的内存单元依次存放线性表的数据元素，元素在内存的物理存储次序与它们在线性表中的逻辑次序相同。
线性表的数据元素数据同一种数据类型，设每个元素占用c字节，a0的存储地址为
Loc（a0），则ai的存储地址Loc（ai）为：Loc（ai） = Loc（a0）+ i*c
数组是顺序存储的随机存储结构，它占用一组连续的存储单元，通过下标识别元素，元素地址是下标的线性函数。
1.3：顺序表的插入和删除操作要移动数据元素。平均移动次数是 属数据表长度的一半。（课本第50页）
1.4：线性表的链式存储是用若干地址分散的存储单元存储数据元素，逻辑上相邻的数据元素在物理位置上不一定相邻，必须采用附加信息表示数据元素之间的顺序关系。
它有两个域组成：数据域和地址域。通常成为节点。（课本第55页及56页）
1.5单链表（课本56页）
单链表的遍历：Node<E> p = head; while(p!=null){ 访问p节点；p = p.next;}
单链表的插入和删除操作非常简便，只要改变节点间的链接关系，不需移动数据元素。
单链表的插入操作：1）：空表插入/头插入 2)中间插入/尾插入
if(head == null) Node<E> q = new Node<E>(x);
{ head = new Node<E>(x); q.next = p.next;
}else{ p.next = q;
Node<E> q=new Node<E>(x); 中间插入或尾插入都不会改变单表
q.next = head; 的头指针head。
head = q;
}
单链表的删除操作：
头删除：head = head.next;
中间/尾删除：if(p.next!=null){ p.next = p.next.next;}
循环单链表：如果单链表最后一个节点的next链保存单链表的头指针head值，则该单链表成为环形结构，称为循环单链表。（课本67）
若rear是单链表的尾指针，则执行（rear.next=head;）语句，使单链表成为一条循环单链表。当head.next==head时，循环单链表为空。
1.6：双链表结构：双链表的每个结点有两个链域，分别指向它的前驱和后继结点，
当head.next==null时，双链表为空。
设p指向双链表中非两端的某个结点，则成立下列关系：p=p.next.prev=p.prev.next。
双链表的插入和删除：1）插入 2)删除
q=new DLinkNode（x）； p.prev.next = p.next;
q.prev=p.prev;q.next =p; if(p.next=null){
p.prev.next = q;p.prev=q; (p.next).prev = p.prev;}
循环双链表：当head.next==head且head.prev==head时，循环双链表为空。
第三章：栈和队列
1.1栈：栈是一种特殊的线性表，其中插入和删除操作只允许在线性表的一端进行。允许操作的一端称为栈顶，不允许操作的一端称为栈底。栈有顺序栈和链式栈。
栈中插入元素的操作称为入栈，删除元素的操作称为出栈。没有元素的中称为空栈。
栈的进出栈顺序：后进先出，先进后出。（及75页的思考题）。
1.2：队列：队列是一种特殊的线性表，其中插入和删除操作分别在线性表的两端进行。
向队列中插入元素的过程称为入队，删除元素的过程称为出对，允许入队的一端称为队尾，允许出队的一端称为对头。没有元素的队列称为空队列。队列是先进先出。
第四章：串
1.1：串是一种特殊的线性表，其特殊性在于线性表中的每个元素是一个字符。一个串记为： s=“s0s1s2…sn-1” 其中n>=0,s是串名，一对双引号括起来的字符序列s0s1s2…sn-1是串值，si（i=0，1，2，…n-1）为特定字符集合中的一个字符。一个串中包含的字符个数称为串的长度。
长度为0的串称为空串，记作“”，而由一个或多个空格字符构成的字符串称为空格串。
子串：由串s中任意连续字符组成的一个子序列sub称为s的子串，s称为sub的主串。子串的序号是指该子串的第一个字符在主串中的序号。
串比较：两个串可比较是否相等，也可比较大小。两个串（子串）相等的充要条件是两个串（子串）的长度相同，并且各对应位置上的字符也相同。
两个串的大小由对应位置的第一个不同字符的大小决定，字符比较次序是从头开始依次向后。当两个串长度不等而对应位置的字符都相同时，较长的串定义为较“大”。
第五章：数组和广义表
1.1：数组是一种数据结构，数据元素具有相同的数据类型。一维数组的逻辑结构是线性表，多维数组是线性表的扩展。
1.2：一维数组：一维数组采用顺序存储结构。一个一维数组占用一组连续的存储单元。
设数组第一个元素a0的存储地址为Loc（a0），每个元素占用c字节，则数组其他元素ai的存储地址Loc（ai）为： Loc（ai）= Loc（a0）+i*c
数组通过下标识别元素，元素地址是下标的线性函数。一个下标能够唯一确定一个元素，所划给的时间是O（1）。因此数组是随机存取结构，这是数组最大的优点。
1.3：多维数组的遍历：有两种次序：行主序和列主序。
行主序：以行为主序，按行递增访问数组元素，访问完第i行的所有元素之后再访问第i+1行的元素，同一行上按列递增访问数组元素。
a00,a01,…a0(n-1), a10,a11,…a1(n-1),…a(m-1)0,a(m-1)1,…,a(m-1)(n-1)
2)列主序：以列为主序，按列递增访问数组元素，访问完第j列的所有元素之后再访问第j+1列的元素，同一列上按列递增访问数组元素。
多维数组的存储结构：多维数组也是由多个一维数组组合而成，组合方式有一下两种。
静态多维数组的顺序存储结构：可按行主序和列主序进行顺序存储。
按行主序存储时，元素aij的地址为：Loc（aij）= Loc（a00）+（i*n+j）*c
按列主序存储时，Loc（aij）= Loc（a00）+（j*m+i）*c
动态多维数组的存储结构。
二维数组元素地址就是两个下标的线性函数。无论采用哪种存储结构，多维数组都是基于一维数组的，因此也只能进行赋值、取值两种存取操作，不能进行插入，删除操作。
第六章：
树是数据元素（结点）之间具有层次关系的非线性结构。在树结构中，除根以外的结点只有一个直接前驱结点，可以有零至多个直接后继结点。根没有前驱结点。
树是由n（n>=0）个结点组成的有限集合（树中元素通常称为结点）。N=0的树称为空树；n>0大的树T；
@有一个特殊的结点称为根结点，它只有后继结点，没有前驱结点。
@除根结点之外的其他结点分为m（m>=0）个互不相交的集合T0,T1,T3……..,Tm-1，其中每个集合Ti（0<=i<m）本身又是一棵树，称为根的子树。
树是递归定义的。结点是树大的基本单位，若干个结点组成一棵子树，若干棵互不相交的子树组成一棵树。树的每个结点都是该树中某一棵子树的根。因此，树是由结点组成的、结点之间具有层次关系大的非线性结构。
结点的前驱结点称为其父母结点，反之，结点大的后继结点称为其孩子结点。一棵树中，只有根结点没有父母结点，其他结点有且仅有一个父母结点。
拥有同一个父母结点的多个结点之间称为兄弟结点。结点的祖先是指从根结点到其父母结点所经过大的所有结点。结点的后代是指该结点的所有孩子结点，以及孩子的孩子等。
结点的度是结点所拥有子树的棵数。度为0的结点称为叶子结点，又叫终端结点；树中除叶子结点之外的其他结点称为分支结点，又叫非叶子结点或非终端结点。树的度是指树中各结点度的最大值。
结点的层次属性反应结点处于树中的层次位置。约定根结点的层次为1，其他结点的层次是其父母结点的层次加1。显然，兄弟结点的层次相同。
树的高度或深度是树中结点的最大层次树。
设树中x结点是y结点的父母结点，有序对（x，y）称为连接这两个结点的分支，也称为边。
设（X0,X1,….,Xk-1）是由树中结点组成的一个序列，且（Xi，Xi+1）（0<=i<k-1）都是树中的边，则该序列称为从X0到Xk-1的一条路径。路径长度为路径上的边数。
在树的定义中，结点的子树T0，T1…..,Tm-1之间没有次序，可以交换位置，称为无序树，简称树。如果结点的子树T0,T1……,Tm-1从左到右是有次序的，不能交换位置，则 称该树为有序树。
森林是m（m>=0）棵互不相干的树的集合。给森林加上一个根结点就变成一棵树，将树的根节点删除就变成森林。
二叉树的性质1：若根结点的层次为1，则二叉树第i层最多有2 的i-1次方（i>=1）个结点。
二叉树的性质2：在高度为k的二叉树中，最多有2的k次方减一个结点。
二叉树的性质3：设一棵二叉树的叶子结点数为n0,2度结点数为n2，则n0=n2+1。
一棵高度为k的满二叉树是具有2的k次方减一个结点的二叉树。满二叉树中每一层的结点数目都达到最大值。对满二叉树的结点进行连续编号，约定根节点的序号为0，从根节点开始，自上而下，每层自左至右编号。
一棵具有n个结点高度为k的二叉树，如果他的每个节点都与高度为k的满二叉树中序号为0~n-1
的结点一一对应，则这棵二叉树为为完全二叉树。
满二叉树是完全二叉树，而完全二叉树不一定是满二叉树。完全二叉树的第1~k-1层是满二叉树第k层不满，并且该层所有结点必须集中在该层左边的若干位置上。
二叉树的性质4：一棵具有n个结点的完全二叉树，其高度k=log2n的绝对值+1
二叉树的性质5：一棵具有n个结点的完全二叉树，对序号为i的结点，有
@若i=0，则i为根节点，无父母结点；若i>0，则i的父母结点的序号为[（i-1）/2]。
@若2i+1<n，则i的左孩子结点序号为2i+1；否则i无左孩子。
@若2i+2<n，则i的右孩子结点的序号为2i+2，否则i无右孩子。
二叉树的遍历
二叉树的遍历是按照一定规则和次序访问二叉树中的所有结点，并且每个结点仅被访问一次。
二叉树的三种次序遍历
1：先根次序；访问根节点，遍历左子树，遍历右子树。
2：中根次序；遍历左子树，访问右子树，遍历右子树。
3：后根次序；遍历左子树，遍历右子树，访问根节点。
先根次序遍历时，最先访问根节点；后根次序遍历时，最后访问根节点；中根次序遍历时，左子树上的结点在根节点之前访问，右子树上的结点在根节点之后访问。
二叉树的插入和删除操作P147
二叉树的层次遍历P149
习题P167 6—10，6—19
第七章
图是由定点集合及顶点间的关系集合组成的一种数据关边系。顶点之间的关系成为边。一个图G记为G=（V,E），V是顶点A的有限集合，E是边的有限集合。即 V={A|A属于某个数据元素集合}
E={(A,B)|A,B属于V}或E={<A,B>|A,B属于V且Path（A,B）}其中Path（A,B）表示从顶点A到B的一条单向通路，即Path（A,B）是有方向的。
无向图中的边事没有方向，每条边用两个顶点的无序对表示。
有向图中的边是有方向，每条边用两个顶点的有序对表示。
完全图指图的边数达到最大值。n个顶点的完全图记为Kn。无向完全图Kn的边数为n*（n-1）/2,有向完全图Kn的边数为n*（n-1）。
子图：设图G==(V,E),G’=(V’,E’)，若V’包含于V且E’包含于E,则称图G’是G的子图。若G’是G的真子图。
连通图：在无向图G中，若从顶点VI到Vj有路径，则称Vi和Vj是联通的。若图G中任意一对顶点Vi和Vj（Vi不等于Vj）都是联通的，则称G为连通图。非连通图的极大联通子图称为该图的联通分量。
强连通图：在有向图中，若在每一对顶点Vi和Vj（Vi不等于Vj）之间都存在一条从Vi到Vj的路径，也存在一条从Vi到Vj的路径，也存在一条从Vi到Vj的路径，则称该图的强连通图。非强连通图的极大强连通子图称为该图的强连通图分量。
图的遍历
遍历图是指从图G中任意一个顶点V出发，沿着图中的边前行，到达并访问图中的所有顶点，且每个顶点仅被访问一次。遍历图要考虑一下三个问题：
@指定遍历的第一个访问顶点
@由于一个顶点可能与多个顶点相邻，因此要在多个邻接顶点之间约定一种访问次序。
@由于图中可能存在回路，在访问某个顶点之后，可能沿着某条路径又回到该顶点。
深度优先搜索
图的深度优先搜索策略是，访问某个顶点v，接着寻找v的另一个未被访问的邻接顶点w访问，如此反复执行，走过一条较长路径到达最远顶点；若顶点v没有未被访问的其他邻接顶点，则回到前一个被访问顶点，再寻找其他访问路径。
图的深度优先搜索遍历算法P188
联通的无回路的无向图，简称树。树中的悬挂点又成为树叶，其他顶点称为分支点。各连通分量均为树的图称为森林，树是森林。
由于树中无回路，因此树中必定无自身环也无重边（否则他有回路）若去掉树中的任意一条边，则变成森林，成为非联通图；若给树加上一条边，形成图中的一条回路，则不是树。P191
生成树和生成森林：
一个连通无向图的生成树是该图的一个极小联通生成子图，它包含原图中所有顶点（n个）以及足以构成一棵树的n-1条边。
一个非联通的无向图，其各连通图分量的生成图组成该图的生成森林。
图的生成图或生成森林不是唯一的，从不同顶点开始、采用不同遍历可以得到不同的生成树或森林。
在生成树中，任何树中，任何两个顶点之间只有唯一的一条路径。
第八章
折半查找算法描述 P206,P207
二叉排序树及其查找：
二叉排序树或者是一棵空树；或者是具有下列性质的二叉树：
@每个结点都有一个作为查找依据的关键字，所有结点的关键字互不相同。
@若一个结点的左子树不空，则左子树上所有结点的关键字均小于这个节点的关键字；
@每个结点的左右子树也分别为二叉排序树。
在一棵二叉排序树中，查找值为value的结点，算法描述如下：
@从根结点开始，设p指向根结点
@将value与p结点的关键字进行比较，若两者相等，则查找成功；若value值较小，则在p的左子树中继续查找；若value值较大，则在p的右子树中继续查找。
@重复执行上一步，直到查找成功或p为空，若p为空，则查找不成功。
习题 8-6
第九章
直接插入排序算法描述：p228
冒泡排序算法的描述：p232
快速排序算法描述p233
直接选择排序算法描述p236
直接选择排序算法实现如下：
Public static void selectSort(int[]table){
for(int i=0;i<table.length-1;i++){
int min=I;
for(int j=i+1;j<table.length;j++){
if(table[j]<table[min])
min=j;
if(min!=i){
int temp=table[i];
table[i]==table[min];
table[min]=temp;
}
}
}
}
堆排序是完全二叉树的应用，是充分利用完全二叉树特性的一种选择排序。
堆定义：设n个元素的数据序列{k0，k1，。。。。kn-1}，当且仅当满足下列关系
k1<=k2i+1且ki<=k2i+2 i=0,1,2,3,….,[n/2-1]
或ki>==k2i+1且ki>=2i+2i=0,1,2,3,…..[n/2-1]时，序列{k0，k1…….kn-1}称为最小堆或最大堆。将最小（大）堆看成是一颗完全二叉树的层次遍历序列，则任意一个结点的关键字都小于等于（大于等于）它的孩子节点的关键字值，由此可知，根结点值最小（大）。根据二叉树的性质5，完全二叉树中的第i（0<=i<n）个结点，如果有孩子，则左孩子为第2i+1个结点，右孩子为第2i+2个结点。
希望对你会有所帮助。
C. 数据结构与算法试题，高分，求答案啊
给你第一题解法吧：后面的实在是不想做。
先根：ABCDEFGHI
中根：CBEDAGFHI
遍历的基本方法：先左子树后右子树。
1,先根遍历可以确定根节点为A,
2,依据1步，可以在中根遍历中确定左子树为：CBED,右为：GFHI
3,在可以重复1,2步。就可以得到结果。
A
BF
CDGH
I
4,O(n^3)+O(1)
D. 求下面数据结构试题的答案...
一．
1,复杂性2.线性结构非线性结构
3．可以按序号随机存取4.数据元素
5.后进先出6.n7.只能在队头进行
9.长度1深度1
10-+A*BC/DE
11
12顶点Vp到顶点Vq之间的路径是指定的序列Vp，Vi1，Vi2•••Vim，Vq。
13n（n-2）/214n—1152n—1
17一种存储结构
19可以从表中任意结点开始遍历整个链表；只用一个指向尾结点的指针对链表头、尾进行操作，提高了效率。
20栈是仅限制在表的一端进行插入和删除的运算的线性表，是一种操作受限的线性表。
二．
1算法的时间复杂度和空间复杂度
2.队列
3.
4嵌套集合表示法，广义表表示法，凹入表示法
5.456.S(1)X(1)S(2)S(3)X(3)S(4)X(4)X(2)
7（1）O（nˆ2）
（2）O（nˆ2）
8.
哈夫曼树：
WPL=2*5+4*5+5*4+16*3+8*3+7*3+30=173
9.邻接矩阵：
邻接表：
10.二叉树：
前序：ABCEFD
中序：BEFCDA
后序：FEDCBA
E. 数据结构算法 试题 急！ 试构造下图的最小生成树，要求分步给出构造过程。
图有如下参数:
边数=8顶点数=5
顶点顶点边的权值
v1v26
v1v34
v1v42
v2v35
v2v48
v2v56
v3v45
v4v57
用Kruskal(克鲁斯卡尔)算法,求最小生成树.
先将所有边的权值按照从小到大排序:
顶点顶点边的权值
v1v42
v1v34
v2v35
v3v45
v1v26
v2v56
v4v57
v2v48
然后,每次提取权值最小边,逐步组成最小生成树:
(1)取最小边(v1,v4,2)
v1--v4
(2)取边(v1,v3,4),不会产生环路.
v1--v4
|
|
v3
(3)取边(v2,v3,5),不会产生环路.
v1--v4
|
|
v3--v2
(4)如果取边(v3,v4,5),会产生环路,所以不能取.
如果取边(v1,v2,6),会产生环路,所以不能取.
取边(v2,v5,6),不会产生环路.
v1--v4
|
|
v3--v2--v5
这就是最小生成树,连通了所有顶点,总权值最小.
顶点边的权值
(v1,v4)2
(v1,v3)4
(v2,v3)5
(v2,v5)6
//C语言测试程序
//最小生成树Kruskal(克鲁斯卡尔)算法
#include"stdio.h"
#defineMAXEDGE20
#defineMAXVEX20
#defineINF65535
typedefstruct
{
intarc[MAXVEX][MAXVEX];
intnumVertexes,numEdges;
}MGraph;
typedefstruct
{
intbegin;
intend;
intweight;
}Edge;//对边集数组Edge结构的定义
//创建图
voidCreateMGraph(MGraph*G)
{
inti,j;
G->numEdges=8;//边数
G->numVertexes=5;//顶点数
for(i=0;i<G->numVertexes;i++)//初始化图
{
for(j=0;j<G->numVertexes;j++)
{
if(i==j)
G->arc[i][j]=0;
else
G->arc[i][j]=G->arc[j][i]=INF;
}
}
G->arc[0][1]=6;
G->arc[0][2]=4;
G->arc[0][3]=2;
G->arc[1][2]=5;
G->arc[1][3]=8;
G->arc[1][4]=6;
G->arc[2][3]=5;
G->arc[3][4]=7;
for(i=0;i<G->numVertexes;i++)
{
for(j=i;j<G->numVertexes;j++)
{
G->arc[j][i]=G->arc[i][j];
}
}
}
//交换权值以及头和尾
voidSwapn(Edge*edges,inti,intj)
{
inttemp;
temp=edges[i].begin;
edges[i].begin=edges[j].begin;
edges[j].begin=temp;
temp=edges[i].end;
edges[i].end=edges[j].end;
edges[j].end=temp;
temp=edges[i].weight;
edges[i].weight=edges[j].weight;
edges[j].weight=temp;
}
//对权值进行排序(选择排序法)
voidsort(Edgeedges[],MGraph*G)
{
inti,j,min;
for(i=0;i<(G->numEdges-1);i++)
{
min=i;
for(j=i+1;j<G->numEdges;j++)
{
if(edges[min].weight>edges[j].weight)
{
min=j;
}
}
if(i!=min)
{
Swapn(edges,i,min);
}
}
printf("边的权值排序之后: ");
for(i=0;i<G->numEdges;i++)
{
printf("(%d,%d)%d ",edges[i].begin,edges[i].end,edges[i].weight);
}
}
//查找连线顶点的尾部下标
intFind(int*parent,intf)
{
while(parent[f]>0)
{
f=parent[f];
}
returnf;
}
//生成最小生成树
voidMiniSpanTree_Kruskal(MGraphG)
{
inti,j,n,m;
intk=0;
intparent[MAXVEX];//定义一数组用来判断边与边是否形成环路
Edgeedges[MAXEDGE];//定义边集数组,edge的结构为begin,end,weight,均为整型
//用来构建边集数组并排序
for(i=0;i<G.numVertexes-1;i++)
{
for(j=i+1;j<G.numVertexes;j++)
{
if(G.arc[i][j]<INF)
{
edges[k].begin=i;
edges[k].end=j;
edges[k].weight=G.arc[i][j];
k++;
}
}
}
sort(edges,&G);//从小到大排序
for(i=0;i<G.numVertexes;i++)
{
parent[i]=0;
}
printf("打印最小生成树： ");
for(i=0;i<G.numEdges;i++) //循环每一条边
{
n=Find(parent,edges[i].begin);
m=Find(parent,edges[i].end);
if(n!=m)//假如n与m不等，说明此边没有与现有的生成树形成环路
{
parent[n]=m; //将此边的结尾顶点放入下标为起点的parent中
//表示此顶点已经在生成树集合中
printf("(%d,%d)%d ",edges[i].begin,edges[i].end,edges[i].weight);
}
}
}
intmain(void)
{
MGraphG;
CreateMGraph(&G);
MiniSpanTree_Kruskal(G);
return0;
}
F. 谁有数据结构的期末试题，借我参考下马上考试了
A：
06－07第一学期期末考试试卷
试卷代码：03266A 授课课时：112
课程名称：数据结构与算法 适用对象：本科
一、单项选择题(从下列各题四个备选答案中选出一个正确答案，并将其代号写在答题纸相应位置处。答案错选或未选者，该题不得分。每小题2分，共24分。)
1.数据结构被形式地定义为(K,R)，其中K是数据元素的有限集，R是K上的___有限集。
A.操作 B.映像 C.存储 D.关系
2.线性表若采用链式存储结构时，要求内存中可用存储单元的地址____。
A.必须连续的 B.部分地址必须连续的 C.一定是不续的 D.连续不连续都可以
3.一个栈的入栈序列是a、b、c、d、e，则栈的不可能输出序列是____。
A.edcba B.decba C.dceab D.abcde
4.一个队列的入队序列是1、2、3、4，则队列输出序列是____。
A.4、3、2、1 B.1、2、3、4 C.1、4、3、2 D.3、2、4、1
5.栈和队列的共同点是____。
A.都是先进后出 B.都是先进先出
C.只允许在端点处插入、删除元素 D.没有共同点
6.在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q和p之间插入s结点，则执行____。
A. s->next = p->next; p->next=s; B. p->next = s->next; s->next = p;
C. q->next = s; s->next = p; D. p->next = s; s->next = q;
7.设串s1=‘ABCDEFG’，s2=‘PQRST’，函数con (x, y) 返回x与y串的连接串，函数subs (s, i, j) 返回串s的从序号i的字符开始的j个字符组成的子串，函数len (s) 返回串s的长度，则con (subs (s1, 2, len (s2)), subs (s1, len (s2), 2)) 的结果串是____。
A. BCDEF B. BCDEFG C. BCPQRST D. BCDEFEF
8.设高度为h的二叉树上只有度为0和度为2的结点，则此类二叉树中所包含的结点数至少为____。
A. 2h B. 2h-1 C. 2h +1 D. h +1
9.某二叉树的前序遍历结点访问顺序是abdgcefh，中序遍历结点访问顺序是dgbaechf，则其后序遍历结点访问顺序是____。
A. bdgcefha B. gdbecfha C. bdgaechf D. gdbehfca
10.具有6个顶点的无向图至少应有____条边才能确保是一个连通图。
A. 5 B. 6 C. 7 D. 8
11.采用顺序查找方法查找长度为n的线性表时，每个元素的平均查找长度为–。
A. n B. n/2 C. (n+1)/2 D. (n-1)/2
12.排序方法中，从未排序序列中挑选元素，并将其依次放入已排序序列(注：初始时为空)的一端的方法，称为____。
A. 希尔排序 B. 归并排序 C. 插入排序 D. 选择排序
二、填空题(请在每小题的横线上填入正确内容，每空1分，共7分。)
1.在树形结构中，树根结点没有 结点，其余每个结点有且只有 个前驱结点。
2.对n个元素的序列进行起泡排序时，最少的比较次数是 。
3.空串是 ，其长度等于0。
4.一棵有n个结点的满二叉树共有 个叶子结点。
5.在散列函数H(key)=key % p中，p应取 。
6.已知模式串t=‘abcaabbabc’， 其用KMP法求得的每个字符对应的next函数值为 。
三、简答题(本大题共3小题，每小题5分，共15分)
1.在对线性表的处理中一般使用两种存储结构，顺序存储结构和链式存储结构。试叙述在什么情况下使用顺序表比链表好？
2.简述什么是稳定的排序，什么是不稳定的排序。
3.下列中缀表达式对应的后缀形式是什么？
(1) (A + B) * D + E / (F + A * D) + C
(2) A && B|| ! (E > F) {注：按C的优先级)
四、判断题(本大题共10小题，命题正确的在题后括号内写 “T”，错误的在题后括号内写“F”，每小题1分，共10分)
1.数据元素不是数据的最小单位( )。
2.已知一棵二叉树的前序序列和后序序列可以唯一地构造出该二叉树。( )
3.AOE网是一种带权的无环连通图。( )
4.对于同一组待输入的关键码集合，虽然各关键码的输入次序不同，但得到的二叉搜索树都是相同的( )。
5.一棵树中的叶子数一定等于与其对应的二叉树的叶子数。( )
6.邻接表只能用于有向图的存储，邻接矩阵对于有向图和无向图的存储都适用。( )
7.折半插入排序是稳定的。( )
8.在散列法中，使用双散列函数可保证绝对不产生冲突。( )
9.消除递归不一定需要使用栈( )
10.堆排序是交换排序的一种。( )
五、分析应用题（本题共26分，1、4小题各6分，2、3小题各7分）
1．阅读后分析下面程序段的功能是什么? （6分）
SeqStack S1, S2, tmp;
DataType x; //设栈tmp和S2已做过初始化
while ( ! StackEmpty (S1))
{ x=Pop(S1) ;
Push(tmp,x);
}
while ( ! StackEmpty (tmp) )
{ x=Pop(tmp);
Push( S2, x);
}
2.某子系统在通信联络中只可能出现8种字符，其出现的概率分别为0.05，0.29，0.07，0.08，0.14，0.23，0.03，0.11试设计赫夫曼编码。（7分）
3.设散列表为HT[13], 散列函数为 H (key) = key %13。用线性探测再散列法解决冲突, 对下列关键码序列 12, 23, 45, 57, 20, 03, 78, 31, 15, 36 造表。画出相应的散列表, 并计算等概率下搜索成功的平均搜索长度。（7分）
4.设待排序的排序码序列为{12, 2, 16, 30, 28, 10, 16*, 20, 6, 18}, 试写出使用希尔排序(增量为5,2,1)方法每趟排序后的结果。（6分）
六、算法设计题（本题共18分，第1小题10分，第2小题8分）
1.编写一个算法frequency，统计在一个输入字符串中所含各个不同字符出现的频度。用适当的测试数据来验证这个算法。(10分)
2.在一棵以二叉链表表示的二叉树上，试写出用按层次顺序遍历二叉树的方法，并统计树中具有度为1的结点数目的算法。要求给出二叉链表的类型定义。(8分)
答案：
06－07第一学期
期末考试参考答案与评分标准
试卷代码：03266A 授课课时：112
课程名称：数据结构与算法 适用对象：本科
一、单项选择题(每小题2分，共24分。)
1. D 2. D 3. C 4. B 5. C 6. C
7. D 8. B 9. D 10. A 11. C 12. D
二、填空题(每空1分，共7分。)
1.父(或前驱)， 1
2. n-1
3. 不包含任何字符的串
4. (n+1)/2
5. 素数
6. 0111223123
三、简答题(每小题5分，共15分)
1.答：① 顺序存储时，相邻数据元素的存放地址也相邻(逻辑与物理统一)；要求内存中可用存储单元的地址必须是连续的。
优点：存储密度大，存储空间利用率高。缺点：插入或删除元素时不方便。
②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针
优点：插入或删除元素时很方便，使用灵活。缺点：存储密度小(<1)，存储空间利用率低。
顺序表适宜于做查找这样的静态操作；链表宜于做插入、删除这样的动态操作。
若线性表的长度变化不大，且其主要操作是查找，则采用顺序表；
若线性表的长度变化较大，且其主要操作是插入、删除操作，则采用链表。
2.答：在排序序列中，任何两个相等的关键字Ki=Kj,如果在排序前的序列中Ki领先于Kj，若在排序后的序列中Ki仍领先于Kj，则称所用的排序方法是稳定的；反之，若可能使排序后的序列中Kj领先于Ki，则称所用的排序方法是不稳定的。
3.答：各中缀表达式的后缀形式如下：
(1)AB+D*EFAD*+/+C+
(2)AB&&EF>!||
四、判断题(本大题共10小题，命题正确的在题后括号内写 “T”，错误的在题后括号内写“F”，每小题1分，共10分)
1.T 2.F 3.T 4.F 5.F
6.F 7.T 8.F 9.T 10.F
五、分析应用题（1、4小题各6分，2、3小题各7分）
1．（6分）
答：程序段的功能是利用tmp栈将一个非空栈s1的所有元素按原样复制到一个栈s2当中去。
2．（7分）
答：为方便起见，设各种字符的权值w={5,29,7,8,14,23,3,11}。因为n=8，所以要构造的赫夫曼树共有m=2n-1=2*8-1=15个结点。生成的赫夫曼树为下图所示：
赫夫曼编码为：概率为0.23的字符编码为：00
概率为0.11的字符编码为：010
概率为0.05的字符编码为：0110
概率为0.03的字符编码为：0111
概率为0.29的字符编码为：10
概率为0.14的字符编码为：110
概率为0.07的字符编码为：1110
概率为0.08的字符编码为：1111
3.（7分）
答：使用散列函数H(key)=key mod 13 有：
H（12）=12， H（23）=10，H（45）=6，H（57）=5，H（20）=7，H（03）=3，H（78）=0，H（31）=5，H（15）=2，H（36）=10
利用线性探查法造表：
0 1 2 3 4 5 6 7 8 9 10 11 12
78 15 03 57 45 20 31 23 36 12
1 1 1 1 1 1 4 1 2 1
搜索成功的平均搜索长度为：
ASL=1/10（1+1+1+1+1+1+4+1+2+1）=14/10
4.（6分）
答： 希尔排序(增量为5,2,1)
六、算法设计题（第1小题10分，第2小题8分）
1. (10分)
include <iostream.h>
include”string.h”
int charnumber=128;
void frequency(string&s,int C[ ]){
for(int i=0;i< charnumber;i++) C[i]=0;
for( i=0;i< s.length();i++) C[atoi(s[i])]++;
for( i=0;i< charnumber;i++)
if(C[i]>0) cout<<”(”<<i<<”):\t”<<C[i]<<”\t”;
}
2. (8分)
类型定义（略）
int Level(BiTree bt) //层次遍历二叉树，并统计度为1的结点的个数
{
int num=0; //num统计度为1的结点的个数
if(bt){
QueueInit(Q); QueueIn(Q,bt)；//Q是以二叉树结点指针为元素的队列
while(!QueueEmpty(Q))
{ p=QueueOut(Q); printf(p->data); //出队,访问结点
if(p->lchild && !p->rchild ||!p->lchild && p->rchild)
num++;//度为1的结点
if(p->lchild) QueueIn(Q,p->lchild); //非空左子女入队
if(p->rchild) QueueIn(Q,p->rchild); //非空右子女入队
}
}
return(num); //返回度为1的结点的个数
}
B：
06－07第一学期期末考试试卷
试卷代码：03266B 授课课时：112
课程名称：数据结构与算法 适用对象：本科
一、单项选择题(从下列各题四个备选答案中选出一个正确答案，并将其代号写在答题纸相应位置处。答案错选或未选者，该题不得分。每小题2分，共24分。)
1.数据结构被形式地定义为 (K, R)，其中K是____的有限集，R是K上的关系有限集。
A.算法 B.数据元素 C.数据操作 D.逻辑结构
2.在数据结构中，从逻辑上可以把数据结构分成____。
A.动态结构和静态结构 B.紧凑结构和非紧凑结构
C.线性结构和非线性结构 D.内部结构和外部结构
3.以下的叙述中，正确的是____。
A.线性表的存储结构优于链式存储结构
B.二维数组是其数据元素为线性表的线性表
C.栈的操作方式是先进先出
D.队列的操作方式是先进后出
4.若一个栈的入栈序列是1、2、3、… 、n，其输出序列为p1、p2、p3、… 、pn，若p1=n，则pi为____。
A. i B. n = i C. n - i +1 D.不确定
5.判断一个循环队列QU (最多元素为m) 为空的条件是____。
A. QU->front == QU->rear B. QU->front != QU->rear
C. QU->front == (QU->rear+1)%m D. QU->front != (QU->rear+1)%m
6.在某单链表中，已知p所指结点不是最后结点，在p之后插入s所指结点，则执行____。
A. s->next = p; p->next=s; B. s->next = p->next; p->next = s;
C. s->next = p->next; p = s; D. p->next = s; s->next = p;
7.串是一种特殊的线性表，其特殊性体现在____。
A.可以顺序存储 B.数据元素是一个字符
C.可以链接存储 D.数据元素可以是多个字符
8.已知某二叉树的后序遍历序列是dabec，中序遍历序列是debac，前序遍历序列是____。
A. acbed B. decab C. deabc D. cedba
9.对于一个满二叉树，m个树叶，n个结点，深度为h，则____。
A. n = h + m B. h + m = 2n C. m = h-1 D. n = 2h -1
10.一个有n个顶点的无向图最多有____条边。
A. n B. n(n-1) C. n(n-1)/2 D. 2n
11.顺序查找法适合于存储结构为____的线性表。
A. 散列存储 B. 顺序存储或链接存储
C. 压缩存储 D. 索引存储
12.在待排序的元素序列基本有序的前提下，效率最高的排序方法是____。
A. 插入排序 B.选择排序 C.快速排序 D. 归并排序
二、填空题(请在每小题的横线上填入正确内容，每空1分，共7分。)
1.在线性结构中，第一个结点 前驱结点，其余每个结点有且只有1个前驱结点。
2.在无权图G的邻接矩阵中，若A[i][j]等于1，则等于A[j][i] = 。
3.根据二叉树的定义，具有三个结点的二叉树有 种不同的形态。
4.空格串是指 ，其长度等于 。
5.在散列存储中，装填因子α的值越大，则存储元素时发生冲突的可能性就 。
6.已知模式串t= ‘abacabaaad’， 其用KMP法求得的每个字符对应的next函数值为 。
三、简答题(本大题共3小题，每小题5分，共15分)
1.比较静态查找与动态查找的主要区别，它们的基本运算有哪些不同？
2.逻辑结构分哪几种，存储结构有哪几种？
3.在具有n(n>1)个结点的各棵不同形态树中，其中深度最小的那棵树的深度是多少？它共有多少叶子和非叶子结点？
四、判断题(本大题共10小题，命题正确的在题后括号内写 “T”，错误的在题后括号内写“F”，每小题1分，共10分)
1.每种数据结构都应具备三种基本运算：插入、删除、搜索( )。
2.满二叉树不一定是完全二叉树。( )
3.带权连通图的最小生成树的权值之和一定小于它的其它生成树的权值之和。( )
4.任一棵二叉搜索树的平均搜索时间都小于用顺序搜索法搜索同样结点的顺序表的平均搜索时间。( )
5.线性链表中所有结点的类型必须相同。( )
6.用邻接矩阵存储一个图时，在不考虑压缩存储的情况下，所占用的存储空间大小只与图中顶点个数有关，而与图的边数无关( )。
7.在散列法中解决冲突时，其装载因子的取值一定在(0，1)之间。( )
8.任何一个关键活动延迟，那么整个工程将会延迟。( )
9.平衡二叉树的左右子树深度之差的绝对值不超过1。( )
10.n个结点的有向图，若它有n(n－1)条边，则它一定是强连通的。( )
五、分析应用题（本题共26分，1、4小题各6分，2、3小题各7分）
1.下述算法的功能是什么? （6分）
LinkList Demo(LinkList L)
{ // L 是无头结点单链表
ListNode *Q,*P;
if(L&&L->next){
Q=L;
L=L->next;
P=L;
while (P->next) P=P->next;
P->next=Q; Q->next=NULL;
}
return L;
}
2.将给定的图简化为最小的生成树，要求从顶点1出发。（7分）
3.设散列表为HT[13], 散列函数为 H (key) = key %13。用双散列法解决冲突, 对下列关键码序列 12, 23, 45, 57, 20, 03, 78, 31, 15, 36 造表。再散列函数为 RH (key) = (7*key) % 10 + 1, 寻找下一个地址的公式为 Hi = (Hi-1 + RH (key)) % 13, H1 = H (key)。画出相应的散列表, 并计算等概率下搜索成功的平均搜索长度。（7分）
4.设待排序的排序码序列为{12, 2, 16, 30, 28, 10, 16*, 20, 6, 18},写出使用快速排序法每趟排序后的结果。（6分）
六、算法设计题（本题共18分，第1小题10分，第2小题8分）
1.试设计一个实现下述要求的查找运算函数Locate。设有一个带表头结点的双向链表L， 每个结点有4个数据成员：指向前驱结点的指针llink、指向后继结点的指针rlink，存放字符数据的成员data和访问频度freq。所有结点的freq 初始时都为0。每当在链表上进行一次Locate(L, x) 操作时，令元素值为x的结点的访问频度freq加1，并将该结点前移，链接到与它的访问频度相等的结点后面，使得链表中所有结点保持按访问频度递减的顺序排列，以使频繁访问的结点总是靠近表头。(10分)
2.设一棵二叉树以二叉链表为存贮结构，设计一个算法将二叉树中所有结点的左，右子树相互交换。要求给出二叉链表的类型定义。(8分)
答案：
06－07第一学期
期末考试参考答案与评分标准
试卷代码：03266B 授课课时：112
课程名称：数据结构与算法 适用对象：本科
一、单项选择题(每小题2分，共24分。)
1. B 2. C 3. B 4. C 5. A 6. B
7. B 8. D 9. D 10.C 11. B 12. A
二、填空题(每空1分，共7分。)
1. 无
2. 1
3. 5
4. 串中字符全为空格 ， 空格的个数
5. 大
6. 0112123422 。
三、简答题(本大题共5小题，每小题5分，共15分)
1．答：两种查找方法最大的区别在于：
静态查找方法不修改查找表；动态查找在查找不成功时，将结点插入查找表中，即有可能修改查找表；
静态查找的基本运算有建表、查找和读表元；动态查找除上述基本操作外还有初始化、插入和删除操作；
2.答：根据数据元素之间关系的不同特性，通常有下列四类基本结构：(1)集合；(2)线性结构；(3)树形结构；(4)图状结构或网状结构。有两种不同的存储结构：顺序存储结构和链式存储结构。
3.答：深度最小的那棵树的深度为2。对于这n个结点，除了一个根结点之外，其余得n-1个结点均为叶子结点，故其深度为2。该树叶子结点数为n-1，非叶子结点数为1。
四、判断题(每小题1分，共10分)
1. (T) 2. (F) 3. (T) 4. (F) 5. (T)
6. (T) 7. (F) 8. (T) 9. (T ) 10.(T)
五、分析应用题（本题共26分，1、4小题各6分，2、3小题各7分）
1.（6分）
答：该算法的功能是：将开始结点摘下链接到终端结点之后成为新的终端结点，而原来的第二个结点成为新的开始结点，返回新链表的头指针。
2.（7分）
答:
3.（7分）
答：使用散列函数H(key)=key mod 13 有：
H（12）=12， H（23）=10，H（45）=6，H（57）=5，H（20）=7，H（03）=3，H（78）=0，H（31）=5，H（15）=2，H（36）=10
利用双散列法造表：Hi =（Hi-1+RH(key)）%13, Hi =H(key)
0 1 2 3 4 5 6 7 8 9 10 11 12
78 15 03 57 45 20 31 36 23 12
1 1 1 1 1 1 3 5 1 1
搜索成功的平均搜索长度为：ASL =1/10（1+1+1+1+1+1+3+5+1+1）=16/10
4.（6分）
答：
六、算法设计题（第1小题10分，第2小题8分）
1.(10分)
答：
(1) 定义链表结构
struct DoubleListNode {
char data ;
int freq;
DoubleListNode * llink, *rlink ;
};
初始时，所有结点的freq域的值都为0。
(2) 定义函数
DoubleListNode * locate ( DoubleListNode *f ; char &x ) {
DoubleListNode * p, *q;
p = f→rlink; /*跳过表头结点*/
while ( p != NULL && p→data != x ) p = p→rlink; /*搜索*/
if ( p ) {
p→freq ++; q = p→llink;
p→rlink→llink = q; q→rlink = p→rlink; /*从链中摘下p*/
while ( q != f &&q→freq < p→freq ) q =q→llink;
p→llink = q;
p→rlink = q→rlink; q→rlink→llink = p;
q→rlink = p; /*在q后面插入p*/
}
return p;
}
2． (8分)
答：类型定义（略）
void exchange(BiTree bt)//将二叉树bt所有结点的左右子树交换
{
if(bt)
{ BiTree s；
s=bt->lchild; bt->lchild=bt->rchild; bt->rchild=s; //左右子女交换
exchange(bt->lchild); //交换左子树上所有结点的左右子树
exchange(bt->rchild); //交换右子树上所有结点的左右子树
}
}
G. 数据结构与算法处理面试题
1、时针走一圈，时针分针重合几次
2、N*N的方格纸,里面有多少个正方形
3、2000万个整数，找出第五十大的数字？
4、网络POI中如何试下查找最近的商家功能(提示：坐标镜像+R树)。
5、一个文件中有100万个整数，由空格分开，在程序中判断用户输入的整数是否在此文件中。说出最优的方法
6、两个不重复的数组集合中，这两个集合都是海量数据，内存中放不下，怎么求共同的元素？
7、烧一根不均匀的绳，从头烧到尾总共需要1个小时。现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个小时十五分钟呢？
8、万亿级别的两个URL文件A和B，如何求出A和B的差集C(提示：Bit映射->hash分组->多文件读写效率->磁盘寻址以及应用层面对寻址的优化)
9、怎么在海量数据中找出重复次数最多的一个？
10、海量日志数据，提取出某日访问网络次数最多的那个IP。
11、在2.5亿个整数中找出不重复的整数，注，内存不足以容纳这2.5亿个整数。
12、搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。
13、有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词。
14、有10个文件，每个文件1G，每个文件的每一行存放的都是用户的query，每个文件的query都可能重复。要求你按照query的频度排序。
15、给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b文件共同的url？
16、一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。
17、腾讯面试题：给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中？
18、100w个数中找出最大的100个数。
H. 数据结构试题 若X和Y是用结点大小为1的单链表表示的串，设计算法找出X中第一个不再Y中出现的字符
一
选择题（7分，每小题0.5分）
1.C语言源程序的基本单位是（ ）。
A 过程 B 函数 C 子程序 D 标识符
2.下列程序的输出结果是（ ）。
main( )
{ int a=7,b=5;
printf("%d\n",b=b/a);
}
A 5 B 1 C 0 D不确定值
3.假设变量a,b均为整型，表达式(a=5,b=2,a>b?a++:b++,a+b)的值是（ ）。
A 7 B 8 C 9 D 2
4.设a为int型变量，执行下列赋值语句后，a的取值分别是（ ）。
a=125.534; a=(int)125.521%4; a=5<<2;
A 125,31,1 B 125,1,20 C 125,31,20 D 125.534,2,20
5.设有如下程序段，下面描述中正确的是 （ ）。
int k=10; while(k=0) k=k-1;
A 循环执行一次 B循环是无限循环 C循环体语句一次也不执行 D循环体语句执行一次
6.以下程序的输出结果为（ ）。
int i;
void prt( )
{ for(i=5;i<8;i++) printf("%c",'*');
printf("\t");
}
main( )
{ for(i=5;i<=8;i++) prt( );
}
A *** B *** *** *** *** C *** *** D * * *
7.在C语言程序中，以下说法正确的是（ ）。
A函数的定义可以嵌套,但函数的调用不可以嵌套
B函数的定义不可以嵌套,但函数的调用可以嵌套
C函数的定义和函数的调用都不可以嵌套
D函数的定义和函数的调用都可以嵌套
8.以下函数调用语句中含有（ ）个实参。
func((e1,e2),(e3,e4,e5));
A 2 B 3 C 5 D 语法错误
9.以下程序的输出结果为（ ）。
#define ADD(x) x*x
main( )
{ int a=4,b=6,c=7,d=ADD(a+b)*c;
printf("d=%d",d);
}
A d=70 B d=80 C d=140 D d=700
10.已知职工记录描述如下，在Turbo C中，系统为变量w分配（ ）字节的空间。
struct worker
{ int no;
char name[20];
char sex;
union
birth;
} w;
A 29 B 20 C 25 D 6
11.设有以下定义，值为5的枚举常量是（ ）。
enum week w；
A tue B sat C fri D thu
12.下面选项中正确的赋值语句是(设 char a[5],*p＝a;)（ ）。
A p="abcd"; B a="abcd"; C *p="abcd"; D *a="abcd";
13.设有以下程序段，则值为6的表达式是（ ）。
struct st ;
static struct st a[3]=，*p;
p=&a[0];
A p++->n B ++p->n C p->n++ D (*p).n++
14.C语言中的文件类型只有（ ）。
A 索引文件和文本文件两种 B 文本文件一种
C 二进制文件一种 D ASCII码文件和二进制文件两种
二 判断对错，对的划“√”，错的划“×”（5分，每小题0.5分）
1．在Turbo C中，整型数据在内存中占2个字节。（ ）
2．int i=20;switch(i/10)的输出结果为A。（ ）
3．break语句用在循环体中，可结束本层循环，continue语句用在循环体中，可结束本次循环。（ ）
4．函数的递归调用不过是一个函数直接或间接地调用它自身。（ ）
5．函数strlen("ASDFG\n")的值是7。（ ）
6．通过return语句，函数可以带回一个或一个以上的返回值。（ ）
7．结构体类型只有一种。 （ ）
8．char *p="girl"；的含义是定义字符型指针变量p，p的值是字符串"girl"。（ ）
9．若有定义：char *p(char a[10]);则p是函数名。（ ）
10．用fopen("file","r+");打开的文件"file"可以进行修改。 （ ）
三 写出下列程序的运行结果（10分，每小题2分）
1.float average (float array[10])
{ int i;
float aver,sum=array[0];
for (i=1;i<10;i++)
sum=sum+array[i];
aver=sum/10;
return(aver);
}
main( )
,aver;
int i;
aver=average (score);
printf (“average score is %5.2f\n”,aver);
}
2.main( )
,*p=a,**pa;
for(p=0;p<a+5;p++)
printf(“%2c”,*p);
printf(“\n”);
printf(“%2c\n”,**(pa=&p));
}
3.main( )
{ int a,b,s=0;
for(a=1,b=1;a<=100;a++)
{ if(b>=20) break;
if(b%3==1)
b-=5;
}
printf(“a=%d\tb=%d\n”,a,b);
}
4.main()
{ printf(“main( ) :%d\n”,fact(5));
fact(-5);
}
fact(int value)
{ int f;
if(value<0)
{ printf(“Arg error\n");
return(-1);
}
else if(value==1||value==0) f=1;
else f=value*fact(value-1)+1;
printf(“This called value=%d\n”,f);
return f;
}
5.main( )
{ int a=012,b=0x12,k=12;
char c=‘\102’,d=‘\r’;
printf(“a=%d\tb=%d\tk=%d\n”,a,b,k);
printf(“c=%c,d=%c%o\n”,c,d,a);
a=‘A’; c=49;
printf(“a=%d\tc=%c\n”,a,c);
}
四 阅读下列程序,在 处填入适当内容，使程序完整（8分，每个空1分）
1.有一个3*4矩阵，求其中的最大元素。
max_value( (1) )
{ int i,j,max;
max=array[0][0];
for(i=0;i<3;i++)
for(j=0;j<4;j++)
if(array[i][j]>max)
max=array[i][j];
(2) ;
}
main( )
{ int a[3][4], i,j;
for(i=0;i<3;i++)
for(j=0;j<4;j++)
(3) ;
printf(“max value is %d\n”,max_value(a));
}
2.输入x、y两个整数，按先大后小的顺序输出x、y。
#include “stdio.h”
main( )
{ int x,y, *px,*py, (4) ;
scanf(“%d%d”,&x,&y);
(5) ; (6) ;
if(x<y)
printf(“x=%d,y=%d\n”,x,y);
printf(“MAX=%d,MIN=%d\n”,*px,*py);
}
3.用选择排序法对任意10个整数按照由小到大排序。
main()
{ int a[11],i,j,k,t;
printf("Please input 10 numbers:\n");
for(i=1;i<11;i++) scanf("%d",&a[i]);
printf("\n");
for(i=1;i<=9;i++)
{ (7) ;
for(j=i+1; (8) ;j++)
if(a[j]>a[k]) k=j;
if(k!=i)
}
printf("The sorted numbers:\n");
for(i=1;i<11;i++) printf("%d ",a[i]);
}
答案
一 选择题（7分，每小题0.5分）
1. B 2. C 3. B 4. B 5. C
6. A 7. B 8. A 9. A 10. C
11. A 12. A 13. B 14. D
二 判断对错，对的划“√”，错的划“×”（5分，每小题0.5分）
1.× 2.× 3.√ 4.√ 5.×
6.× 7.× 8.× 9.√ 10.√
三 写出下列程序的运行结果（10分，每小题2分）
1. 2. 3.
4. 5.
四 阅读下列程序,在 处填入适当内容，使程序完整（8分，每个空1分）
1.(1)int array[3][4](int array[][4]) (2)return(max) (3)scanf(“%d”,&a[i][j])
2.(4)*p (5)px=&x(py=&y) (6)py=&y(px=&x)
3.(7) (8)
请参考
I. 数据结构试题求解
1 错。给的条件能确定链表含1个元素，而非空。
2 错。
3 错。M阶B树要求（叶上）至少M/2个元素，上面所谓的叶就是倒数第二层了，而三阶平衡树最底层可以有1个元素。
1. 下面程序段时间复杂度为________
for (int i=0;i<n;i++)
for (int j=0;j<k;j++ )
S+=i;
O(n*k)
2 数据结构的存储结构包括顺序，________，索引和散列四种。
链接
3.设森林T中有三棵树，第一，二，三棵树的结点个数分别为n1,n2,n3,将森林转换成二叉树后，其根结点的左子树上有________个结点。
n1-1。
森林转为二叉树之后，原第一棵树T1的根节点将成为二叉树Tn的根节点，其余的采取貌似于长兄如父的方式排列，原先是父子关系的还是步子，但是原先是兄弟的也变成了父子，对于其他树的根节点的有分支，会分到左分支的另一派左分支上。所以是n1-1
4.对二叉搜索树进行________遍历，可以得到按关键字从小到大排列的结点序列。
中序
二叉搜索树为了搜索的方便，根节点大于左边的，小于右边的。所以中序遍历才会得到所要序列
三.选择题
1.已知单链表A长度为m，单链表B长度为n，若将B联接在A的末尾，其时间复杂度应为________。
A. O(1) B. O(m) C. O(n) D.O(m+n)
B。步进m次（即O(m)）以达到其尾节点，然后将该节点的next指向B。如果给定了条件是链表既存有头，又存有尾，那么就是o(1).这里选B。
2.设有一个递归算法如下：
int fact(int n) { //n大于等于0
if(n<=0) return 1;
else return n*fact(n-1);
}
则计算fact(n)需要调用该函数的次数为________次。
A. n B. n+1 C. n+2 D.n-1
B
可乐答的不错。可以保证。我做的结果一样。