k删除线性表a中第i个元素起的k个元素.docx

k删除线性表a中第i个元素起的k个元素.docx

《k删除线性表a中第i个元素起的k个元素.docx》由会员分享，可在线阅读，更多相关《k删除线性表a中第i个元素起的k个元素.docx（21页珍藏版）》请在冰豆网上搜索。

k删除线性表a中第i个元素起的k个元素

　　　　　　　　　第二章线性表

2.10

StatusDeleteK（SqList&a,inti,intk）//删除线性表a中第i个元素起的k个元素

{

if（i<1||k<0||i+k-1>a.length）returnINFEASIBLE;

for（count=1;i+count-1<=a.length-k;count++）//注意循环结束的条件

a.elem[i+count-1]=a.elem[i+count+k-1];

a.length-=k;

returnOK;

}//DeleteK

2.11

voidInsertOrderList（SqList&L,ElemTypex）

{

inti=0,j;

while（i=L.elem[i]）i++;

for（j=L.length;j>i;j--）

L.elem[j]=L.elem[j-1];

L.elem[i]=x;

L.length++;

}

2.12

intListComp（SqListA,SqListB）//比较字符表A和B,并用返回值表示结果,值为1,表示A>B;值为-1,表示A

{

for（i=1;i<=A.length&&i<=B.length;i++）

if（A.elem[i]!

=B.elem[i]）

returnA.elem[i]>B.elem[i]?

1:

-1;

if（A.length==B.length）return0;

returnA.length>B.length?

1:

-1;//当两个字符表可以互相比较的部分完全相同时,哪个较长,哪个就较大

}//ListComp

2.13

LNode*Locate（LinkListL,intx）//链表上的元素查找,返回指针

{

for（p=l->next;p&&p->data!

=x;p=p->next）;

returnp;

}//Locate

2.14

intLength（LinkListL）//求链表的长度

{

for（k=0,p=L;p->next;p=p->next,k++）;

returnk;

}//Length

2.15

voidListConcat（LinkListha,LinkListhb,LinkList&hc）//把链表hb接在ha后面形成链表hc

{

hc=ha;p=ha;

while（p->next）p=p->next;

p->next=hb;

}//ListConcat

2.16

见书后答案.

2.17

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

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

StatusDelete_Between（Linklist&L,intmink,intmaxk）//删除元素递增排列的链表L中值大于mink且小于maxk的所有元素

{

p=L;

while（p->next->data<=mink）p=p->next;//p是最后一个不大于mink的元素

if（p->next）//如果还有比mink更大的元素

{

q=p->next;

while（q->datanext;//q是第一个不小于maxk的元素

p->next=q;

}

}//Delete_Between

2.20

StatusDelete_Equal（Linklist&L）//删除元素递增排列的链表L中所有值相同的元素

{

p=L->next;q=p->next;//p,q指向相邻两元素

while（p->next）

{

if（p->data!

=q->data）

{

p=p->next;q=p->next;//当相邻两元素不相等时,p,q都向后推一步

}

else

{

while（q->data==p->data）

{

free（q）;

q=q->next;

}

p->next=q;p=q;q=p->next;//当相邻元素相等时删除多余元素

}//else

}//while

}//Delete_Equal

2.21

voidreverse（SqList&A）//顺序表的就地逆置

{

for（i=1,j=A.length;i

A.elem[i]<->A.elem[j];

}//reverse

2.22

voidLinkList_reverse（Linklist&L）//链表的就地逆置;为简化算法,假设表长大于2

{

p=L->next;q=p->next;s=q->next;p->next=NULL;

while（s->next）

{

q->next=p;p=q;

q=s;s=s->next;//把L的元素逐个插入新表表头

}

q->next=p;s->next=q;L->next=s;

}//LinkList_reverse

分析:

本算法的思想是,逐个地把L的当前元素q插入新的链表头部,p为新表表头.

2.23

voidmerge1（LinkList&A,LinkList&B,LinkList&C）//把链表A和B合并为C,A和B的元素间隔排列,且使用原存储空间

{

p=A->next;q=B->next;C=A;

while（p&&q）

{

s=p->next;p->next=q;//将B的元素插入

if（s）

{

t=q->next;q->next=s;//如A非空,将A的元素插入

}

p=s;q=t;

}//while

}//merge1

2.24

voidreverse_merge（LinkList&A,LinkList&B,LinkList&C）//把元素递增排列的链表A和B合并为C,且C中元素递减排列,使用原空间

{

pa=A->next;pb=B->next;pre=NULL;//pa和pb分别指向A,B的当前元素

while（pa||pb）

{

if（pa->datadata||!

pb）

{

pc=pa;q=pa->next;pa->next=pre;pa=q;//将A的元素插入新表

}

else

{

pc=pb;q=pb->next;pb->next=pre;pb=q;//将B的元素插入新表

}

pre=pc;

}

C=A;A->next=pc;//构造新表头

}//reverse_merge

分析:

本算法的思想是,按从小到大的顺序依次把A和B的元素插入新表的头部pc处,最后处理A或B的剩余元素.

2.25

