算法与数据结构重点归纳

1、算法
for(i=n-1; i>=1; i–)
for(j=1; j<=i; j++)
if(A[j]>A[j+1])
A[j]与A[j+1]对换；
其中n为正整数，则最后一行语句的频度（执行次数）在最坏情况下是( D )
A. O(n) B. O(nlog2n) C. O(n3) D. O(n2)
2、设某算法完成对n个元素进行处理，所需的时间是T(n)=100nlog2n+200n+500，则该算法的时间复杂度是( C )
A. O(1) B. O(n) C. O(nlog2n) D. O(nlog2n+n)
3、假设时间复杂度为O(n2)的算法在有200个元素的数组上运行需要3.1ms，则在有400个元素的数组上运行需要( C )ms。
A. 3.1 B. 6.2 C. 12.4 D. 9.61
4、某算法的时间复杂度是O(n2)，表明该算法( C )
A. 问题规模是n2 B. 执行时间等于n2
C. 执行时间与n2成正比 D. 问题规模与n2成正比

线性表
1、( D )是一个线性表。
A. 由n个实数组成的集合 B. 由所有实数组成的集合
C. 由所有整数组成的序列 D. 由n个字符组成的序列
2、已知一维数组A采用顺序存储结构，每个元素占用4个存储单元，第9个元素的地址为144，则第1个元素的地址( D )
A. 108 B. 180 C. 176 D. 122
3、线性表的顺序存储结构是一种( A )的存储结构。
A. 随机存取 B. 顺序存取 C. 索引存取 D. 散列存取
4、n个结点的线性表采用数组实现，算法的时间复杂度是O(1)的操作是( A )
A. 访问第i个结点（1≤i≤n）和求第i个结点的直接前趋(2≤i≤n)
B. 在第i个结点后插入一个新结点(1≤i≤n)
C. 删除第i个结点(1≤i≤n)
D. 以上都不对
5、对于顺序存储的线性表，访问某个元素和增加一个元素的时间复杂度为( C )
A. O(n), O(n) B. O(n), O(1) C. O(1), O(n) D. O(1), O(1)
6、顺序表的插入算法中，当n个空间已满时，可再申请增加分配m个空间，若申请失败，则说明系统没有( D )可分配的存储空间。
A. m个 B. m个连续的 C. n+m个 D. n+m个连续的
7、在具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是( B )
A. O(1) B. O(n) C. O(n2) D. O(nlog2n)
8、在一个单链表中，已知q所指结点是p所指结点的直接前驱，若在q和p之间插入s所指结点，则执行( B )操作。
A. S->next=p->next; p->next=s; B. q->next=s; s->next=p;
C. p->next=s->next; s->next=p; D. p->next=s; s->next=q;
9、在一个长度为n(n>1)的带头结点的单链表h上，另设有尾指计r指向尾结点，执行( B )操作与链表的长度有关。
A. 删除单链表中的第一个元素
B. 删除单链表中的最后一个元素
C. 在单链表第一个元素前插入一个新元素
D. 在单链表的最后一个元素后插入一个新元素
10、将线性表(a1, a2, …, an)组织为一个带头结点的循环单链表，设H为链表的头指针，则链表中最后一个结点指针域中存放的是( B )。
A. 变量H的地址 B.变量H的值 C. 元素a1的地址 D. 空指针
11、设线性表非空，( B )可以在O(1)的时间内在表尾插入一个新结点。
A. 带头结点的单链表，有一个链表指针指向头结点
B. 带头结点的循环单链表，有一个链表指针指向头结点
C. 不带头结点的单链表，有一个链表指针指向表的第一个结点
D. 不带头结点的循环单链表，有一个链表指针指向表中某个结点（除第一个结点外）
12、设指针rear指向带头结点的循环单链表的尾结点，若要删除链表的第一个元素结点，正确的操作是( D )。
A. s=rear; rear=rear->next;
B. rear=rear->next;
C. rear=rear->next->next;
D. s=rear->next->next; rear->next->next=s->next;
13、使用双链表存储线性表，其优点是可以( B )
A. 提高查找速度 B. 更方便数据的插入和删除
C. 节约存储空间 D. 很快回收存储空间
14、与单链表相比，双链表的优点之一是( D )
A. 插入和删除操作更简单 B. 可以进行随机访问
C. 可以省略表头指针或表尾指针 D. 访问前后相邻结点更灵活
15、带头结点的循环双链表L为空表的条件是( D )
A. L->next->prior=NULL B. L->prior=L
C. L->next=L D. B和C都对
16、在循环双链表的p所指结点后插入s所指结点的操作是( D )
A. p->next=s; s->prior=p; p->next->prior=s; s->next=p->next;
B. p->next=s; p->next->prior=s; s->prior=p; s->next=p->next;
C. s->prior=p; s->next=p->next; p->next=s; p->next->prior=s;
D. s->prior=p; s->next=p->next; p->next->prior=s; p->next=s;
17、在双链表中指针pa所指结点后面插入pb所指结点，执行的语句序列是( D )。
①pb->next=pa->next; ②pb->prior=pa;
③pa->next=pb; ④pa->next->prior=pb;
A. ①②③④ B. ④③②① C. ③④①② D. ①④③②
18、在一个双链表中，删除结点p的操作是( A )。
A. p->prior->next=p->next; p->next->prior=p->prior;
B. p->prior=p->prior-prior; p->prior->prior=p;
C. p->next->prior=p; p->next=p->next->next;
D. p->next=p->prior->prior; p->prior=p->prior->prior;
19[简答]、若频繁地对一个线性表进行插入和删除操作，该线性表采用什么存储结构比较好？
答：采用链式存储结构，如单链表。
20[编程]、试以顺序表作存储结构，实现线性表就地逆置算法Reverse。
假设顺序表的类型定义如下：
typedef struct{
ElemType * elem; //从索引(下标)0开始存放数据
int length;
int listsize;
}SqList;
答：
void Reverse(SqList L){
n=L.length;
for(i=1; i<n/2; i++) //此处i是数据元素的逻辑序号
L.elem[i-1]<–>L.elem[n-i]; //交换元素
}

