计130121第二次作业Word文档下载推荐.docx
《计130121第二次作业Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《计130121第二次作业Word文档下载推荐.docx（27页珍藏版）》请在冰豆网上搜索。
Next=p;
p->
Prior->
next=q;
B.p->
next=p;
Prior=p->
Prior;
C.q->
Next=q;
D.q->
13、已知循环队列存储在一维数组A[0…n-1]中，且队列非空时front和rear分别指向对头元素和队尾元素，且要求第一个进入队列的元素存储在A[0]处，则初始时front和rear的值分别是B。
A.0,0B.0,n-1C.n-1,0D.n-1,n-1
14、某队列允许在两端进行入队操作，但仅允许在一端进行出队操作（称为输出受限的双端队列），若a,b,c,d,e元素依次进队，则不可能得到的顺序是C。
A.bacdeB.dbaceC.dbcaeD.ecbad
15、在双向链表中间插入一个结点时，需要修改修改D个指针域。
A.1B.2C.3D.4
16、在按行优先顺序存储的三元组表中，下述陈述错误的是D。
A.同一行的非零元素，是按列号递增次序存储的
B.同一列的非零元素，是按行号递增次序存储的
C.三元组表中三元组行号是非递减的
D.三元组表中三元组列号是非递减的
17、在稀疏矩阵的三元组表示法中，每个三元组表示D。
A.矩阵中非零元素的值
B.矩阵中数据元素的行号和列号
C.矩阵中数据元素的行号、列号和值
D.矩阵中非零数据元素的行号、列号和值
18、对特殊矩阵采用压缩存储的目的主要是为了D。
A.表达变得简单B.对矩阵元素的存取变得简单
C.去掉矩阵中的多余元素D.减少不必要的存储空间
19、广义表是线性表的推广，它们之间的区别在于A。
A.能否使用子表B.能否使用原子项
C.表的长度D.是否能为空
20、已知广义表（a,b,c,d）的表头是A，表尾是D。
A.aB.（）C.（a,b,c,d）D.（b,c,d）
21、下面说法不正确的是A。
A.广义表的表头总是一个广义表B.广义表的表尾总是一个广义表
C.广义表难以用顺序存储结构表示D.广义表可以是一个多层次的结构
22、若广义表A满足Head（A）=Tail（A），则A为B。
A.（）B.（（））C.（（）,（））D.（（）,（）,（））
二、填空题
1、对于循环向量的循环队列，求队列长度的公式为（rear-front+n+1）%n。
2、栈的逻辑特点是后进先出。
队列的逻辑特点是先进先出。
两者的共同特点是只允许在它们的两端出插入和删除数据元素，区别是出栈在顶端，出队列在头部。
3、链队列LQ为空时，LQ->
front->
next=NULL.
4、在一个链队列中，若队首指针为front，队尾指针为rear，则判断该队列只有一个结点的条件为front->
next==rear。
5、设串S=“Ilikecomputer”，T=“com”，则Length（S）=13。
Index（S,T）=5。
6、在KMP算法中，next[j]只与T串有关，而与S无关。
7、字符串“ababaab“的Next数组值是0012312。
8、稀疏矩阵一般压缩存储的方式有三种，分别是三元组表、带行表的三元组表和稀疏矩阵的链式结构。
9、二维数组M中每个元素的长度是3字节，行下标i从0~7，列下标j从0～9，从首地址&
M[0][0]开始连续存放在存储器中。
若按行优先的方式存放，元素M[7][5]的起始地址为
（void）&
M[0][0]+3*70+5；
若按列优先方式存放，元素M[7][5]的起始地址为（void）&
M[0][0]+3*40+7。
10、广义表（a,（a,b）,d,e,（（i,j）,k））的长度是5，深度是3。
11、设广义表A（（（）,（a,（b）,c））2）1，则Cal（Cdr（Cal（Cdr（Cal（A））））=（b）
三、设有一个循环队列Queue，只有头指针front，不设尾指针，另设一个含有元素个数的计数器count，试写出相应的判断队列空、判断队列满、出队算法和入队算法。
要求：
1、定义相应的循环队列的型（只有头指针，没有尾指针，但有一个元素个数的计数器）；
2、定义该队列的四个算法：
判断队列空、判断队列满、出队算法和入队算法；
3、在main函数验证算法的正确性。
////
#include<
iostream>
usingnamespacestd;
typedefintele;
classQueue{
eledata[10];
ele*_font;
intlen;
public:
Queue（）{
_font=data;
len=0;
}
voidpush_back（eleval）{
data[（_font-data+len）%10]=val;
len++;
boolfull（）{
return（len>
=10）;
boolempty（）{
return（len==0）;
voidpop_font（）{
_font=data+（_font-data+1）%10;
len--;
intfont（）{
return*_font;
};
intmain（intargc,char*argv[]）{
Queueq;
inti;
for（i=0;
i<
10;
i++）{
q.push_back（i）;
cout<
<
q.font（）<
endl;
q.pop_font（）;
cout<
"
=====欢乐的分割线====="
return0;
}
/////
四、设主串T=“abcaabbabcabaacbacba“，模式为p=“abcabaa”。
1、计算模式p的nextval函数值
2、不写算法，只画出利用KMP算法进行模式匹配时，每一趟的匹配过程。
1、写出模式p的nextval值；
2、画出KMP算法的每一趟匹配过程（可参照教材P61从第8行开始的内容）；
3、不需要编写程序。
0001211
五、假设表达式中允许包含三种括号：
圆括号、方括号和大括号。
设计一个算法采用顺序栈（用数组表示的栈）判断表达式中的括号是否正确配对。
1、定义栈以及栈的型，栈中所存放元素的类型为字符型，定义枚举类型Boolean，其中两个元素分别为TRUE和FALSE。
2、定义栈的各种操作。
3、定义函数Booleancheck（char*s）;
判断s中的括号是否正确配对，如果正确配对，返回TRUE，否则返回FALSE。
4、在主函数中验证所编写函数的正确性。
stack>
typedefstack<
char>
STACK;
enumBoolean{
FALSE=0,
TRUE=1
Booleancheck（char*s）{
STACK_;
while（*s）{
switch（*s）{
case'
{'
:
case'
（'
case'
['
_.push（*s）;
break;
}'
if（_.top（）!
='
）
returnFALSE;
_.pop（）;
）'
]'
default:
;
}
++s;
if（_.empty（））{
returnTRUE;
}else{
returnFALSE;
//return_.empty（）;
char*data1="
123（）ow{}sa{nfak1（234[s]ff）1f}aer"
;
char*data2="
12（3owsan[fak1）234s]ff1faer"
check（data1）<
endl<
check（data2）<
六、设有一个带头结点的双向链表h，设计一个算法用于查找第一个元素之为x的结点，并将其与其前驱结点进行交换。
1、定义带头结点的双向链表的型DLIST。
2、定义双向链表DLIST的基本操作。
3、定义函数intswap（elementtypex,DLIST&
h），查找第一个元素之为x的结点，如果在链表中存在元素值为x的结点，并其与其前驱结点进行交换，并返回1，否则返回0。
4、在主函数中测试所编写函数的正确性。
/////////D-list.h
#ifndefD_LIST
#defineD_LIST
typedefintelementtype;
structNode{
Node*pre;
Node*next;
elementtypeval;
Node（elementtype_val,Node*_pre,Node*_next）:
val（_val）,pre{_pre},next（_next）{}
classDLIST{
Node*head;
Node*last;
DLIST（）{
head=NULL;
last=NULL;
DLIST（DLIST&
list）{
Node*p=list.head;
while（p）{
push_back（p->
val）;
p=p->
next;
~DLIST（）{
Node*p;
while（head）{
p=head;
head=head->
deletep;
voidpush_back（elementtypeval）{
if（last）{
last->
next=newNode（val,last,NULL）;
last=last->
else{
head=last=newNode（val,NULL,NULL）;
voidprint_back（）{
stringstr;
charbuff[13];
Node*p=last;
str+=（string（itoa（p->
val,buff,10））+"
->
"
）;
pre;
cout<
（str.substr（0,str.length（）-4））;
friendostream&
operator<
（ostream&
out,DLIST&
list）;
friendintswap（elementtypex,DLIST&
h）;
ostream&
charbuff[13];
stringstr;
Node*p=list.head;
while（p）{
str+=（string（itoa（p->
val,buff,10））+"
p=p->
out<
returnout;
intswap（elementtypex,DLIST&
h）{
Node*p=h.head;
if（p->
val==x）{
//pisnotthefirstelement
if（p->
pre）{
//pisnotthesecondelement
if（p->
pre->
if（p->
next）{
p->
next->
pre=p->
}
Node*tmp=p->
p->
next=p;
pre=p;
next=p->
pre=tmp;
}
else{
pre=NULL;
}
return1;
#endif
//////////
//////////main.cpp
#include<
string>
cstdlib>
#include"
D-list.h"
intmain（intargc,char*argv[]）{
DLISTlist;
for（inti=0;
i++）
list.push_back（i）;
cout<
list<
endl;
=====我是萌萌哒的分割线====="
<
swap（4,list）;
list.print_back（）;
七、试编写一个求三元组顺序表示的稀疏矩阵对角线元素之和的算法
////////以下为七八九三题代码
vector>
classTLIST;
classRowList;
constintCOL=10;
constintROW=10;
constintR_COL=COL+1;
constintR_ROW=ROW+1;
structTNODE{
introw;
intcol;
intval;
TNODE（int_row,int_col,int_val）:
row（_row）,col（_col）,val（_val）{}
booloperator<
（TNODE&
a,TNODE&
b）{
if（a.row<
b.row）
return1;
return（a.col<
b.col）;
TNODEoperator+（TNODE&
returnTNODE（a.row,a.col,a.val+b.val）;
classTLIST{
vector<
TNODE>
s;
friendintSiagonalSum（TLIST&
l）;
TLIST（）{
TLIST（TLIST&
l）{
s=l.s;
voidpush_back（TNODEdata）{
s.push_back（data）;
voidinsert（TNODEdata）{
vector<
iteratorit;
for（it=s.begin（）;
it<
s.end（）;
it++）
{
if（（*it）<
data）
continue;
break;
if（it==s.end（））
s.push_back（data）;
return;
if（data.col==it->
col&
&
data.row==it->
row）
it->
val+=data.val;
s.insert（it,data）;
TLISToperator+（TLIST&
TLISTret;
iteratorit1=s.begin（）,
it2=l.s.begin（）,
end1=s.end（）,
end2=l.s.end（）;
while（it1!
=end1&
it2!
=end2）
if（*it1<
*it2）
{
ret.push_back（*it1）;
++it1;
if（*it2<
*it1）
ret.push_back（*it2）;
++it2;
ret.push_back（*it1+*it2）;
it1++;
it2++;
=end1）
ret.push_back（*it1）;
++it1;
while（it2!
=end2）
ret.push_back（*it2）;
++it2;
returnret;
out,TLIST&
friendRowList;
intcol=1,
row=1;
iteratorit=l.s.begin（）,
end=l.s.end（）;
whi
升级会员 