第2章线性表习题参考答案

第2章线性表习题参考答案
习题二参考答案
一、选择题
1.链式存储结构的最大优点是（D）。

A.便于随机存取
B.存储密度高
C.无需预分配空间
D.便于进行插入和
删除操作
2.假设在顺序表{a0,a1,……,an－1}中，每一个数据元素所占的存储
单元的数目为4，且第0
个数据元素的存储地址为100，则第7个数据元素的存储地址是（D）。

A.106B.107C.124D.128
3.在线性表中若经常要存取第i个数据元素及其前趋，则宜采用（A）存储方式。

A.顺序表
B.带头结点的单链表
C.不带头结点的单链表
D.循环单链表
4.在链表中若经常要删除表中最后一个结点或在最后一个结点之后插
入一个新结点，则宜
采用（C）存储方式。

A.顺序表
B.用头指针标识的循环单链表
C.用尾指针标识的循环单链
表D.双向链表
5.在一个单链表中的p和q两个结点之间插入一个新结点，假设新结
点为S,则修改链的
java语句序列是（D）。

A..etNe某t(p);q.etNe某t();B.p.etNe某t(.getNe某t());.etNe某t(p);C.q.etNe某t(.getNe某t());.etNe某t(p);D.p.etNe某t();.etNe某t(q);6.在一个含有n个结点的有序单链表中插入一个新结点，使单链表仍然保持有序的算法的
时间复杂度是（C）。

A.O(1)
B.O(log2n)
C.O(n)
D.O(n2)
7.要将一个顺序表{a0,a1,……,an-1}中第i个数据元素
ai(0≤i≤n-1)删除，需要移动（B）
个数据元素。

A.i
B.n-i-1
C.n-i
D.n-i+1
8.在带头结点的双向循环链表中的p结点之后插入一个新结点，其修改链的java语句序
列是（D）。

A.p.etNe某t();.etPrior(p);p.getNe某t().etPrior();.etNe某t(p.getPrior());
B.p.etNe某t();p.getNe某t().etPrior();.etPrior(p);.etNe某t(p.getNe某t());
C..etPrior(p);.etNe某t(p.getNe某t());p.etNe某t();p.getNe 某t().etPrior();
D..etNe某t(p.getNe某t());.etPrior(p);p.getNe某
t().etPrior();
p.etNe某t();
9.顺序表的存储密度是（B），而单链表的存储密度是（A）。

A．小于1B.等于1C.大于1D.不能确定10.对于图2.29所示的单链表，下列表达式值为真的是（D）。

headABP1CDP2
E图2.29单链表head的存储结构图
A.head.getNe某
t().getData()=='C'B.head.getData()=='B'C.P1.getData()==’D’D.P2
.getNe某t()==null二、填空题
1.线性表是由n（n≥0）个数据元素所构成的有限序列，其中n为数
据元素的个数，称为线性表的长度，n=0的线性表称为空表
2.线性表中有且仅有一个开始结点和终端结点，除开始结点和终端结
点之外，其它每一个数据元素有且仅有一个前驱，有且仅有一个后继
3.线性表通常采用顺序存储和链式存储两种存储结构。

若线性表的长
度确定或变化不大，则适合采用顺序存储存储结构进行存储。

4.在顺序表{a0,a1,……,an-1}中的第i(0≤i≤n-1)个位置之前插入
一个新的数据元素，会引起n-i个数据元素的移动操作。

5.在线性表的单链表存储结构中，每一个结点有两个域，一个是数据域，用于存储数据元素值本身，另一个是指针域，用于存储后继结点的地址。

6.在线性表的顺序存储结构中可实现快速的随机存取，而在链式存储
结构中则只能进行顺序存取。

7.顺序表中逻辑上相邻的数据元素，其物理位置一定相邻，而在单链
表中逻辑上相邻的数据元素，其物理位置不一定相邻。

8.在仅设置了尾指针的循环链表中，访问第一个结点的时间复杂度是
O（1）
9.在含有n个结点的单链表中，若要删除一个指定的结点p，则首先
必须找到指定结点p的前驱，其时间复杂度为O（n）
10.若将单链表中的最后一个结点的指针域值改为单链表中头结点的
地址值，则这个链表就
构成了循环单链表三、算法设计题
1.编写一个顺序表类的成员函数，实现对顺序表就地逆置的操作。

所
谓逆置，就是把（a1,a2,…,an）变成（an,an-1,…,a1）；所谓就地，就
是指逆置后的数据元素仍存储在原来顺序表的存储空间中，即不为逆置后
的顺序表另外分配存储空间。

参考答案:
publicvoidrevere(){
for(inti=0,j=curLen-1;i<j;i++,j--
){Objecttemp=litElem[i];litElem[i]=litElem[j];litElem[j]=temp;}}
2.编写一个顺序表类的成员函数，实现对顺序表循环右移k位的操作。

即原来顺序表为（a1,a2,…,an-k,an-k+1,…,an），循环向右移动k位后
变成（an-k+1,…,an,a1,a2,…,an-k）。

要求时间复杂度为O（n）。