21[编程]、设计算法BringBack，判断给定字符串是否是回文。假设待判断字符串存放于ch[]，数组长度为n。若ch[]为回文，则返回整型1，否则返回整型0。
答：
int BringBack(char ch[], int n) {
for (i=0; i<n/2; i++) //此处i是字符在数组中的下标
if(ch[i]!=ch[n-i-1]) return 0;
return 1; //退出循环说明所有对称位置字符均相符
}
22[编程]、已知数组A[n]中的元素为整型，长度为n。设计算法Adjust，将A[n]调整为左右两部分，左边所有元素为奇数，右边所有元素为偶数，并要求算法的时间复杂度为O(n)。
答：
void Adjust(int A[], int n){
i=0;
j=n-1;
while(i<j){
while(A[i]%2!=0) i++; //退出循环A[i]为偶数
while(A[j]%2==0) j++; //退出循环A[j]为奇数
if(i<j) A[i]<–>A[j];
}
}
23[编程]、已知顺序表L中的元素递增有序排列，设计算法Insert，将整型元素x插入到表L中并保持表L仍递增有序。
假设顺序表的类型定义如下：
typedef struct{
ElemType * elem; //从索引(下标)0开始存放数据
int length;
int maxsize; //顺序表的最大长度，超过此长度则会发生“上溢”错误。
}SqList;
答；
void Insert(SqList L, int x){
if(L.length>=listsize) {printf(“上溢”); return;}
i=0;
while(i<L.length && L.elem[i]<x) i++; //查找元素x的位置
//注意i是元素x在数组中的下标
for (j=L.length-1;j>=i;j–)
L.elem[j+1]=L.elem[j];
L.elem[i]=x;
L.length++;
}
24[编程]、设计一个高效算法，在顺序表中删除所有元素值等于x的元素，要求空间复杂度为O(1)。假设算法名为DeleteAllx，顺序表为L，x为整型，顺序表的类型定义如下：
typedef struct{
ElemType * elem; //从索引(下标)0开始存放数据
int length;
int listsize;
}SqList;
答：
void DeleteAllx(SqList L, int x){
k=0; //k记录x出现的次数
for(i=0; i<L.length; i++){
if(L.elem[i]==x) k++;
else L.elem[i-k]=L.elem[i]; //前移k个位置
}
L.length=L.length-k; //共删除了k个元素
}
25[编程]、设计算法DeleteSame，删除顺序表L中重复的元素，要求算法移动元素的次数较少并使剩余元素间的相对次序保持不变。假设顺序表的类型定义如下：
typedef struct{
ElemType * elem; //从索引(下标)0开始存放数据
int length;
int listsize;
}SqList;
答：
void DeleteSame(SqList L){
j=0; //初始化，先存放顺序表中的第一个元素
for(i=1; i<L.length; i++){ //依次考察顺序表中的元素
for(k=0; k<=j; k++){ //elem[0]~elem[j]中已有相同元素
if(L.elem[i]==L.elem[k])break;
}
if(k>j) //退出循环说明elem[i]与elem[0]~elem[j]都不相同
L.elem[++j]=L.elem[i]; //将elem[i]插入j+1位置
}
L.length=j+1; //最后共有j+1个互不相同的元素
}
26[编程]、给定n个记录的有序序列A[n]和m个记录的有序序列B[m]，将它们归并为一个有序序列，存放在C[m+n]中，试写出这一算法Union（假设A、B和C均为升序序列）。假设A、B、C索引（下标）均从0开始。
答：
void Union(int A[], int n, int B[], int m, int C[]){ //下标从0开始
i=0; j=0; k=0;
while(i<n && j<m){
if(A[i]<=B[j]) C[k++]=A[i++]; //取A[i]与B[j]中较小者存入C[K]
else C[k++]=B[j++];
}
while(i<n)C[k++]=A[i++]; //收尾处理，表A中还有剩余记录
while(j<m)C[k++]=B[j++]; //收尾处理，表B中还有剩余记录
}
27[编程]、设计算法Traverse依次打印带头结点的单链表L中每个结点的数据信息。假设单链表的存储结构定义如下：
typedef struct LNode{
ElemType data;
struct LNode * next;
}LNode, * LinkList;
答：
void Traverse(LinkList L) {
p=L->next; //工作指针p指始化
while(p!=NULL){
printf(p->data);
p=p->next; //工作指针p后移
}
}
28[编程]、求带头结点的单链表的长度。假设算法名为Length，返回链表长度，类型为整型，单链表的存储结构定义如下：
typedef struct LNode{
ElemType data;
struct LNode * next;
}LNode, * LinkList;
答：
int Length(LinkList L){
p=L->next; length=0; //初始化工作指针p和链表长度length
while§{
p=p->next;
length++;
}
return length;
}
29[编程]、试写出算法Increase，判断带头结点的非空单链表L是否递增有序，若为递增有序，则返回整数1，否则返回整数0。假设单链表的存储结构定义如下：
typedef struct LNode{
ElemType data;
struct LNode * next;
}LNode, * LinkList;
答：
int Increase(LinkList L){
p=L->next; //因为单链表非空，所以p非空且指向开始结点
while(p->next){ //当p的后继结点存在，进行比较
q=p->next;
if(p->datadata) p=q;
else return 0;
}
return 1; //退出循环说明每个结点的值均小于其后继结点的值
}
30[编程]、已知带头结点的非单链表由L指出。请编写算法MoveMin，将链表中数据域值最小的结点移到链表的最前面。要求：不得额外申请新的结点。假设单链表的存储结构定义如下：
typedef struct LNode{
ElemType data;
struct LNode * next;
}LNode, * LinkList;
答：
void MoveMin(LinkList L){
pre=L; //pre指向最小值结点的前驱
q=L->next; //q指向最小值结点，初始假定是第一个结点
p=q; //p是链表的工作指针，依次将链表中的结点与结点q相比较
while(p->next!=NULL){
if(p->next->datadata){
pre=p; q=p->next; //找到新的最小值结点
}
p=p->next;
}
if(q!=L->next){ //若最小值是第一元素结点，则不需要操作
pre->next=q->next; //将最小值结点从链表上摘下
q->next=L->next; L->next=q; //将结点q插入到头结点的后面
}
}