voidSqList_Intersect（SqListA,SqListB,SqList&C）//求元素递增排列的线性表A和B的元素的交集并存入C中

{

i=1;j=1;k=0;

while（A.elem[i]&&B.elem[j]）

{

if（A.elem[i]

if（A.elem[i]>B.elem[j]）j++;

if（A.elem[i]==B.elem[j]）

{

C.elem[++k]=A.elem[i];//当发现了一个在A,B中都存在的元素,

i++;j++;//就添加到C中

}

}//while

}//SqList_Intersect

2.26

voidLinkList_Intersect（LinkListA,LinkListB,LinkList&C）//在链表结构上重做上题

{

p=A->next;q=B->next;

pc=（LNode*）malloc（sizeof（LNode））;

C=pc;

while（p&&q）

{

if（p->datadata）p=p->next;

elseif（p->data>q->data）q=q->next;

else

{

s=（LNode*）malloc（sizeof（LNode））;

s->data=p->data;

pc->next=s;pc=s;

p=p->next;q=q->next;

}

}//while

}//LinkList_Intersect

2.27

voidSqList_Intersect_True（SqList&A,SqListB）//求元素递增排列的线性表A和B的元素的交集并存回A中

{

i=1;j=1;k=0;

while（A.elem[i]&&B.elem[j]）

{

if（A.elem[i]

elseif（A.elem[i]>B.elem[j]）j++;

elseif（A.elem[i]!

=A.elem[k]）

{

A.elem[++k]=A.elem[i];//当发现了一个在A,B中都存在的元素

i++;j++;//且C中没有,就添加到C中

}

else{i++;j++;}

}//while

while（A.elem[k]）A.elem[k++]=0;

}//SqList_Intersect_True

2.28

voidLinkList_Intersect_True（LinkList&A,LinkListB）//在链表结构上重做上题

{

p=A->next;q=B->next;pc=A;

while（p&&q）

{

if（p->datadata）p=p->next;

elseif（p->data>q->data）q=q->next;

elseif（p->data!

=pc->data）

{

pc=pc->next;

pc->data=p->data;

p=p->next;q=q->next;

}

}//while

}//LinkList_Intersect_True

2.29

voidSqList_Intersect_Delete（SqList&A,SqListB,SqListC）

{

i=0;j=0;k=0;m=0;//i指示A中元素原来的位置,m为移动后的位置

while（i

{

if（B.elem[j]

elseif（B.elem[j]>C.elem[k]）k++;

else

{

same=B.elem[j];//找到了相同元素same

while（B.elem[j]==same）j++;

while（C.elem[k]==same）k++;//j,k后移到新的元素

while（i

A.elem[m++]=A.elem[i++];//需保留的元素移动到新位置

while（i

}

}//while

while（i

A.elem[m++]=A.elem[i++];//A的剩余元素重新存储。

A.length=m;

}//SqList_Intersect_Delete

分析:

先从B和C中找出共有元素,记为same,再在A中从当前位置开始,凡小于same的

元素均保留（存到新的位置）,等于same的就跳过,到大于same时就再找下一个same.

2.30

voidLinkList_Intersect_Delete（LinkList&A,LinkListB,LinkListC）//在链表结构上重做上题

{

p=B->next;q=C->next;r=A-next;

while（p&&q&&r）

{

if（p->datadata）p=p->next;

elseif（p->data>q->data）q=q->next;

else

{

u=p->data;//确定待删除元素u

while（r->next->datanext;//确定最后一个小于u的元素指针r

if（r->next->data==u）

{

s=r->next;

while（s->data==u）

{

t=s;s=s->next;free（t）;//确定第一个大于u的元素指针s

}//while

r->next=s;//删除r和s之间的元素

}//if

while（p->data=u）p=p->next;

while（q->data=u）q=q->next;

}//else

}//while

}//LinkList_Intersect_Delete

2.31

StatusDelete_Pre（CiLNode*s）//删除单循环链表中结点s的直接前驱

{

p=s;

while（p->next->next!

=s）p=p->next;//找到s的前驱的前驱p

p->next=s;

returnOK;

}//Delete_Pre

2.32

StatusDuLNode_Pre（DuLinkList&L）//完成双向循环链表结点的pre域

{

for（p=L;!

p->next->pre;p=p->next）p->next->pre=p;

returnOK;

}//DuLNode_Pre

2.33

StatusLinkList_Divide（LinkList&L,CiList&A,CiList&B,CiList&C）//把单链表L的元素按类型分为三个循环链表.CiList为带头结点的单循环链表类型.

{

s=L->next;

A=（CiList*）malloc（sizeof（CiLNode））;p=A;

B=（CiList*）malloc（sizeof（CiLNode））;q=B;

C=（CiList*）malloc（sizeof（CiLNode））;r=C;//建立头结点

while（s）

{

if（isalphabet（s->data））

{

p->next=s;p=s;

}

elseif（isdigit（s->data））

{

q->next=s;q=s;

}

else

{

r->next=s;r=s;

}

}//while

p->next=A;q->next=B;r->next=C;//完成循环链表

}//LinkList_Divide

2.34

