没有合适的资源?快使用搜索试试~ 我知道了~
2.( 1 ),当且仅当 3.( 0 )若借助二分法查找确定每个元素的插入位置,向量的插入排序只需时间时间 4.( 1 )RPN中各操作数的相对次序,与原中缀表
资源详情
资源评论
资源推荐
THU 数据结构历年期中期末题
第 1 题 正误判断(凡交代未尽之处,皆以讲义及示例代码为准)
1. ( 1 )对有序向量做 Fibonacci 查找,就最坏情况而言,成功查找所需的比较次数与失败查找相
等。
2.( 1 )
f(n) = ( ( ))g nO
,当且仅当
( ) ( ( ))g n f n= W
。
3.( 0 )若借助二分法查找确定每个元素的插入位置,向量的插入排序只需时间
( log )n nO
时间。
4.( 1 )RPN 中各操作数的相对次序,与原中缀表达式完全一致。
5.( 1 )对不含括号的中缀表达式求值时,操作法栈的容量可以固定为某一常数。
6.( 0 )无论有序向量或有序列表,最坏情况下均可在
(log )nO
时间内完成一次查找。
7.( 0 )只要是采用基于比较的排序算法,对任何输入序列都至少需要运行
(n log )nW
时间。
8.( 0 )对于同一有序向量,每次折半查找绝不会慢于顺序查找。
第 2 题 多重选择
1.( C )共有几种栈混洗方案,可以使字符序列{‘x’,’o’,’o’,’o’,’x’}的输出保持原样?
A.12 B. 10 C. 6 D. 5
2.( AD )若
2
f(n) = (n ) ( ) ( )O g n O n=且
,则下列结论正确的是:
A.
2
(n)+ ( ) = (n )f g n O
B.
2
(n)/ ( ) = (n )f g n O
C.
( ) = (f(n))g n O
D.
3
(n)* ( ) = (n )f g n O
3.( B )对长度为
( ) 1n Fib k= -
的有向序列做 Fibonacci 查找。若个元素的数值等概率独立均匀分
布,且平均成功查找长度为 L,则失败平均查找长度为:
A.n(L-1)/(n-1) B. n(L+1)/(n+1) C. (n-1)L/n D. (n+1)L/n
4.( A )对长度为 Fib(12) – 1 = 143 的有序向量做 Fibonacci 查找,比较操作的次数至多为:
A.12 B. 11 C. 10 D. 9
5.( D )算法 g(n)的复杂度为
( )nQ
。若算法 f(n)中有 5 条调用 g(n)的指令,则 f(n)的复杂度为:
A.
( )nQ
B.
( )O n
C.
( )nW
D. 不确定
第 3 题 估计以下函数 F(n)的复杂度(假定 int 类型字长无限,且递归不会溢出)
void F(int n) //O( sqrt(n) )
{
for (int i = 0, j = 0; i<n; i+=j, j++);
}
void F(int n) //O(loglogn )
{
for (int i = 1, r = 1; i<n; i<<=r, r<<=1);
}
void F(int n) //O( nlog(n))
{
for (int i=1; i<n; i++)
for (int j=0; j<n; j+=i);
}
void F(int n) //expected-O(nlog(n) )
{
for (int i=1; i<n; i++)
if(0 == rand()%i)
for (int j=1; j<n; j<<=1);
}
void F(int n) //O(logn* )
{
for (int i=1; i<n; i=1<<i);
}
void F(int n) //O(logn)
{
return (n<4) ? n : F(n>>1)+F(n>>2);
}
int F(int n) //O(n)
{
return (n==0) ? 1 : G(2, F(n-1));
}
int G(int n, int m)
{
return (m==0) ? 0 : n+G(n, m-1);
}
int F(int n) //O(n
{
return G(G(n-1));
}
int G(int n)
{
return (n==0) ? 0 : G(n-1)+2*n-1;
}
第 4 题 分析与计算
1. 考察如下问题:任给 12 个互异的整数,且其中 10 个已组织为一个有序序列,现需要插入剩余
的两个已完成整体排序。若采用基于比较的算法(CBA),最坏情况下至少需要做几次比较?为
什么?
答:8 次。 我们知道对于 CBA,我们可以将其涵盖于一棵比较树里边,而树的每一个节点可以代
表一次比较运算,树的分支可以代表算法下一步执行的方向。由此可以推算,树高则可以代表
比较的次数。
2. 向量的插入排序由 n 次迭代完成,逐次插入各元素。为插入第 k 个元素,最坏情况需要做 k 次移
动,最好情况则无需移动。从期望的角度来看,无需移动操作的迭代次数平均有多少次?为什
么?
假定个元素是等概率独立均匀分布的。
答:logn。调和级数
3. 现有一长度为 15 的有序向量 A[0…14],个元素被成功查找的概率如下:
I
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
( 1)
i
P å =
1/1
28
1/1
28
1/3
2
1/
8
1/
8
1/3
2
1/1
6
1/1
6
1/1
28
1/6
4
1/1
6
1/
4
3/1
6
1/1
28
1/6
4
若采用二分查找算法,试计算该结构的平均成功查找长度。
答:
4. 考察表达式求值算法。算法执行过程中的某时刻,若操作符栈中的括号多达 2010 个,则此时栈
的规模(含栈底的’\n’)至多可能多达?试说明理由,并示范性地画出当时栈中的内容。
答:3*2010+1+4 = 6035。
5. 阅读以下程序,试给出其中 ListReport()一句的输出结果(即当时序列 L 中个元素的数值)
#define LLiST_ELEM_TYPE_iNT //节点数据域为 int 型
LvalueType visit(LvalueType e)
{
static int lemda = 1980;
lemda += e*e;
return lemda;
}
int main(int argc, char* argv[])
{
LList* L = Listinit(-1);
for(int i=0; i<5; i++)
ListinsertLast(L, i);
ListTraverse(L, visit);
ListReport(L); /* 输 出 :
*/
ListDestroy(L);
return 0;
}
1980 1981 1985 1994 2010
第 5 题 基于 ADT 操作实现算法(如有必要,可增加子函数)
1、sortOddEvev(L)
#define LLiST_TYPE_ARRAY //基于向量实现序列
#define LLiST_ELEM_TYPE_iNT //节点数据域为 int 型
/*********************************************************************
*输入:基于向量实现的序列 L
*功能:移动 L 中元素,使得所有奇数集中于前端,所有偶数都集中于后端
*输出:无
*实例:L = {2,13,7,4,6,3,7,12,9},则排列序后
* L = {9,13,7,7,3,6,4,12,2}
*要求:O(n)时间,O(1)附加空间
*********************************************************************/
void sortOddEvev(LList* L){
}
flag1 = 0;
flag2 = n-1;
for (int i=flag1; i<=flag2; i++)
{
if (i%2==0)
剩余15页未读,继续阅读
咖啡碎冰冰
- 粉丝: 11
- 资源: 292
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
最新资源
- python-leetcode面试题解之第162题寻找峰值-题解.zip
- python-leetcode面试题解之第161题相隔为1的编辑距离-题解.zip
- python-leetcode面试题解之第160题相交链表-题解.zip
- python-leetcode面试题解之第159题至少包含两个不同字符的最长子串-题解.zip
- python-leetcode面试题解之第158题用Read4读取N个字符II-多次调用-题解.zip
- Python 程序语言设计模式思路-行为型模式:策略模式:将算法封装成独立的类,并使它们可以互相替换及支付模式数据压缩
- main.py
- Last Loaded Test.DBK
- Screenshot_20240520_163011.jpg
- ubuntu-python3-whisper-tornado docker镜像 Dockerfile
资源上传下载、课程学习等过程中有任何疑问或建议,欢迎提出宝贵意见哦~我们会及时处理!
点击此处反馈
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功
评论0