李云清揭安全数据结构答案文档格式.docx
- 文档编号:22004003
- 上传时间:2023-02-02
- 格式:DOCX
- 页数:62
- 大小:43.90KB
李云清揭安全数据结构答案文档格式.docx
《李云清揭安全数据结构答案文档格式.docx》由会员分享,可在线阅读,更多相关《李云清揭安全数据结构答案文档格式.docx(62页珍藏版)》请在冰豆网上搜索。
T(n)表示算法基本操作的执行次数。
为了评价算法的执行效率,通常采用大写O符号表示算法
的时间复杂度,大写O符号给出了函数f的一个上限。
其它义如下:
3
定义:
f(n)=O(g(n))当且仅当存在正的常数c和n0,使得对于所有的n≥n0,有f(n)≤cg(n)。
上述定义表明,函数f顶多是函数g的c倍,除非n小于n0。
因此对于足够大的n(如n≥n0),
g是f的一个上限(不考虑常数因子c)。
在为函数f提供一个上限函数g时,通常使用比较
简单的函数形式。
比较典型的形式是含有n的单个项(带一个常数系数)。
表1-1列出了一些
常用的g函数及其名称。
对于表1-1中的对数函数logn,没有给出对数基,原因是对于任何大
于1的常数a和b都有logan=logbn/logba,所以logan和logbn都有一个相对的乘法系数1/logba,
其中a是一个常量。
表1-1常用的渐进函数
算法的空间复杂度指的是什么如何表示
算法的空间复杂度是指算法在执行过程中占用的额外的辅助空间的个数。
可以将它表
示为问题规模的函数,并通过大写O符号表示空间复杂度。
对于下面的程序段,分析带下划线的语句的执行次数,并给出它们的时间复杂度T(n)。
(1)i++;
(2)for(i=0;
i<
n;
i++)
if(a[i]<
x)x=a[i];
(3)for(i=0;
for(j=0;
j<
j++)
printf(“%d”,i+j);
(4)for(i=1;
=n-1;
{k=i;
for(j=i+1;
=n;
if(a[j]>
a[j+1])k=j;
t=a[k];
a[k]=a[i];
a[i]=t;
}
(5)for(i=0;
{++x;
s=s+x;
(1)O
(1);
(2)O(n);
(3)O(n2);
(4)O(n);
(5)O(n2)
4
第2章线性表及其顺序存储
选择题
(1)表长为n的顺序存储的线性表,当在任何位置上插入或删除一个元素的概率相等时,
插入一个元素所需移动元素的平均个数为(E),删除一个元素所需移动元素的平均个数
为(A)。
A.(n1)/2B.nC.n+1D.n1
E.n/2F.(n+1)/2G.(n2)/2
(2)设栈S和队列Q的初始状态为空,元素e1、e2、e3、e4、__________e5和e6依次通过栈S,
一个元素出栈后即进入队列Q,若6个元素出队的序列为e2、e4、e3、e6、e5和e1,则栈S
的容量至少应该为(C)。
A.6B.4C.3D.2
(3)设栈的输入序列为1、2、3…n,若输出序列的第一个元素为n,则第i个输出的元素为
(B)。
A.不确定B.ni+1C.iD.ni
(4)在一个长度为n的顺序表中删除第i个元素(1<
=i<
=n)时,需向前移动(A)个
元素。
A.niB.ni+1C.ni1D.i
(5)若长度为n的线性表采用顺序存储结构存储,在第i个位置上插入一个新元素的时
间复杂度为(A)。
A.O(n)B.O
(1)C.O(n2)D.O(n3)
(6)表达式a*(b+c)d的后缀表达式是(B)。
A.abcd*+B.abc+*dC.abc*+dD.+*abcd
(7)队列是一种特殊的线性表,其特殊性在于(C)。
A.插入和删除在表的不同位置执行B.插入和删除在表的两端位置执行
C.插入和删除分别在表的两端执行D.插入和删除都在表的某一端执行
(8)栈是一种特殊的线性表,具有(B)性质。
A.先进先出B.先进后出C.后进后出D.顺序进出
(9)顺序循环队列中(数组的大小为n),队头指示front指向队列的第1个元素,队尾
指示rear指向队列最后元素的后1个位置,则循环队列中存放了n1个元素,即循环队列满
的条件为(B)。
A.(rear+1)%n=front1B.(rear+1)%n=front
C.(rear)%n=frontD.rear+1=front
(10)顺序循环队列中(数组的大小为6),队头指示front和队尾指示rear的值分别为3
和0,当从队列中删除1个元素,再插入2个元素后,front和rear的值分别为(D)。
A.5和1B.2和4C.1和5D.4和2
什么是顺序表什么是栈什么是队列
5
当线性表采用顺序存储结构时,即为顺序表。
栈是一种特殊的线性表,它的特殊性表
现在约定了在这种线性表中数据的插入与删除操作只能在这种线性表的同一端进行(即栈顶),
因此,栈具有先进后出、后进先出的特点。
队列也是一种特殊的线性表,它的特殊性表现在约
定了在这种线性表中数据的插入在表的一端进行,数据的删除在表的另一端进行,因此队列具
有先进先出,后进后出的特点。
设计一个算法,求顺序表中值为x的结点的个数。
顺序表的存储结构定义如下(文件名):
#include<
>
#defineN100/*预定义最大的数据域空间*/
typedefintdatatype;
/*假设数据类型为整型*/
typedefstruct{
datatypedata[N];
/*此处假设数据元素只包含一个整型的关键字域*/
intlength;
/*线性表长度*/
}seqlist;
/*预定义的顺序表类型*/
算法countx(L,x)用于求顺序表L中值为x的结点的个数。
intcountx(seqlist*L,datatypex)
{intc=0;
inti;
for(i=0;
L->
length;
if(L->
data[i]==x)c++;
returnc;
设计一个算法,将一个顺序表倒置。
即,如果顺序表各个结点值存储在一维数组a中,倒
置的结果是使得数组a中的a[0]等于原来的最后一个元素,a[1]等于原来的倒数第2个元
素,…,a的最后一个元素等于原来的第一个元素。
顺序表的存储结构定义同题,实现顺序表倒置的算法程序如下:
voidverge(seqlist*L)
{intt,i,j;
i=0;
j=L->
length-1;
while(i<
j)
{t=L->
data[i];
data[i++]=L->
data[j];
data[j--]=t;
已知一个顺序表中的各结点值是从小到大有序的,设计一个算法,插入一个值为x的结点,
使顺序表中的结点仍然是从小到大有序。
顺序表的定义同题,实现本题要求的算法程序如下:
6
voidinsertx(seqlist*L,datatypex)
{intj;
length<
N)
{j=L->
while(j>
=0&
&
L->
data[j]>
x)
{L->
data[j+1]=L->
j--;
data[j+1]=x;
length++;
将下列中缀表达式转换为等价的后缀表达式。
(1)5+6*7
(2)(5-6)/7
(3)5-6*7*8
(4)5*7-8
(5)5*(7-6)+8/9
(6)7*(5-6*8)-9
(7)5+6*7后缀表达式:
567*+
(8)(5-6)/7后缀表达式:
56-7/
(9)5-6*7*8后缀表达式:
567*8*-
(10)5*7-8后缀表达式:
57*8-
(11)5*(7-6)+8/9后缀表达式:
576-*89/+
(12)7*(5-6*8)-9后缀表达式:
7568*-*9-
循环队列存储在一个数组中,数组大小为n,队首指针和队尾指针分别为front和rear,请
写出求循环队列中当前结点个数的表达式。
循环队列中当前结点个数的计算公式是:
(n+rear-front)%n
编号为1,2,3,4的四列火车通过一个栈式的列车调度站,可能得到的调度结果有哪些如果
有n列火车通过调度站,请设计一个算法,输出所有可能的调度结果。
解题思路:
栈具有先进后出、后进先出的特点,因此,任何一个调度结果应该是1,2,3,4
全排列中的一个元素。
由于进栈的顺序是由小到大的,所以出栈序列应该满足以下条件:
对于
序列中的任何一个数其后面所有比它小的数应该是倒序的,例如4321是一个有效的出栈序列,
1423不是一个有效的出栈结果(4后面比它小的两个数2,3不是倒序)。
据此,本题可以通过
算法产生n个数的全排列,然后将满足出栈规则的序列输出。
产生n个数的全排列有递归与非递归两种实现算法。
产生全排列的递归算法:
7
设R={r1,r2,…,rn}是要进行排列的n个元素,Ri=R-{ri}。
集合X中元素的全排列记为
perm(X)。
(ri)perm(X)表示在全排列perm(X)的每一个排列前加上前缀ri得到的排列。
R的全排
列可归纳定义如下:
当n=1时,perm(R)=(r),其中r是集合R中惟一的元素;
当n>
1时,perm(R)由(r1)perm(R1),(r2)perm(R2),…,(rn)perm(Rn)构成。
依此递归定义,可设计产生perm(R)的递归算法如下:
递归解法:
#include<
intcont=1;
/*全局变量,用于记录所有可能的出栈序列个数*/
voidprint(intstr[],intn);
/*求整数序列str[]从k到n的全排列*/
voidperm(intstr[],intk,intn)
{inti,temp;
if(k==n-1)print(str,n);
else
{for(i=k;
{temp=str[k];
str[k]=str[i];
str[i]=temp;
perm(str,k+1,n);
/*递归调用*/
temp=str[i];
str[i]=str[k];
str[k]=temp;
/*本函数判断整数序列str[]是否满足进出栈规则,若满足则输出*/
voidprint(intstr[],intn)
{inti,j,k,l,m,flag=1,b[2];
for(i=0;
i++)/*对每个str[i]判断其后比它小的数是否为降序序列*/
{m=0;
n&
flag;
if(str[i]>
str[j]){if(m==0)b[m++]=str[j];
else{if(str[j]>
b[0]){flag=0;
elseb[0]=str[j];
if(flag)/*满足出栈规则则输出str[]中的序列*/
{printf("
%2d:
"
cont++);
printf("
%d"
str[i]);
\n"
);
8
intmain()
{intstr[100],n,i;
inputaint:
/*输出排列的元素个数*/
scanf("
&
n);
i++)/*初始化排列集合*/
str[i]=i+1;
inputtheresult:
perm(str,0,n);
return0;
当参与进出栈的元素个数为4时,输出的结果如下图所示。
该算法执行的时间复杂度为O(n!
)。
随着n的增大,算法的执行效率非常的低。
非递归解法:
()
对一组数穷尽所有排列,还可一种更直接的方法,将一个排列看作一个长整数,则所有排
列对应着一组整数,将这组整数按从小到大的顺序排成一个数列,从对应最小的整数开始,按
数列的递增顺序逐一列举每个排列对应的每一个整数,这能更有效地完成排列的穷举。
从一个
排列找出对应数列的下一个排列可在当前排列的基础上作部分调整来实现。
倘若当前排列为
1,2,4,6,5,3,并令其对应的长整数为124653。
要寻找比长整数124653更大的排列,可从该排列
的最后一个数字顺序向前逐位考察,当发现排列中的某个数字比它前一个数字大时,如本例中
的6比它的前一位数字4大,则说明还有可能对应更大整数的排列。
但为顺序从小到大列举出
所有的排列,不能立即调整得太大,如本例中将数字6与数字4交换得到的排列为126453就
不是排列124653的下一个排列。
为得到排列124653的下一个排列,应从已考察过的那部分数
字中选出比数字4大,但又是它们中最小的那一个数字,比如数字5,与数字4交换。
该数字
也是从后向前考察过程中第一个比4大的数字,5与4交换后,得到排列125643。
在前面数字
1,2,5固定的情况下,还应选择对应最小整数的那个排列,为此还需将后面那部分数字的排
列颠倒,如将数字6,4,3的排列顺序颠倒,得到排列1,2,5,3,4,6,这才是排列1,2,4,6,
9
5,3的下一个排列。
按照以上想法可以编写非递归程序实现n个数的全排列,对满足进出栈
规则的排列则计数并输出。
/*本程序输出12...n个序列进栈出栈的序列*/
intpl(intn)
{inta[100];
/*最大处理范围为99个数*/
intflag=1,flag1=0;
FILE*rf;
inti,j,k,x,count=0;
rf=fopen("
"
w"
);
/*用于存放进出栈序列结果*/
for(i=1;
i++)/*初始序列*/
a[i]=i;
while(flag)/*还剩余未输出的排列*/
{flag1=1;
/*判断本次排列是否符合进栈出栈序列*/
{j=i+1;
while(j<
=n&
a[j]>
a[i])j++;
/*找a[i]后第一个比a[i]小__________的元素a[j]*/
k=j+1;
while(k<
=n)/*如果a[j]后还有比a[i]小且比a[j]大的元素,则此排列无效*/
{if(a[k]<
a[i]&
a[k]>
a[j])flag1=0;
k++;
if(flag1)
{for(i=1;
i++)/*输出当前排列*/
%4d"
a[i]);
fprintf(rf,"
count++;
/*计数器加1*/
i=n;
/*从后向前找相邻位置后大前小的元素值*/
while(i>
1&
a[i]<
a[i-1])i--;
if(i==1)flag=0;
/*未找到则结束*/
{j=i-1;
/*若找到,则在该位置的后面从右向左找第一个比该元素大的值*/
j&
a[j])i--;
k=a[j];
/*交换两元素的值*/
a[j]=a[i];
a[i]=k;
/*对交换后后面的数据由小到大排序*/
10
for(i=k+1;
i++)/*插入排序*/
{j=i-1;
x=a[i];
=k&
x<
a[j]){a[j+1]=a[j];
j--;
a[j+1]=x;
fclose(rf);
returncount;
/*返回排列总个数*/
voidmain()
{intn,m=0;
pleaseinputn:
/*输入排列规模*/
m=pl(n);
\nm=%d"
m);
/*输出满足进出栈的排列总个数*/
程序运行时如果输入4,则输出的结果如下图所示。
该算法的时间复杂度也是O(n!
结论:
如果n个数按编号由小到大的顺序进栈,进栈的过程中可以出栈,则所有可能的出栈序
列的总数为:
(1)!
!
(2)!
nnn
n
+
11
第3章线性表的链式存储
(1)两个有序线性表分别具有n个元素与m个元素且n≤m,现将其归并成一个有序表,
其最少的比较次数是(A)。
A.nB.mC.n1D.m+n
(2)非空的循环单链表head的尾结点(由p所指向)满足(C)。
A.p->
next==NULLB.p==NULLC.p->
next==headD.p==head
(3)在带头结点的单链表中查找x应选择的程序体是(C)。
A.node*p=head->
next;
while(p&
p->
info!
=x)p=p->
if(p->
info==x)returnpelsereturnNULL;
B.node*p=head;
while(p&
returnp;
C.node*p=head->
p->
D.node*p=head;
while(p->
next;
(4)线性表若采用链式存储结构时,要求内存中可用存储单元的地址(D)。
A.必须是连续的B.部分地址必须是连续的
C.一定是不连续的D.连续不连续都可以
(5)在一个具有n个结点的有序单链表中插入一个新结点并保持单链表仍然有序的时间
复杂度是(B)。
A.O
(1)B.O(n)C.O(n2)D.O(nlog2
n)
(6)用不带头结点的单链表存储队列时,其队头指针指向队头结点,其队尾指针指向队
尾结点,则在进行删除操作时(D)。
A.仅修改队头指针B.仅修改队尾指针
C.队头、队尾指针都要修改D.队头,队尾指针都可能要修改
(7)若从键盘输入n个元素,则建立一个有序单向链表的时间复杂度为(B)。
A.O(n)B.O(n2)C.O(n3)D.O(nlog2n)
(8)下面哪个术语与数据的存储结构无关(D)。
A.顺序表B.链表C.散列表D.队列
(9)在一个单链表中,若删除p所指结点的后续结点,则执行(A)。
next=p->
next->
B.p=p->
C.p->
D.p=p->
(10)在一个单链表中,若p所指结点不是最后结点,在p之后插入s所指结点,则执行(B)。
A.s->
next=p;
next=s;
B.s->
C.s->
p=s;
D.p->
s->
设计一个算法,求一个单链表中的结点个数。
单链表存储结构定义如下(相关文件:
)
12
typedefstructnode
{intdata;
structnode*next;
}linknode;
typedeflinknode*linklist;
/*尾插法创建带头结点的单链表*/
linklistcreatlinklist()
{linklisthead,r,x,s;
head=r=(linklist)malloc(sizeof(linknode));
\n请输入一组以0结束的整数序列:
x);
while(x)
{s=(linklist)malloc(sizeo
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 李云清揭 安全 数据结构 答案
![提示](https://static.bdocx.com/images/bang_tan.gif)