数据结构线性表答案.doc
《数据结构线性表答案.doc》由会员分享，可在线阅读，更多相关《数据结构线性表答案.doc（30页珍藏版）》请在冰点文库上搜索。
第一章线性表
2.1描述以下三个概念的区别：
头指针，头结点，首元结点（第一个元素结点）。
解：
头指针是指向链表中第一个结点的指针。
首元结点是指链表中存储第一个数据元素的结点。
头结点是在首元结点之前附设的一个结点，该结点不存储数据元素，其指针域指向首元结点，其作用主要是为了方便对链表的操作。
它可以对空表、非空表以及首元结点的操作进行统一处理。
2.2填空题。
解：
（1）在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与元素在表中的位置有关。
（2）顺序表中逻辑上相邻的元素的物理位置必定紧邻。
单链表中逻辑上相邻的元素的物理位置不一定紧邻。
（3）在单链表中，除了首元结点外，任一结点的存储位置由其前驱结点的链域的值指示。
（4）在单链表中设置头结点的作用是插入和删除首元结点时不用进行特殊处理。
2.3在什么情况下用顺序表比链表好？
解：
当线性表的数据元素在物理位置上是连续存储的时候，用顺序表比用链表好，其特点是可以进行随机存取。
2.4对以下单链表分别执行下列各程序段，并画出结果示意图。
解：
2.5画出执行下列各行语句后各指针及链表的示意图。
L=（LinkList）malloc（sizeof（LNode））;P=L;
for（i=1;i<=4;i++）{
P->next=（LinkList）malloc（sizeof（LNode））;
P=P->next;P->data=i*2-1;
}
P->next=NULL;
for（i=4;i>=1;i--）Ins_LinkList（L,i+1,i*2）;
for（i=1;i<=3;i++）Del_LinkList（L,i）;
解：
2.6已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。
a.在P结点后插入S结点的语句序列是__________________。
b.在P结点前插入S结点的语句序列是__________________。
c.在表首插入S结点的语句序列是__________________。
d.在表尾插入S结点的语句序列是__________________。
（1）P->next=S;
（2）P->next=P->next->next;
（3）P->next=S->next;
（4）S->next=P->next;
（5）S->next=L;
（6）S->next=NULL;
（7）Q=P;
（8）while（P->next!
=Q）P=P->next;
（9）while（P->next!
=NULL）P=P->next;
（10）P=Q;
（11）P=L;
（12）L=S;
（13）L=P;
解：
a.（4）
（1）
b.（7）（11）（8）（4）
（1）
c.（5）（12）
d.（9）
（1）（6）
2.7已知L是带表头结点的非空单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。
a.删除P结点的直接后继结点的语句序列是____________________。
b.删除P结点的直接前驱结点的语句序列是____________________。
c.删除P结点的语句序列是____________________。
d.删除首元结点的语句序列是____________________。
e.删除尾元结点的语句序列是____________________。
（1）P=P->next;
（2）P->next=P;
（3）P->next=P->next->next;
（4）P=P->next->next;
（5）while（P!
=NULL）P=P->next;
（6）while（Q->next!
=NULL）{P=Q;Q=Q->next;}
（7）while（P->next!
=Q）P=P->next;
（8）while（P->next->next!
=Q）P=P->next;
（9）while（P->next->next!
=NULL）P=P->next;
（10）Q=P;
（11）Q=P->next;
（12）P=L;
（13）L=L->next;
（14）free（Q）;
解：
a.（11）（3）（14）
b.（10）（12）（8）（3）（14）
c.（10）（12）（7）（3）（14）
d.（12）（11）（3）（14）
e.（9）（11）（3）（14）
2.8已知P结点是某双向链表的中间结点，试从下列提供的答案中选择合适的语句序列。
a.在P结点后插入S结点的语句序列是_______________________。
b.在P结点前插入S结点的语句序列是_______________________。
c.删除P结点的直接后继结点的语句序列是_______________________。
d.删除P结点的直接前驱结点的语句序列是_______________________。
e.删除P结点的语句序列是_______________________。
（1）P->next=P->next->next;
（2）P->priou=P->priou->priou;
（3）P->next=S;
（4）P->priou=S;
（5）S->next=P;
（6）S->priou=P;
（7）S->next=P->next;
（8）S->priou=P->priou;
（9）P->priou->next=P->next;
（10）P->priou->next=P;
（11）P->next->priou=P;
（12）P->next->priou=S;
（13）P->priou->next=S;
（14）P->next->priou=P->priou;
（15）Q=P->next;
（16）Q=P->priou;
（17）free（P）;
（18）free（Q）;
解：
a.（7）（3）（6）（12）
b.（8）（4）（5）（13）
c.（15）
（1）（11）（18）
d.（16）
（2）（10）（18）
e.（14）（9）（17）
2.9简述以下算法的功能。
（1）StatusA（LinkedListL）{//L是无表头结点的单链表
if（L&&L->next）{
Q=L;L=L->next;P=L;
while（P->next）P=P->next;
P->next=Q;Q->next=NULL;
}
returnOK;
}
（2）voidBB（LNode*s,LNode*q）{
p=s;
while（p->next!
=q）p=p->next;
p->next=s;
}
voidAA（LNode*pa,LNode*pb）{
//pa和pb分别指向单循环链表中的两个结点
BB（pa,pb）;
BB（pb,pa）;
}
解：
（1）如果L的长度不小于2，将L的首元结点变成尾元结点。
（2）将单循环链表拆成两个单循环链表。
2.10指出以下算法中的错误和低效之处，并将它改写为一个既正确又高效的算法。
StatusDeleteK（SqList&a,inti,intk）
{
//本过程从顺序存储结构的线性表a中删除第i个元素起的k个元素
if（i<1||k<0||i+k>a.length）returnINFEASIBLE;//参数不合法
else{
for（count=1;count//删除第一个元素
for（j=a.length;j>=i+1;j--）a.elem[j-i]=a.elem[j];
a.length--;
}
returnOK;
}
解：
StatusDeleteK（SqList&a,inti,intk）
{
//从顺序存储结构的线性表a中删除第i个元素起的k个元素
//注意i的编号从0开始
intj;
if（i<0||i>a.length-1||k<0||k>a.length-i）returnINFEASIBLE;
for（j=0;j<=k;j++）
a.elem[j+i]=a.elem[j+i+k];
a.length=a.length-k;
returnOK;
}
2.11设顺序表va中的数据元素递增有序。
试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性。
解：
StatusInsertOrderList（SqList&va,ElemTypex）
{
//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法
inti;
if（va.length==va.listsize）return（OVERFLOW）;
for（i=va.length;i>0,xva.elem[i]=va.elem[i-1];
va.elem[i]=x;
va.length++;
returnOK;
}
2.12设和均为顺序表，和分别为和中除去最大共同前缀后的子表。
若空表，则；若=空表，而空表，或者两者均不为空表，且的首元小于的首元，则；否则。
试写一个比较，大小的算法。
解：
StatusCompareOrderList（SqList&A,SqList&B）
{
inti,k,j;
k=A.length>B.length?
A.length:
B.length;
for（i=0;iif（A.elem[i]>B.elem[i]）j=1;
if（A.elem[i]}
if（A.length>k）j=1;
if（B.length>k）j=-1;
if（A.length==B.length）j=0;
returnj;
}
2.13试写一算法在带头结点的单链表结构上实现线性表操作Locate（L,x）;
解：
intLocateElem_L（LinkList&L,ElemTypex）
{
inti=0;
LinkListp=L;
while（p&&p->data!
=x）{
p=p->next;
i++;
}
if（!
p）return0;
elsereturni;
}
2.14试写一算法在带头结点的单链表结构上实现线性表操作Length（L）。
解：
//返回单链表的长度
intListLength_L（LinkList&L）
{
inti=0;
LinkListp=L;
if（p）p=p-next;
while（p）{
p=p->next;
i++;
}
returni;
}
2.15已知指针ha和hb分别指向两个单链表的头结点，并且已知两个链表的长度分别为m和n。
试写一算法将这两个链表连接在一起，假设指针hc指向连接后的链表的头结点，并要求算法以尽可能短的时间完成连接运算。
请分析你的算法的时间复杂度。
解：
voidMergeList_L（LinkList&ha,LinkList&hb,LinkList&hc）
{
LinkListpa,pb;
pa=ha;
pb=hb;
while（pa->next&&pb->next）{
pa=pa->next;
pb=pb->next;
}
if（!
pa->next）{
hc=hb;
while（pb->next）pb=pb->next;
pb->next=ha->next;
}
else{
hc=ha;
while（pa->next）pa=pa->next;
pa->next=hb->next;
}
}
2.16已知指针la和lb分别指向两个无头结点单链表中的首元结点。
下列算法是从表la中删除自第i个元素起共len个元素后，将它们插入到表lb中第i个元素之前。
试问此算法是否正确？
若有错，请改正之。
StatusDeleteAndInsertSub（LinkedListla,LinkedListlb,inti,intj,intlen）
{
if（i<0||j<0||len<0）returnINFEASIBLE;
p=la;k=1;
while（knext;k++;}
q=p;
while（k<=len）{q=q->next;k++;}
s=lb;k=1;
while（knext;k++;}
s->next=p;q->next=s->next;
returnOK;
}
解：
StatusDeleteAndInsertSub（LinkList&la,LinkList&lb,inti,intj,intlen）
{
LinkListp,q,s,prev=NULL;
intk=1;
if（i<0||j<0||len<0）returnINFEASIBLE;
//在la表中查找第i个结点
p=la;
while（p&&kprev=p;
p=p->next;
k++;
}
if（!
p）returnINFEASIBLE;
//在la表中查找第i+len-1个结点
q=p;k=1;
while（q&&kq=p->next;
k++;
}
if（!
q）returnINFEASIBLE;
//完成删除，注意，i=1的情况需要特殊处理
if（!
prev）la=q->next;
elseprev->next=q->next;
//将从la中删除的结点插入到lb中
if（j=1）{
q->next=lb;
lb=p;
}
else{
s=lb;k=1;
while（s&&ks=s->next;
k++;
}
if（!
s）returnINFEASIBLE;
q->next=s->next;
s->next=p;//完成插入
}
returnOK;
}
2.17试写一算法，在无头结点的动态单链表上实现线性表操作Insert（L,i,b），并和在带头结点的动态单链表上实现相同操作的算法进行比较。
解：
StatusInsert（LinkList&L,inti,intb）//在无头结点链表L的第i个元素之前插入元素b
{
p=L;q=（LinkList*）malloc（sizeof（LNode））;
q.data=b;
if（i==1）
q.next=p;L=q;//插入在链表头部
else
{
while（--i>1）
p=p->next;
q->next=p->next;
p->next=q;//插入在第i个元素的位置
}
}//Insert
2.18试写一算法，实现线性表操作Delete（L,i），并和在带头结点的动态单链表上实现相同操作的算法进行比较。
解：
StatusDelete（LinkList&L,inti）//在无头结点链表L中删除第i个元素
{
if（i==1）
L=L->next;//删除第一个元素
else
{
p=L;
while（--i>1）
p=p->next;
p->next=p->next->next;//删除第i个元素
}
}//Delete
2.19已知线性表中的元素以值递增有序排列，并以单链表作存储结构。
试写一高效的算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素），同时释放被删结点空间，并分析你的算法的时间复杂度（注意，mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。
解：
StatusListDelete_L（LinkList&L,ElemTypemink,ElemTypemaxk）
{
LinkListp,q,prev=NULL;
if（mink>maxk）returnERROR;
p=L;
prev=p;
p=p->next;
while（p&&p->dataif（p->data<=mink）{
prev=p;
p=p->next;
}
else{
prev->next=p->next;
q=p;
p=p->next;
free（q）;
}
}
returnOK;
}
2.20同2.19题条件，试写一高效的算法，删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同），同时释放被删结点空间，并分析你的算法的时间复杂度。
解：
voidListDelete_LSameNode（LinkList&L）
{
LinkListp,q,prev;
p=L;
prev=p;
p=p->next;
while（p）{
prev=p;
p=p->next;
if（p&&p->data==prev->data）{
prev->next=p->next;
q=p;
p=p->next;
free（q）;
}
}
}
2.21试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表逆置为。
解：
//顺序表的逆置
StatusListOppose_Sq（SqList&L）
{
inti;
ElemTypex;
for（i=0;ix=L.elem[i];
L.elem[i]=L.elem[L.length-1-i];
L.elem[L.length-1-i]=x;
}
returnOK;
}
2.22试写一算法，对单链表实现就地逆置。
解：
//带头结点的单链表的逆置
StatusListOppose_L（LinkList&L）
{
LinkListp,q;
p=L;
p=p->next;
L->next=NULL;
while（p）{
q=p;
p=p->next;
q->next=L->next;
L->next=q;
}
returnOK;
}
2.23设线性表，，试写一个按下列规则合并A，B为线性表C的算法，即使得
当时；
当时。
线性表A，B和C均以单链表作存储结构，且C表利用A表和B表中的结点空间构成。
注意：
单链表的长度值m和n均未显式存储。
解：
//将合并后的结果放在C表中，并删除B表
StatusListMerge_L（LinkList&A,LinkList&B,LinkList&C）
{
LinkListpa,pb,qa,qb;
pa=A->next;
pb=B->next;
C=A;
while（pa&&pb）{
qa=pa;qb=pb;
pa=pa->next;pb=pb->next;
qb->next=qa->next;
qa->next=qb;
}
if（!
pa）qb->next=pb;
pb=B;
free（pb）;
returnOK;
}
2.24假设有两个按元素值递增有序排列的线性表A和B，均以单链表作存储结构，请编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许表中含有值相同的元素）排列的线性表C，并要求利用原表（即A表和B表）的结点空间构造C表。
解：
//将合并逆置后的结果放在C表
升级会员 