栈和队列
1、经过以下栈运算后，x的值是( A )
InitStack(s); Push(s, a); Push(s, b); Pop(s, x); GetTop(s, x);
A. a B. b C. 1 D. 0
2、经过以下栈运算后，StackEmpty(s)的值是( C )
InitStack(s); Push(s, a); Push(s,b); Pop(s, x); Pop(s, y);
A. a B. b C. 1 D. 0
3、一个栈的入栈序列是{1, 2, 3, 4, 5}，则栈的不可能的输出序列是( C )
A. {5, 4, 3, 2, 1} B. {4, 5, 3, 2, 1}
C. {4, 3, 5, 1, 2} D. {1, 2, 3, 4, 5}
4、若一个栈的输入序列是1, 2, 3, …, n，输出序列的第一个元素是n，则第i个输出元素是( D )
A. 不确定 B. n-i C. n-i-1 D. n-i+1
5、若一个栈的输入序列是1, 2, 3, …, n，其输出序列是p1, p2, …, pn，若p1=3，则p2的值( C )
A. 一定是2 B. 一定是1 C. 不可能是1 D. 以上都不对
6、在一个具有n个单元的顺序栈中，假定以地址低端（即下标为0的单元）作为栈底，以top作为栈顶指针，当出栈时，top的变化为( C )
A. 不变 B. top=0; C. top=top-1; D. top=top+1;
7、两个栈共享一个数组空间的好处是( B )
A. 减少存取时间，降低发生上溢的可能性 B. 节省存储空间，降低发生上溢的可能性
C. 减少存取时间，降低发生下溢的可能性 D. 节省存储空间，降低发生下溢的可能性
8、一个队列的入队顺序是1, 2, 3, 4，则队列的输出顺序是( B )
A. 4321 B. 1234 C. 1432 D. 3241
9、循环队列存储在数组A[0…m]中，则入队时的操作为( D )
A. rear=rear+1 B. rear=(rear+1) mod (m-1)
C. rear=(rear+1) mod m D. rear=(rear+1) mod (m+1)
10、已知循环队列的存储空间为数组A[21]，front指向队头元素的前一个位置，rear指向队尾元素，假设当前front和rear的值分别为8和3，则该队列的长度为( C )
A. 5 B. 6 C. 16 D. 17
11、在链队列中，设指针f和r分别指向队首和队尾，则插入s所指结点的操作是( B )
A. f->next=s; f=s; B. r->next=s; r=s;
C. s->next=r; r=s; D. s->next=f; f=s;
12、设计一个判别表达式中左右括号是否配对的算法，采用( B )数据结构最佳。
A. 顺序表 B. 栈 C. 队列 D. 链表
13、栈和队列的主要区别在于( D )
A. 它们的逻辑结构不一样 B. 它们的存储结构不一样
C. 所包含的运算不一样 D. 插入、删除运算的限定不一样
14、栈和队列的共同点是( C )
A. 都是先进先出 B. 都是先进后出
C. 只允许在端点处插入和删除元素 D. 没有共同点

树和二叉树
1、如果结点A有3个兄弟，B是A双亲，则结点B的度是( D )
A. 1 B. 2 C. 3 D. 4
2、假定一棵度为3的树中结点数为50，则其最小高度应为( C )
A. 3 B. 4 C. 5 D. 6
3、对于一棵具有n个结点的树，树中所有结点的度数之和为( C )
A. n B. n-2 C. n-1 D. n+1
4、设二叉树有n个结点，则其深度为( D )
A. n-1 B. n C. Llog2n」+1 D. 不能确定
5、一个具有1025个结点的二叉树的高度为( C )
A. 11 B. 12 C. 11~1025 D. 12~1025
6、深度为k的完全二叉树至少有( B )个结点，至多有( C )个结点。
A. 2k-2+1 B. 2k-1 C. 2k-1 D. 2k-1-1
7、若某完全二叉树的结点个数为100，则第60个结点的度为( A )
A. 0 B. 1 C. 2 D. 不确定
8、一棵有124个叶结点的完全二叉树，最多有( B )个结点
A. 247 B. 248 C. 249 D. 250
9、对于完全二叉树中的任一结点，若其右分支下的子孙的最大层次为h，则其左分支下的子孙最大层次为( C )
A. h B. h+1 C. h或h+1 D. 任意
10、一个高度为h的满二叉树共有n个结点，其中有m个叶子结点，则有( D )成立。
A. n=h+m B. h+m=2h C. m=h-1 D. n=2m-1
11、一棵满二叉树中共有n个结点，其中有m个叶子结点，深度为h，则( D )
A. n=h+m B. h+m=2n C. m=h-1 D. n=2h-1
12、若一棵二叉树共有1001个结点，且无度为1的结点，则叶子结点的个数为( D )
A. 498 B. 499 C. 500 D. 501
13、设二叉树有2n个结点，则对于m<n，不可能存在( C )的结点。
A. n个度为0 B. 2m个度为0 C. 2m个度为1 D. 2m个度为2
14、设高度为h的二叉树只有度为0和度为2的结点，则此类二叉树中所包含的结点数至少为( C )
A. 2h B. 2h+1 C. 2h-1 D. h-1
15、每个结点的度或者为0或者为2的二叉树称为正则二叉树。n个结点的正则二叉树中有( B )个叶子。
A. log2n B. (n-1)/2 C. log2(n+1) D.(n+1)/2
16、深度为h的满m叉树的第k(1≤k≤h)层有( A )个结点。
A. mk-1 B. mk-1 C. mh-1 D. mh-1
17、用顺序存储的方法将完全二叉树中的所有结点逐层存放在数组A[1]~A[n]中，结点A[i]若有左子树，则左子树的根结点是( D )。
A. A[2i-1] B. A[2i+1] C. A[i/2] D. A[2i]
18、一棵二叉树的前序遍历序列为ABCDEFG，它的中序遍历序列可能是( B )
A. CABDEFG B. BCDAEFG C. DACEFBG D. ADBCFEG
19、现有前序遍历二叉树的结果为ABC，则有( C )种不同的二叉树可以得到这一结果。
A. 3 B. 4 C. 5 D. 6
20、二叉树的前序序列和后序序列正好相反，则该二叉树一定是( B )的二叉树。
A. 空或只有一个结点 B. 高度等于其结点数
C. 任一结点无左孩子 D. 任一结点无右孩子
21、任何一棵二叉树的叶子结点在前序、中序、后序遍历序列中的相对次序( A )。
A. 肯定不发生改变 B. 肯定发生改变 C. 不能确定 D. 有时发生变化
22、前序遍历和中序遍历结果相同的二叉树是( D )
A. 根结点无左孩子的二叉树 B. 根结点无右孩子的二叉树
C. 所有结点只有左子树的二叉树 D. 所有结点只有右子树的二叉树
23、如果在某二叉树的前序序列、中序序列、后序序列中，结点a都在结点b的前面（即形如…a…b…），则( A )。
A. a和b是兄弟 B. a是b双亲 C. a是b的左孩子 D. a是b的右孩子
24、已知某完全二叉树采用顺序存储，结点数据信息的存放顺序是ABCDEFGH，则该完全二叉树的后序遍历序列为( A )
A. HDEBFGCA B. HEDBFGCA C. HDEBAFGC D. HDEFGBCA
25、下列说法中，( A )是正确的。
A. 深度为k的二叉树最多有2k-1个结点，最少有k个结点
B. 二叉树中一定存在度为2的结点
C. 对二叉树的遍历是指先序、中序或后序遍历中的一种
D. 构造线索二叉树的目的是为了能方便地找到每个结点的双亲
26、设森林中有4棵树，树中结点的个数依次为n1, n2, n3, n4，则把森林转换成二叉树后，其根结点的右子树上有( D )个结点，根结点的左子树上有( A )个结点。
A. n1-1 B. n1 C. n1+n2+n3 D. n2+n3+n4
27、设森林F对应的二叉树为B，它有m个结点，B的根为p，p的右子树结点个数为n，森林F中第一棵树的结点个数是( A )
A. m-n B. m-n-1 C. n+1 D. 条件不足，无法确定
28、深度为h(h>0)的满二叉树对应的森林由( D )棵树构成。
A. 1 B. log2n C. h/2 D. h
29、由权值为{3, 8, 6, 2, 5}的叶子结点生成一棵huffman树，其带权路径长度为( C )
A. 24 B. 48 C. 53 D. 72
30、一棵huffman树共有215个结点，对其进行huffman编码，能得到( B )个不同的编码。
A. 107 B. 108 D. 214 D. 215
31、下述编码中( B )不是前缀编码。
A. (00, 01, 10, 11) B. (0, 1, 00, 11)
C. (0, 10, 110, 111) D. (1, 01, 000, 001)
32、为5个使用频率不等的字符设计huffman编码，不可能的方案是( C )
A. 111, 110, 10, 01, 00 B. 000, 001, 010, 011, 1
C. 100, 11, 10, 1, 0 D. 001, 000, 01, 11, 10
33、为5个使用频率不等的字符设计huffman编码，不可能的方案是( D )
A. 000, 001, 010, 011, 1 B. 0000, 0001, 001, 01, 1
C. 000, 001, 01, 10, 11 D. 00, 100, 101, 110, 111
34、设计huffman编码的长度不超过4，若已经对两个字符编码为1和01,则最多还可以为( C )个字符编码。
A. 2 B. 3 C. 4 D. 5
35、假设字符集{a, b, c, d, e}中各字符出现的频率分别为{4, 21, 7, 14, 31}，为该字符集构造huffman编码，则字符集编码的总码数为( C )。
A. 12 B. 13 C. 14 D. 15
36[简答]、已知一棵二叉树的前序遍历序列和中序遍历序列分别为ABCDEFGH和CDBAFEHG，试构造该二叉树。