voidPrint_XorLinkedList（XorLinkedListL）//从左向右输出异或链表的元素值

{

p=L.left;pre=NULL;

while（p）

{

printf（"%d",p->data）;

q=XorP（p->LRPtr,pre）;

pre=p;p=q;//任何一个结点的LRPtr域值与其左结点指针进行异或运算即得到其右结点指针

}

}//Print_XorLinkedList

2.35

StatusInsert_XorLinkedList（XorLinkedList&L,intx,inti）//在异或链表L的第i个元素前插入元素x

{

p=L.left;pre=NULL;

r=（XorNode*）malloc（sizeof（XorNode））;

r->data=x;

if（i==1）//当插入点在最左边的情况

{

p->LRPtr=XorP（p.LRPtr,r）;

r->LRPtr=p;

L.left=r;

returnOK;

}

j=1;q=p->LRPtr;//当插入点在中间的情况

while（++j

{

q=XorP（p->LRPtr,pre）;

pre=p;p=q;

}//while//在p,q两结点之间插入

if（!

q）returnINFEASIBLE;//i不可以超过表长

p->LRPtr=XorP（XorP（p->LRPtr,q）,r）;

q->LRPtr=XorP（XorP（q->LRPtr,p）,r）;

r->LRPtr=XorP（p,q）;//修改指针

returnOK;

}//Insert_XorLinkedList

2.36

StatusDelete_XorLinkedList（XorlinkedList&L,inti）//删除异或链表L的第i个元素

{

p=L.left;pre=NULL;

if（i==1）//删除最左结点的情况

{

q=p->LRPtr;

q->LRPtr=XorP（q->LRPtr,p）;

L.left=q;free（p）;

returnOK;

}

j=1;q=p->LRPtr;

while（++j

{

q=XorP（p->LRPtr,pre）;

pre=p;p=q;

}//while//找到待删结点q

if（!

q）returnINFEASIBLE;//i不可以超过表长

if（L.right==q）//q为最右结点的情况

{

p->LRPtr=XorP（p->LRPtr,q）;

L.right=p;free（q）;

returnOK;

}

r=XorP（q->LRPtr,p）;//q为中间结点的情况,此时p,r分别为其左右结点

p->LRPtr=XorP（XorP（p->LRPtr,q）,r）;

r->LRPtr=XorP（XorP（r->LRPtr,q）,p）;//修改指针

free（q）;

returnOK;

}//Delete_XorLinkedList

2.37

voidOEReform（DuLinkedList&L）//按1,3,5,...4,2的顺序重排双向循环链表L中的所有结点

{

p=L.next;

while（p->next!

=L&&p->next->next!

=L）

{

p->next=p->next->next;

p=p->next;

}//此时p指向最后一个奇数结点

if（p->next==L）p->next=L->pre->pre;

elsep->next=l->pre;

p=p->next;//此时p指向最后一个偶数结点

while（p->pre->pre!

=L）

{

p->next=p->pre->pre;

p=p->next;

}

p->next=L;//按题目要求调整了next链的结构,此时pre链仍为原状

for（p=L;p->next!

=L;p=p->next）p->next->pre=p;

L->pre=p;//调整pre链的结构,同2.32方法

}//OEReform

分析:

next链和pre链的调整只能分开进行.如同时进行调整的话,必须使用堆栈保存偶数结点的指针,否则将会破坏链表结构,造成结点丢失.

2.38

DuLNode*Locate_DuList（DuLinkedList&L,intx）//带freq域的双向循环链表上的查找

{

p=L.next;

while（p.data!

=x&&p!

=L）p=p->next;

if（p==L）returnNULL;//没找到

p->freq++;q=p->pre;

while（q->freq<=p->freq&&p!

=L）q=q->pre;//查找插入位置

if（q!

=p->pre）

{

p->pre->next=p->next;p->next->pre=p->pre;

q->next->pre=p;p->next=q->next;

q->next=p;p->pre=q;//调整位置

}

returnp;

}//Locate_DuList

2.39

floatGetValue_SqPoly（SqPolyP,intx0）//求升幂顺序存储的稀疏多项式的值

{

PolyTerm*q;

xp=1;q=P.data;

sum=0;ex=0;

while（q->coef）

{

while（exexp）xp*=x0;

sum+=q->coef*xp;

q++;

}

returnsum;

}//GetValue_SqPoly

2.40

voidSubtract_SqPoly（SqPolyP1,SqPolyP2,SqPoly&P3）//求稀疏多项式P1减P2的差式P3

{

PolyTerm*p,*q,*r;

Create_SqPoly（P3）;//建立空多项式P3

p=P1.data;q=P2.data;r=P3.data;

while（p->coef&&q->coef）

{

if（p->expexp）

{

r->coef=p->coef;

r->exp=p->exp;

p++;r++;

}

elseif（p->expexp）

{

r->coef=-q->coef;

r->exp=q->exp;

q++;r++;

}

else

{

if（（p->coef-q->coef）!

=0）//只有同次项相减不为零时才需要存入P3中

{

r->coef=p->coef-q->coef;

r->exp=p->exp;r++;

}//if

p++;q++;

}//else

}//while