Anyview第四章15年数据结构.docx
《Anyview第四章15年数据结构.docx》由会员分享，可在线阅读，更多相关《Anyview第四章15年数据结构.docx（17页珍藏版）》请在冰豆网上搜索。
Anyview第四章15年数据结构
DS03-PE22
/**********
【题目】试写一算法，借助辅助栈，复制顺序栈S1得到S2。
顺序栈的类型定义为：
typedefstruct{
ElemType*elem;//存储空间的基址
inttop;//栈顶元素的下一个位置，简称栈顶位标
intsize;//当前分配的存储容量
intincrement;//扩容时，增加的存储容量
}SqStack;//顺序栈
可调用顺序栈接口中下列函数：
StatusInitStack_Sq（SqStack&S,intsize,intinc）;//初始化顺序栈S
StatusDestroyStack_Sq（SqStack&S）;//销毁顺序栈S
StatusStackEmpty_Sq（SqStackS）;//栈S判空，若空则返回TRUE，否则FALSE
StatusPush_Sq（SqStack&S,ElemTypee）;//将元素e压入栈S
StatusPop_Sq（SqStack&S,ElemType&e）;//栈S的栈顶元素出栈到e
***********/
StatusCopyStack_Sq（SqStackS1,SqStack&S2）
/*借助辅助栈，复制顺序栈S1得到S2。
*/
/*若复制成功，则返回TRUE；否则FALSE。
*/
{
//if（TRUE==StackEmpty_Sq（S1））returnFALSE;//当S1是空的时候
SqStackS3;
if（ERROR==InitStack_Sq（S2,S1.size,S1.increment））returnFALSE;
if（ERROR==InitStack_Sq（S3,S1.size,S1.increment））returnFALSE;//对S1、S2的初始化
if（!
StackEmpty_Sq（S2））returnFALSE;
if（!
StackEmpty_Sq（S3））returnFALSE;//对S1、S2的判空
ElemTypee;
while（S1.top）
{
Pop_Sq（S1,e）;
Push_Sq（S3,e）;
}
while（S3.top）
{
Pop_Sq（S3,e）;
Push_Sq（S2,e）;
}
//DestroyStack_Sq（S1）;
//DestroyStack_Sq（S3）;
returnTRUE;
}
DS03-PE37
/**********
【题目】假设将循环队列定义为：
以域变量rear
和length分别指示循环队列中队尾元素的位置和内
含元素的个数。
试给出此循环队列的队满条件，并
写出相应的入队列和出队列的算法（在出队列的算
法中要返回队头元素）。
本题的循环队列CLenQueue的类型定义如下：
typedefstruct{
ElemTypeelem[MAXQSIZE];
intlength;
intrear;
}CLenQueue;
**********/
StatusEnCQueue（CLenQueue&Q,ElemTypex）
/*将元素x加入队列Q，并返回OK；*/
/*若失败，则返回ERROR。
*/
{
if（MAXQSIZE<=Q.length）returnERROR;//队满，无法插入
Q.rear=（Q.rear+1）%MAXQSIZE;
Q.elem[Q.rear]=x;
Q.length+=1;
returnOK;
}
StatusDeCQueue（CLenQueue&Q,ElemType&x）
/*将队列Q的队头元素退队到x，并返回OK；*/
/*若失败，则返回ERROR。
*/
{
if（0==Q.length）returnERROR;
x=Q.elem[（（Q.rear+MAXQSIZE-Q.length+1）%MAXQSIZE）];
Q.length-=1;
returnOK;
}
DS03-PE44
/**********
【题目】已知k阶斐波那契序列的定义为:
f0=0,f1=0,…,fk-2=0,fk-1=1;
fn=fn-1+fn-2+…+fn-k,n=k,k+1,…
试利用循环队列编写求k阶斐波那契序列中第
项fn+1n的算法。
本题的循环队列的类型定义如下：
typedefstruct{
ElemType*base;//存储空间的基址
intfront;//队头位标
intrear;//队尾位标，指示队尾元素的下一位置
intmaxSize;//最大长度
}SqQueue;
**********/
longAddSum（intn,ElemType*q）
{
longsum=0;
inti;
for（i=0;isum+=q[i];
returnsum;
}
longFib（intk,intn）
/*求k阶斐波那契序列的第n+1项fn*/
{
if（k<2||n<-1）returnERROR;
if（nif（n+1==k）return1;
SqQueueQ;
inta,i;
Q.base=（ElemType*）malloc（k*sizeof（ElemType））;
if（NULL==Q.base）returnERROR;
Q.maxSize=k;
for（i=0;i{
Q.base[i]=0;
}
//初始化序列
Q.base[k-1]=1;
Q.front=0;
Q.rear=k-1;
a=k;
while（a<=n）
{
Q.rear=（Q.rear+1）%k;
Q.base[Q.rear]=AddSum（k,Q.base）;
a++;
}
returnQ.base[Q.rear];
}
DS03-PE81
/**********
【题目】试对一元稀疏多项式Pn（x）采用存储量同多项式
项数m成正比的顺序存储结构，编写求Pn（x0）的算法（x0
为给定值）。
一元稀疏多项式的顺序存储结构:
typedefstruct{
intcoef;//系数
intexp;//指数
}Term;
typedefstruct{
Term*elem;//存储空间基址
intlength;//长度（项数）
}Poly;
**********/
floatFunction（Term*p,floatx）
{
inta;
floatsum=1;
if（0==p->exp）returnsum;
for（a=0;aexp;a++）
sum*=x;
returnsum;
}
floatEvaluate（PolyP,floatx）
/*P.elem[i].coef存放ai，*/
/*P.elem[i].exp存放ei（i=1,2,...,m）*/
/*本算法计算并返回多项式的值。
不判别溢出。
*/
/*入口时要求0≤e1{
floatsum=0;
Term*p;
p=P.elem;
if（0==P.length）returnsum;
while（P.length--）
{
sum+=p->coef*Function（p,x）;
p++;
}
returnsum;
}
DS03-PE85
/**********
【题目】假设有两个集合A和B分别用两个线性表LA和LB
表示（即：
线性表中的数据元素即为集合中的成员），
试写一算法，求并集A＝A∪B。
1、在每个元素遍历的时候，排除相同的元素
2、插入
顺序表类型定义如下
typedefstruct{
ElemType*elem;//存储空间的基址
intlength;//当前长度
intsize;//存储容量
intincrement;//空间不够增加空间大小
}SqList;//顺序表
可调用顺序表的以下接口函数：
StatusInitList_Sq（SqList&L,intsize,intinc）;//初始化顺序表L
intListLength_Sq（SqListL）;//返回顺序表L中元素个数
StatusGetElem_Sq（SqListL,inti,ElemType&e）;
//用e返回顺序表L中第i个元素的值
intSearch_Sq（SqListL,ElemTypee）;
//在顺序表L顺序查找元素e，成功时返回该元素在表中第一次出现的位置，否则返回-1
StatusAppend_Sq（SqList&L,ElemTypee）;//在顺序表L表尾添加元素e
**********/
voidAppend_Sq1（SqListL,ElemTypee）
{
L.elem[L.length]=e;
}
voidUnion（SqList&La,SqListLb）
{
ElemTypee;
inta=ListLength_Sq（Lb）;
intb=ListLength_Sq（La）;
ElemType*p;
p=（ElemType*）realloc（La.elem,（a+b）*sizeof（ElemType））;
La.elem=p;
La.length=b;
La.size=a+b;
inti=1;
while（i<=a）
{
GetElem_Sq（Lb,i,e）;
if（-1==Search_Sq（La,e））
{
Append_Sq1（La,e）;
La.length++;
}
i++;
}
}
DS04-PE38
/**********
【题目】假设以带头结点的循环链表表示队列，并且
只设一个指针指向队尾元素结点（注意不设头指针），
试编写相应的队列初始化、入队列和出队列的算法。
带头结点循环链队列CLQueue的类型定义为：
typedefstructLQNode{
ElemTypedata;
structLQNode*next;
}LQNode,*CLQueue;
**********/
StatusInitCLQueue（CLQueue&rear）//初始化空队列
{
rear=（CLQueue）malloc（sizeof（LQNode））;
if（NULL==rear）returnERROR;
rear->next=rear;
returnOK;
}
StatusEnCLQueue（CLQueue&rear,ElemTypex）//入队
{
LQNode*p;
p=（LQNode*）malloc（sizeof（LQNode））;
if（NULL==p）returnERROR;
p->data=x;
p->next=rear->next;
rear->next=p;
rear=p;
returnOK;
}
StatusDeCLQueue（CLQueue&rear,ElemType&x）//出队
{
if（rear->next==rear）
returnERROR;
CLQueuep;
p=rear->next->next;
x=p->data;
if（p==rear）
{
rear=rear->next;
rear->next=p;
}
else
{
rear->next->next=p->next;
}
returnOK;
}
DS04-PE62
/**********
【题目】试写一算法，在带头结点单链表L插入第i元素e。
带头结点单链表的类型定义为：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
**********/
intLengthLinkList（LinkListL）
{
LinkListp=L;
intlength=0;
while（p->next）
{
length++;
p=p->next;
}
returnlength;
}
StatusInsert_L（LinkListL,inti,ElemTypee）
/*在带头结点单链表L插入第i元素e，并返回OK。
*/
/*若参数不合理，则返回ERROR。
*/
{
if（NULL==L）returnERROR;
intlength=LengthLinkList（L）;
if（i>length+1||i==0）returnERROR;
LinkListp=L;
LinkListq;
q=（LNode*）malloc（sizeof（LNode））;
if（NULL==q）returnERROR;
inta=0;
q->data=e;
if（i==length+1）
{
while（a++p=p->next;
p->next=q;
}
else
{
while（a++p=p->next;
q->next=p->next;
p->next=q;
}
returnOK;
}
DS04-PE64
/**********
【题目】试写一算法，在带头结点单链表删除第i元素到e。
带头结点单链表的类型定义为：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
**********/
intLengthLinkList（LinkListL）
{
LinkListp=L;
intlength=0;
while（p->next）
{
length++;
p=p->next;
}
returnlength;
}
StatusDelete_L（LinkListL,inti,ElemType&e）
/*在带头结点单链表L删除第i元素到e，并返回OK。
*/
/*若参数不合理，则返回ERROR。
*/
{
intlength=LengthLinkList（L）;
if（NULL==L||i==0||i>length）returnERROR;
LinkListp;
p=L;
if（i==length）
{
while（--i>0）
p=p->next;
e=p->next->data;
p->next=NULL;
}
else
{
while（--i>0）
p=p->next;
e=p->next->data;
p->next=p->next->next;
}
returnOK;
}
DSO4-PE66
/**********
【题目】试写一算法，在带头结点单链表的第i元素起的
所有元素从链表移除，并构成一个带头结点的新链表。
带头结点单链表的类型定义为：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
**********/
intLengthLinkList（LinkListL）
{
LinkListp=L;
intlength=0;
while（p->next）
{
length++;
p=p->next;
}
returnlength;
}
StatusSplit_L（LinkListL,LinkList&Li,inti）
/*在带头结点单链表L的第i元素起的所有元素*/
/*移除，并构成带头结点链表Li，返回OK。
*/
/*若参数不合理，则Li为NULL，返回ERROR。
*/
{
if（NULL==L||i==0）returnERROR;
intlength=LengthLinkList（L）;
if（i>length）
{
Li=NULL;
returnERROR;
}
Li=（LNode*）malloc（sizeof（LNode））;
if（NULL==Li）
returnERROR;
LinkListp=L;
while（--i>0）
p=p->next;
Li->next=p->next;
p->next=NULL;
returnOK;
}
DS04-PE68
/**********
【题目】试写一算法，在带头结点单链表删除第i元素
起的所有元素。
带头结点单链表的类型定义为：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
**********/
intLengthLinkList（LinkListL）
{
LinkListp=L;
intlength=0;
while（p->next）
{
length++;
p=p->next;
}
returnlength;
}
StatusCut_L（LinkListL,inti）
/*在带头结点单链表L删除第i元素起的所有元素，并返回OK。
*/
/*若参数不合理，则返回ERROR。
*/
{
if（NULL==L||i==0）returnERROR;
intlength=LengthLinkList（L）;
if（i>length）
returnERROR;
LinkListp=L;
while（--i>0）
p=p->next;
p->next=NULL;
returnOK;
}
DS04-PE70
/**********
【题目】试写一算法，删除带头结点单链表中所有值
为x的元素，并释放被删结点空间。
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
**********/
StatusDeleteX_L（LinkListL,ElemTypex）
/*删除带头结点单链表L中所有值为x的元素，*/
/*并释放被删结点空间，返回实际删除的元素个数。
*/
{
if（NULL==L）returnERROR;
LinkListp;
p=L;
intcount=0;
if（NULL==L->next）returncount;
if（NULL==p->next->next）
{
if（x==p->next->data）
{
count++;
p->next=NULL;
}
returncount;
}
while（p->next->next）
{
if（x==p->next->data）
{
count++;
p->next=p->next->next;
}
else
p=p->next;
}
if（x==p->next->data）
{
count++;
p->next=NULL;
}
returncount;
}
升级会员 