37[简答]、将下面左图中所示的树转换为二叉树，右图所示的二叉树转换为树或森林

答：左图为转换后的二叉树，右图为转换后的森林

38[简答]、已知某字符串S中共有8种字符，各种字符分别出现2次、1次、4次、5次、7次、3次、4次和9次，对该字符串用[0,1]进行前缀编码，问该字符串的编码至少有多少位。
答：以各字符出现的次数作为叶子结点的权值构造的huffman编码树如图所示。其带树路径长度=2x5+1x5+3x4+5x3+9x2+4x3+4x3+7x2=98，所以，该字符串的编码长度至少为98位

39[简答]、假设用于通信的电文由字符集{a,b,c,d,e,f,g}中的字符构成，它们在电文中出现的频率分别为{0.31, 0.16, 0.10, 0.08, 0.11, 0.20, 0.04}。要求：
①为这7个字符设计huffman编码
②使用huffman编码比使用等长编码使电文总长压缩多少？
答：
①设权值W={31, 16, 10, 8, 11, 20, 4}，构造的huffman树如图所示：

根据huffman树得到各字符的哈夫曼编码为：
a:01; b:001; c:100; d:0001; e:101; f:11; g:0000
②因为7<23，则7个字符的等长编码至少需要3位二进制数。假设电文的长度为100，则采用等长编码发送100个字符需要300位的二进制数，采用huffman编码发送100个字符需要(31x2+16x3+10x3+8x4+11x3+20x2+4x4)=261位二进制数，压缩了(300-261)/300=13%。
40[简答]、证明：对任一满二叉树，其分支数B=2(n0-1)。其中，n0为终端结点数。
答：
因为在满二叉树中没有度为1的结点，所以有：n=n0+n2
设Ｂ为树中分支数，则 n=B+1
所以有 B=n0+n2-1
再由二叉树性质: n0=n2+1　代入上式有：B=n0+n0-1-1=2(n0-1)
41[简答]、证明：非空满k叉树的叶子结点数为(k-1)*N+1，其中N为非终端结点数。
答：
因为在满k叉树中所有的非终端结点的度均为k，所以有：n=n0+N
设B为树中分支数，在满k叉树中每个非终端结点都有k个分支，则有：n=B+1=kxN+1
所以，n0=(k-1)xN+1
42[编程]、设一棵有n(n≤100)个结点的二叉树按顺序存储方式存储在bt[1…n]中，编写算法Ancestor，求出二叉树中编号为i和j的两个结点的最近公共祖先结点。
答：
int Ancestor(int i, int j){
while(i!=j){
if(i>j) i=i/2; //下标为i的结点的双亲结点的下标
else j=j/2; //下标为j的结点的双亲结点的下标
}
return i;
}
43[编程]、设计算法PreOrder，按前序次序的逆序打印二叉树中的叶子结点。假设二叉树的二叉链表存储结构定义为：
typedef struct BiTNode{
TElemType data;
struct BiTNode * lchild, *rchild; //左右孩子指针
}BiTNode, *BiTree;
答：要想得到前序次序的逆序，只要按照前序遍历相反的顺序即可。注意，遍历过程中不是打印每个结点，而是打印出其中的叶子结点。
void PreOrder(BiTree T){
if(T){
PreOrder(T->rchild);
PreOrder(T->lchild);
if(!T->lchild && !T->rchild) printf(T->data);
}
}
44[编程]、设计算法Depth，求二叉树的深度。假设二叉树的二叉链表存储结构定义为：
typedef struct BiTNode{
TElemType data;
struct BiTNode * lchild, *rchild; //左右孩子指针
}BiTNode, *BiTree;
答：当二叉树为空时，深度为0；若二叉树不为空，深度应是其左右子树深度的最大值加1,而其左右子树的深度的求解又可通过递归调用本算法完成。
int Depth(BiTree T){
if(!T) return 0;
else{
hl=Depth(T->lchild);
hr=Depth(T->rchild);
return max(h1, hr)+1;
}
}
45、设计算法CopyTree，复制一棵二叉树。假设二叉树的二叉链表存储结构定义为：
typedef struct BiTNode{
TElemType data;
struct BiTNode * lchild, *rchild; //左右孩子指针
}BiTNode, *BiTree;
答：复制二叉树是已经存在一棵二叉树，要求按原二叉树的结构重新生成一棵二叉树，其实质就是按照原二叉树的二叉链表再建立一个新的二叉链表。
BiTree CopyTree(BiTree T){
if(!T) return NULL; //复制一棵空树
else{
newlptr=CopyTree(T->lchild); //复制左子树
newrptr=CopyTree(T->rchild); //复制右子树
//生成一个二叉链表结点
newnode=(BiTNode *)mallac(sizeof(BiTNode));
newnode->data=T->data;
newnode->lchild=newlptr; //左指针为newlptr
newnode->rchild=newrptr; //右指针为newrptr
return newnode;
}
}
46[编程]、设计算法Search，在二叉树中查找值为x的结点。假设二叉树的二叉链表存储结构定义为：
typedef struct BiTNode{
TElemType data;
struct BiTNode * lchild, *rchild; //左右孩子指针
}BiTNode, *BiTree;
答：
BiTNode * Search(BiTree T, TElemType x){
if(TNULL) return NULL;
else{
if(T->datax) return root;
else{
p=Search(T->lchild, x);
//如果在左子树中没找到则查找右子树
if(!p) p=Search(T->rchild);
return p;
}
}
}
48[编程]、编写算法Create，根据二叉树的前序序列pre[]和中序序列in[]建立该二叉树。假定，函数pos(x, in, i)的返回值为在数组in[]中从第i个元素开始查找元素值等于x的元素的位置，pre[]和in[]的长度均为k。假设二叉树的二叉链表存储结构定义为：
typedef struct BiTNode{
TElemType data;
struct BiTNode * lchild, *rchild; //左右孩子指针
}BiTNode, *BiTree;
答：
Void Create(BiTree & T, TElemType pre[], TElemType in[],
int i1, int i2, int k){
//pre数组存放二叉树的前序序列，in数组存放二叉树的中序序列
//i1为前序序列的起始下标，i2为中序序列的起始下标，k为序列的长度
if(k <= 0) T = NULL;
else{
T = (BiTNode *)malloc(sizeof(BiTNode));
T->data = pre[i1]; //根结点为前序序列中第1元素
m = pos(pre[i1], in, i2); //查找根结点在中序序列中的位置
leftlen = m - i2; //左子树的长度
rightlen = k - (leftlen + 1); //右子树的长度
//递归建立左子树
Create(T->lchild, pre, in, i1+1, i2, leftlen);
//递归建立右子树
Create(T->rchild, pre, in, i1+leftlen+1, m+1, rightlen);
}
}