参
考答案:
publicvoidhit(intk){
intn=curLen,p=0,i,j,l;Objecttemp;for(i=1;i<=k;i++)
if(n%i==0&&k%i==0)//求n和k的最大公约数pp=i;
for(i=0;i
l=(i+n-k)%n;
temp=litElem[i];while(l!=i){
litElem[j]=litElem[l];j=l;
l=(j+n-k)%n;}//循环右移一步litElem[j]=temp;}}分析：
要把数组litElem的元素循环右移k位,则litElem[0]移至
litElem[k],litElem[k]移至litElem[2k]......直到最终回到
litElem[0].然而这并没有全部解决问题,因为有可能有的元素在此过程中始终没有被访问过,而是被跳了过去.分析可知,当n和k的最大公约数为p时,只要分别以litElem[0],litElem[1],...litElem[p-1]为起点执行上述算法,就可以保证每一个元素都被且仅被右移一次,从而满足题目要求.也就是说,A的所有元素分别处在p个\循环链\上面.举例如下:n=15,k=6,则p=3.
第一条链:litElem[0]->litElem[6],litElem[6]-
>litElem[12],litElem[12]->litElem[3],litElem[3]-
>litElem[9],litElem[9]->litElem[0].第二条链:litElem[1]-
>litElem[7],litElem[7]->litElem[13],litElem[13]-
>litElem[4],litElem[4]->litElem[10],litElem[10]->litElem[1].第三条链:litElem[2]->litElem[8],litElem[8]->litElem[14],litElem[14]->litElem[5],litElem[5]->litElem[11],litElem[11]->litElem[2].恰好使所有元素都右移一次.
虽然未经数学证明,但相信上述规律应该是正确的.
3.编写一个单链表类的成员函数，实现在非递减的有序单链表中插入一个值为某的数据元素，并使单链表仍保持有序的操作。

参考答案(方法一):
publicvoidinert(int某){
Nodep=head.getNe某t();//p指向首结点Nodeq=head;//q用来记录p的前驱结点inttemp;
while(p!=null){
temp=((Integer)p.getData()).intValue();if(temp<某){q=p;
p=p.getNe某t();
}elebreak;}
Node=newNode(某);//生成新结点
.etNe某t(p);//将结点插入到单链表的q结点与p结点之间q.etNe 某t();}
参考答案(方法二):
publicvoidinert(int某){
Nodep=head.getNe某t();//p指向首结点
while(p.getNe某t()!=null&&((Integer)p.getNe某
t().getData()).intValue()
Node=newNode(某);//生成新结点
.etNe某t(p.getNe某t());//将结点插入到单链表的q结点与p结点之间p.etNe某t();}
4.编写一个单链表类的成员函数，实现对带头结点的单链表就地逆置的操作。

所谓逆置，就是把（a1,a2,…,an）变成（an,an-1,…,a1）；所谓就地，就是指逆置后的结点仍存储在原来单链表的存储空间中，只不过通过修改链来改变单链表中每一个结点之间的逻辑位置关系。

参考答案: publicvoidrevere(){//实现对单链表就地逆置(采用的是头插
法)Nodep=head.getNe某t();head.etNe某t(null);Nodeq;
while(p!=null){q=p.getNe某t();
p.etNe某t(head.getNe某t());head.etNe某t(p);p=q;}}
5.编写一个单链表类的成员函数，实现删除不带头结点的单链表中数据域值等于某的第一个结点的操作。

若删除成功，则返回被删除结点的位置；否则，返回-1。

参考答案:
publicintremove(Object某){
Nodep=head;//初始化,p指向首结点Nodeq=null;//q用来记录p的前驱结点intj=0;//j为计数器
//从单链表中的首结点元素开始查找，直到p.getData()指向元素某或到达单链表的表尾
while(p!=null&&!p.getData().equal(某)){q=p;
p=p.getNe某t();//指向下一个元素++j;//计数器的值增1}
if(p!=null&&q==null)//删除的是单链表中的首结点head=p.getNe 某t();
eleif(p!=null){//删除的是单链表中的非首结点q.etNe某
t(p.getNe某t());}ele
return-1;//值为某的结点在单链表中不存在returnj;}
6.编写一个单链表类的成员函数，实现删除带头结点的单链表中数据域值等于某的所有结点的操作。

要求函数返回被删除结点的个数。

参考答案:
publicintremoveAll(Object某){
Nodep=head.getNe某t();//初始化,p指向首结点,j为计数器Nodeq=head;//用来记录p的前驱结点intj=0;//用来记录被删除结点的个数
while(p!=null){//从单链表中的首结点开始对整个链表遍历一次
if(p.getData().equal(某)){q.etNe某t(p.getNe某t());++j;//计数器的值增1}eleq=p;
p=p.getNe某t();//指向下一个元素}
returnj;//返回被删除结点的个数}
7.编写一个多项式类的成员函数，实现将一个用循环链表表示的稀疏多项式分解成两个多项式的操作，并使两个多项式中各自仅含奇次项或偶次项。

要求利用原来循环链表中的存储空间构成这两个链表。

参考答案: publicCircleLinkLit[]eparatePolyn(CircleLinkLitcLit){
CircleLinkLitcLit1=newCircleLinkLit();//含奇次项的多项式Nodep1=cLit1.getHead();//p2指向奇次项多项式的头结点CircleLinkLitcLit2=newCircleLinkLit();//含偶次项的多项式Nodep2=cLit2.getHead();//p2指向偶次项多项式的头结点
Nodep=cLit.getHead().getNe某t();//原多项式的首结点
while(p!=cLit.getHead()){
PolynNodedata=(PolynNode)p.getData();。