图
1、在一个无向图中，所有顶点的度数之和等于所有边数的( C )倍。
A. 1/2 B. 1 C. 2 D. 4
2、n个顶点的强连通图至少有( A )条边，其形状是( G )。
A. n B. n+1 C. n-1 D. nX(n-1)
E. 无回路 F. 有回路 G. 环状 H. 树状
3、具有10个顶点的无向连通图最少有( B )条边，最多有( C )条边。
A. 0 B. 9 C. 45 D. 90
4、G是一个非连通无向图，共有28条边，则该图至少有( D )个顶点。
A. 6 B. 7 C. 8 D. 9
5、在一个具有n个顶点的有向完全图中包含有( B )条边。
A. n(n-1)/2 B. n(n-1) C. n(n+1)/2 D. n2
6、无向图G有16条边，度为4的顶点有3个，度为3的顶点有4个，其余顶点的度均小于3，则图G至少有( B )个顶点。
A. 10 B. 11 C. 12 D. 13
7、对于一个具有n个顶点的无向图，若采用邻接矩阵存储，则该矩阵的大小是( D )
A. n B. (n-1)2 C. n-1 D. n2
8、有一个网的邻接矩阵，可以看出，该图共有( A )个顶点。
A. 3 B. 6 C. 9 D. 以上答案均不正确
9、无向图的邻接矩阵是一个( C )，有向图的邻接矩阵是一个( D )
A. 上三角矩阵 B. 下三角矩阵 C. 对称矩阵 D. 无规律
10、具有n个顶点e条边的无向图采用邻接矩阵存储，则零元素的个数为( D )
A. e B. 2e C. n2-e D. n2-2e
11、用邻接表存储图所用的空间大小( A )
A. 与图的顶点数和边数都有关 B. 只与图的边数有关系
C. 只与图的顶点数有关 D. 与边数的平方有关
12、在有向图的邻接表存储结构中，顶点v在边表中出现的次数是( C )。
A. 顶点v的度 B. 顶点v的出度
C. 顶点v的入度 D. 依附于顶点v的边数
13、具有n个顶点的无向图，其邻接表最多有( B )个边表结点。
A. n2 B. n(n-1) C. n(n+1) D. n(n-1)/2
14、带权有向图G采用邻接矩阵储存，则顶点i的入度等于邻接矩阵中( D )。
A. 第i行非∞的元素之和 B. 第i列非∞的元素之和
C. 第i行非∞且非0的元素个数之和 D. 第i列非∞且非0的元素个数之和
15、下列说法不正确的是( C )
A. 图的遍历是从给定的源点出发每一个顶点仅被访问一次
B. 遍历的基本算法有两种：深度遍历和广度遍历
C. 图的深度遍历不适用于有向图
D. 图的深度遍历是一个递归过程
16、最小生成树指的是( C )
A. 由连通网所得到的边数最少的生成树
B. 由连通网所得到的顶点数相对较少的生成树
C. 连通网中所有生成树中权值之和为最小的生成树
D. 连通网的极小连通子图
17、对于右图所示的无向连通网图从顶点d开始用Prim算法构造最小生成树，在构造过程中加入最小生成树的前4条边依次是( A )
A. (d, f)4, (f, e)2, (f, b)3, (b, a)5
B. (f, e)2, (f, b)3, (a, c)3, (f, d)4
C. (d, f)4, (f, e)2, (a, c)3, (b, a)5
D. (d, f)4, (d, b)5, (f, e)2, (b, a)5
18、下面关于工程计划的AOE网的叙述中，不正确的是( B )
A. 关键活动不按期完成就会影响整个工程的完成时间
B. 任何一个关键活动提前完成，那么整个工程将会提前完成
C. 所有的关键活动都提前完成，那么整个工程将会提前完成
D. 某些关键活动若提前完成，那么整个工程将会提前完成
19、关键路径是AOE网中( A )
A. 从源点到终点的最长路径 B. 从源点到终点的最短路径
C. 从源点到终点的边数最多的路径 D. 从源点到终点的边数最少的路径
20、下面关于求关键路径的说法不正确的是( C )
A. 求关键路径是以拓扑排序为基础的
B. 一个事件的最早开始时间同以该事件为尾的弧的活动最早开始时间相同
C. 一个事件的最迟开始时间为以该事件为尾的弧的活动最迟开始时间与该活动的持续时间相同
D. 关键活动一定位于关键路径上
21[简答]、如图所示是一个无向带权图，请分别按Prim算法和Kruskal算法给出最小生成树的求解过程（注：Prim算法要求从a顶点出发）。
参考答案：Prim算法求最小生成树的过程

Kruskal算法求最小生成树的过程

[简答][拉档拔高题]、一家输油公司在6个地点{a, b, c, d, e, f}有储油罐，现要在这些储油罐之间建造若干输油管道，在这些储油罐之间调配石油，并向沿途的客户输出。因为建造输油管十分昂贵（主要是不同线路输油管之间的链接处，所需材料与技术昂贵，而同一线路输油管的管道费用相对低廉），所以公司希望建造尽可能少的输油管道（线路数）。另一方面，每条输油管在向沿途客户供油时都会产生利润，公司希望所产生的利润最大。可以建造输油管的储油罐分布如下图所示，其中顶点表示储油罐，边表示可以建造输油管，边上的权值表示相应的输油管所能产生的利润。假设每条输油管的建造费用都相同，请为该公司设计最佳建造输油管的方案。

参考答案：可以把这个问题看作求最大生成树，即在利用Prim算法或Kruskal算法求最小生成树时每次取权值最大的边，求得的一棵生成树如下图所示：

也可将所有边的权值变为相反数（负数），然后求最小生成树。
22[编程]、设有向图G采用邻接表存储，设计算法CountIn，打印输出图G中每个顶点的入度。假设图的邻接表存储定义如下：
#define MAX_VERTEX_NUM 20
typedef struct ArcNode{
int adjvex; //该弧所指向的顶点的位置
struct ArcNode * nextarc; //指向下一条弧的指针
InfoType * info; //该弧相关信息的指针
}ArcNode;
typedef struct VNode{
VertexType data; //顶点信息
ArcNode * firstarc; //指向第一条依附该顶点的弧指针
}VNode, AdjList[MAX_VERTEX_NUM];
typedef struct{
AdjList vertices;
int vexnum, arcnum; //图的当前顶点数和弧数
int kind; //图的种类标志
}ALGraph;
答：
void CountIn(ALGraph G)
{
for(i=0; i<G.vexnum; ++i)
indegree[i]=0;
for(i=0; i<G.vexnum; ++i){
p=G.vertices[i].firstarc;
while(p!=NULL){
indegree[p->adjvex]++;
p=p->nextarc;
} //while
} //for
for(i=0; i<G.vexnum; ++i)
printf(indegree[i]);
}

查找
1、静态查找与动态查找的根本区别在于( B )
A. 它们的逻辑结构不一样 B. 施加在其上的操作不同
C. 所包含的数据元素的类型不一样 D. 存储实现不一样
2、平均查找长度与查找集合中记录个数n无关的查找方法( C )
A. 折半查找 B. 平衡查找 C. 散列查找 D. 不存在
3、对线性表进行顺序查找，要求线性表的存储结构为( D )
A. 散列存储 B. 顺序存储 C. 链接存储 D. 顺序存储或链接存储
4、已知一个有序表为{12、18、24、35、47、50、62、83、90、115、134}，当折查找值为90的元素时，经过( A )次比较后查找成功。
A. 2 B. 3 C. 4 D. 5
5、对具有14个元素的有序表R(假定下标从0开始)进行折半查找，查找R[3]时需要比较的序列为( B )
A. R[0]R[1]R[2]R[3] B. R[6]R[2]R[4]R[3]
C. R[0]R[13]R[2]R[3] D. R[6]R[4]R[2]R[3]
6、对有序表A[1…17]进行折半查找，则查找长度为5的元素下标依次是( A )
A. 8,17 B. 5, 10, 12 C. 9, 16 D. 9, 17
7、用n个键值构造一棵二叉排序树，其最低高度为( D )
A. n/2 B. n C. D.
8、二叉排序树中，最小值结点的( A )
A. 左指针一定为空 B. 右指针一定为空
C. 左、右指针均为空 D. 左、右指针均不为空
9、已知9个元素(57、28、16、73、62、95、60、26、43)，按照依次插入的方法生成一棵二叉排序树，查找值为62的结点所需比较次数为( B )
A. 2 B. 3 C. 4 D. 5
10、已知9个元素(57、28、16、73、62、95、60、26、43)，按照依次插入的方法生成一棵二叉排序树，则该树的深度为( C )
A. 2 B. 3 C. 4 D. 5
11、按( B )遍历二叉排序树得到的序列是一个有序序列
A. 前序 B. 中序 C. 后序 D. 层次
12、下列二叉排序树中查找效率最高的是( A )
A. 平衡二叉树 B. 二叉查找树
C. 没有左子树的二叉排序树 D. 没有右子树的二叉排序树
13、在二叉排序树上查找关键码为28的结点(假设存在)，则依次比较的关键码有可能是( C )
A. 30, 36, 28 B. 38, 48, 28
C. 48, 18, 38, 28 D. 60, 30, 50, 40, 38, 36
14、一棵深度为k的平衡二叉树，其每个叶子结点的平衡因子均为0，则该平衡树共有( D )个结点
A. B. C. D.
15、下列关于m阶B-树的说法错误的是( C )
A. 根结点至多有m棵子树
B. 所有叶子都在同一层次上
C. 非叶结点至少有m/2(m为偶数)或m/2+1(m为奇数)棵子树
D. 根结点中的数据是有序的
16、下面关于m阶B-树说法正确的是( B )
①每个结点至少有两棵非空子树
②树中每个结点至多有m-1个关键码
③所有叶子在同一层上
④当插入一个数据引起B-树结点分裂后，树长高一层
A. ①②③ B. ②③ C. ②③④ D. ③
17、m阶B-树是一棵( B )
A. m叉排序树 B. m叉平衡排序树
C. m-1叉平衡排序树 D. m+1叉平衡排序树
18、设散列表表长m=14，散列函数H(k)=k mod 11。表中已有15、38、61、84四个元素，如果用线性探测处理冲突，则元素49的存储地址是( A )。
A. 8 B. 3 C. 5 D. 9
20、在散列函数H(k)=k mod m中，一般而言，m应取( C )
A. 奇数 B. 偶数 C. 素数 D. 充分大的数
21[简答]、画出长度为10的折半查找判定树，并求等概率时查找成功和不成功的平均查找长度。
答：长度为10的折半查找判定树如下图所示：

查找成功的平均查找长度为(1+2X2+3X4+4X3)/10)=29/10
查找不成功的平均查找长度为(3X5+4X6)=39/11
22[简答]、已知一棵二叉排序树如下图所示，分别画出删除元素90和47后的二叉排序树。

答：删除元素90后的二叉排序树和删除元素47后的二叉排序树，分别下左右两图所示：

23[简答]、对下图所示的3阶B-树，试分别①画出插入关键码序列为{2、12、16、17、18}后B-树，②及删除关键码序列为{4、8、10、5}后B-树。

答：插入关键码序列为{2、12、16、17、18}后B-树为

删除关键码序列为{4、8、10、5}后B-树

24[编程]、试写出折半查找非递归算法。设有序表存放于int型数组r中，数组元素从索引（下标）1开始存放，长度为n，待查关键字为k，折半查找的非递归函数名为BinSearch。若查找成功，返回关键字为k的元素的索引值（下标）；若查找失败，返回整数0。
答：
int BinSearch(int r[], int n, int k)
{
low = 1;
high = n;
while(low<=high){
mid=(low+high)/2;
if(k<r[mid])
high=mid-1;
else if(k>r[mid])
low=mid+1;
else
return mid;
}
return 0;
}
25[编程]、试写出折半查找递归BinSearch算法。设有序表存放于int型数组r中，数组元素从索引（下标）1开始存放，长度为n，待查关键字为k，折半查找的递归函数名为BinSearch。若查找成功，返回关键字为k的元素的索引值（下标）；若查找失败，返回整数0。
答：
int BinSearch(int r[], int low, int high, int k)
{
if(low>high)
return 0;
else{
mid=(low+high)/2;
if(k<r[mid])
return BinSearch(r, low, mid-1, k);
else if(k>r[mid])
return BinSearch(r, mid+1, high, k);
eles
return mid;
}
}
显然，初始调用为BinSearch(r, 1, n, k)。

排序
1、排序算法的稳定性是指( A )
A. 经过排序之后，能使值相同的数据保持原顺序中的相对位置不变
B. 经过排序之后，能使值相同的数据保持原顺序中的绝对位置不变
C. 排序算法的性能与被排序元素的数量关系不大
D. 排序算法的性能与被排序元素的数量关系密切
2、对数据序列{15, 9, 7, 8, 20, -1, 4}进行排序，一趟后数据序列变为{9, 15, 7, 8, 20, -1, 4}，则采用的是( C )。
A. 选择排序 B. 冒泡排序 C. 插入排序 D. 堆排序
3、对数据序列{98, 36, -9, 0, 47, 23, 1, 8, 10, 7}采用希尔排序，下列( A )是增量为4的排序结果。
A. {10, 7, -9, 0, 47, 23, 1, 8, 98, 36}
B. {-9, 0, 36, 98, 1, 8, 23, 47, 7, 10}
C. {36, 98, -9, 0, 23, 47, 1, 8, 7, 10}
D. 以上都不对
4、将记录序列{8, 9, 10, 4, 5, 6, 20}采用冒泡（起泡）排序排成升序序列，需要进行( B )趟（假设采用从前向后的扫描方式）。
A. 3 B. 4 C. 5 D. 8
5、对数列{25, 84, 21, 47, 15, 27, 68, 35, 20}进行排序，元素序列的变化情况如下：
①25, 84, 21, 47, 15, 27, 68, 35, 20
②20, 15, 21, 25, 47, 27, 68, 35, 84
③15, 20, 21, 25, 35, 27, 47, 68, 84
④15, 20, 21, 25, 27, 35, 47, 68, 84
则其采用的排序方法是( C )
A. 希尔排序 B. 简单选择排序 C. 快速排序 D. 归并排序
6、一组记录的关键码为{46, 79, 56, 38, 40, 84}，则利用快速排序的方法，以第一个记录为基准（基轴）得到的一次划分结果为( A )。
A. {40, 38, 46, 56, 79, 84} B. {40, 38, 46, 79, 56, 84}
C. {40, 38, 46, 84, 56, 79} D. {84, 79, 56, 46, 40, 38}
7、就平均时间而言，( D )最佳。
A. 直接插入排序 B. 冒泡(起泡)排序 C. 简单选择排序 D. 快速排序
8、( D )方法是从未排序序列中挑选元素，并将其放入已排序列的一端。
A. 归并排序 B. 插入排序 C. 快速排序 D. 选择排序
9、对数据序列{84, 47, 25, 15, 21}进行排序，数据序列的变化为：{84, 47, 25, 15, 21}->{15, 47, 25, 84, 21}->{15, 21, 25, 84, 47}->{15, 21, 25, 47, 84}，则采用的排序方法是( A )。
A. 简单选择排序 B. 快速排序 C. 冒泡(起泡)排序 D. 直接插入排序
10、堆的形状是一棵( C )。
A. 二叉排序树 B. 满二叉树 C. 完全二叉树 D. 判定树
11、下面的序列中，( A )是堆。
A. {1, 2, 8, 4, 3, 9, 10, 5} B. {1, 5, 10, 6, 7, 8, 9, 2}
C. {9, 8, 7, 6, 4, 8, 2, 1} D. {9, 8, 7, 6, 5, 4, 3, 7}
12、对关键码序列{23, 17, 72, 60, 25, 8, 68, 71, 52}进行堆排序，输出两个最小关键码后的剩余堆是( D )。
A. {23, 72, 60, 25, 68, 71, 52} B. {23, 25, 52, 60, 71, 72, 68}
C. {71, 25, 23, 52, 60, 72, 68} D. {23, 25, 68, 52, 60, 72, 71}
13、下述二叉树中，( C )从任意结点出发到根结点的路径上所经过的结点序列按其关键码有序。
A. 完全二叉树 B. 平衡二叉树 C. 堆 D. 二叉排序树
14、以下排序方法中，稳定的排序方法是( C )
A. 快速排序 B. 希尔排序 C. 基数排序 D. 堆排序
15[简答]、判别下列序列是否为堆，如果不是，按照堆排序思想把它调整为堆，并绘出调整后的堆。
①{1, 5, 7, 25, 21, 8, 8, 42}
②{3, 9, 5, 8, 4, 17, 21, 6}
答：①是堆
②不是堆，调整后的堆为：

16[编程]、试写出直接插入排序InsertSort算法。假设待排序元素存放于整型数组r中，长度为n，开始索引（下标）为1。
答：
void InsertSort(int r[], int n)
{
for(i=2; i<=n; ++i){ //进行n-2趟插入排序
r[0]=r[i]; //设置哨兵
for(j=i-1; r[0]<r[j]; --j) //寻找插入位置
r[j+1]=r[j]; //记录后移
r[j+1]=r[0];
}
}
17[编程]、试写出希尔排序ShellSort算法。假设待排序元素存放于整型数组r中，长度为n，开始索引（下标）为1。希尔排序增量d的初始值为n，以后的每趟排序中，新的d值为原值的二分之一。
void ShellSort(int r[], int n){
for(d=n/2; d>=1; d=d/2){ //以增量为d进行直接插入排序
for(i=d+1; i<=n; ++i){
r[0]=r[i];
for(j=i-d; j>0 && r[0]<r[j]; j=j-d)
r[j+d]=r[j];
r[j+d]=r[0]; //记录后移d个位置
}
}
}
18[编程]、试写出冒泡（起泡）排序BubbleSort算法。假设待排序元素存放于整型数组r中，长度为n，开始索引（下标）为1。
void BubbleSort(int r[], int n)
{
exchange=n; //第一趟起泡排序的范围是r[1]到r[n]
while(exchange){ //仅当上一趟排序有记录交换才进行本趟排序
bound=exchange;
exchange=0;
for(j=1; j<bound; ++j){ //一趟起泡排序
if(r[j]>r[j+1]){
r[j]<–>r[j+1];
exchange=j; //记录最后一次发生记录交换的位置
}
}
}
}
19[编程]、试写出简单选择排序SelectSort算法。假定待排序元素存放于整型数组r中，长度为n，开始索引（下标）为1。
void SelectSort(int r[], int n)
{
for(i=1; i<n; ++i){ //对n个记录进行n-1趟简单选择排序
index=i;
for(j=i+1; j<=n; ++j){ //在无序区中选取最小记录
if(r[j]<r[index]){
index=j;
}
}
if(index!=i){
r[i]<–>r[index];
}
}
}

算法与数据结构重点归纳相关推荐

2015计算机考研重点,2015考研计算机复习：数据结构重点归纳_跨考网
计算机专业数据结构复习重点归纳(适于清华严版教材) 一.数据结构的章节结构及重点构成数据结构学科的章节划分基本上为:概论,线性表,栈和队列,串,多维数组和广义表,树和二叉树,图,查找,内排,外排,文 ...
【村长的算法教程】算法与数据结构基础重点
这份教程针对数据结构与算法的基础重点进行梳理,以便快速复习相关知识点以及思想,不求全,而求精. 一.二叉树栈和队列就不说了,栈是先进后出,队列是先进先出.树也有几个专业名词,分别是:高度(从 ...
面试复试重点算法与数据结构
算法.数据结构一:算法 1. 算法的几个特征是什么. 2. 算法复杂性的定义.大O.θ.Ω.小o分别表示的含义. 3. 递归算法的定义.递归算法的两要素. 4. 分治算法的思想,经典的分治算法(全排 ...
Linux内核中的算法和数据结构
算法和数据结构纷繁复杂,但是对于Linux Kernel开发人员来说重点了解Linux内核中使用到的算法和数据结构很有必要. 在一个国外问答平台stackexchange.com的Theoretica ...
计算机考研专业课复习资料,考研计算机专业课复习重点归纳
考研计算机专业课复习重点归纳中国大学网考研:一.数据结构的章节结构及重点构成数据结构学科的章节划分基本上为:概论,线性表,栈和队列,串,多维数组和广义表,树和二叉树,图,查找,内排,外排,文件,动态 ...
python数据结构推荐书-「算法与数据结构」从入门到进阶吐血整理推荐书单
推荐一下「算法与数据结构」从入门到进阶的书单. 一.入门系列这些书籍通过图片.打比方等通俗易懂的方法来讲述,让你能达到懂一些基础算法,线性表,堆栈,队列,树,图,DP算法,背包问题等,不要求会实现, ...
算法与数据结构——并查集
文章推荐:[算法与数据结构]-- 并查集例子: 数据结构--最小生成树之克鲁斯卡尔算法(Kruskal) 1.2 并查集思想(重点) 我们可以把每个连通分量看成一个集合,该集合包含了连通分量的所有点 ...
python算法和数据结构_Python中的数据结构和算法
python算法和数据结构 To 至 Leonardo da Vinci 达芬奇(Leonardo da Vinci) 介绍 (Introduction) The purpose of this ar ...
算法与数据结构c语言版PPT,C语言算法与数据结构.ppt
C语言算法与数据结构.ppt 第十二章算法与数据结构12.1 算法的基本概念,该节知识点所占试题比重为12,属于重点考查对象,基本上每次必考,主要考查算法的定义和对算法复杂度的理解.历次试题分值在0 ...

算法与数据结构重点归纳

算法与数据结构重点归纳相关推荐

最新文章

热门文章