线性表——数据结严蔚敏C语言版代码代码
ADT List
{
D;
R;
InitList(&L)
DestroyList(&L)
ClearList(&L)
ListEmpty(L)
ListLength(L)
GetElem(L,i,&e)
LocateElem(L,e,compare())
PriorElem(L,cur_e,&pre_e)
NextElem(L,cur_e,&next_e)
ListInsert(&L,i,e)
ListDelete(&L,i,&e)
ListTraverse(L,visit())
}ADT List
void Union(List &La,List Lb)
{
int La_len=ListLength(La),Lb_len=ListLength(Lb);
for(int i=1;i<=Lb_len;i++){
GetElem(LB,i,e);
if(!LocateElem(La,e,equal)) ListInsert(La,La_len,e);
}
}//Union
void MergeList(List La,List Lb,List &Lc)
{
InitList(Lc);
int i=1,j=1,k=0;
int La_len=ListLength(La),Lb_len=ListLength(Lb);
while(i<=La_len&&j<=Lb_len){
GetElem(La,i,a[i]); GetElem(Lb,j,bj);
if(ai<=bj) {ListInsert(Lc,++k,ai); ++i;}
else {ListInsert(Lc,++k,bj); ++j}
}
while(i<=La_len){
GetElem(La,i++,ai); ListInsert(Lc,++k,ai);
}
while(j<=Lb_len){
GetElem(Lb,j++,bj); ListInsert(Lc,++k,bj);
}
}//MergeList
#define ElemType int
#define Status int
#define OK 1
#define OVERFLOW 0
#define ERROR 0
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef struct{
ElemType *elem;
int length;
int listsize;
}SqList;
Status InitList_Sq(SqList &L)
{
L.elem=(ElemType )malloc(LIST_INIT_SIZEsizeof(ElemType));
if(!L.elem) exit(OVERFLOW);
L.length=0;
L.listsize=LIST_INIT_SIZE;
return OK;
}//InitList_Sq
Status ListInsert_Sq(SqList &L,int i,ElemType e){
if(i<1||i>L.length+1) return ERROR;
if(L.length>=L.listsize){
ElemType *newbase=(ElemType )malloc(L.elem,L.listsize+LISTINCREMENTsizeof(ElemType));
if(!newbase) exit(OVERFLOW);
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
ElemType q=&(L.elem[i-1]);
for(ElemType p=&(L.elem[L.length-1]);p>=q;–p) *(p+1)=*p;
*q=e;
++L.length;
return OK;
}//ListInsert_Sq
Status ListDelete_Sq(SqList &L,int i,ElemType &e){
if(i<1||i>L.length+1) return ERROR;
ElemType p=&(L.elem[i-1]);
e=*p;
ElemType q=L.elem+L.length-1;
for(++p;p<=q;++p) *(p-1)=*p;
–L.length;
return OK;
}//ListDelete_Sq
int LocateElem_Sq(SqList L,ElemType e,Status (*compare)(ElemType,ElemType)){
int i=1;
ElemType p=L.elem;
while(i<=L.length&&!(*compare)(*p++,e)) ++i;
if(i<=L.length) return i;
else return 0;
}//LocateElem_Sq
void MergeList_Sq(SqList La,SqList Lb,SqList &Lc){
ElemType * pa=La.elem,pb=Lb.elem;
Lc.listsize=La.length+Lb.length;
ElemType pc=Lc.elem=(ElemType )malloc(Lc.listsizesizeof(ElemType));
if(!Lc.elem) exit(OVERFLOW);
ElemType *pa_last=La.elem+La.length-1;
ElemType *pb_last=Lb.elem+Lb.length-1;
while(pa<=pa_last&&pb<=pb_last){
if(*pa<=*pb) *pc++=*pa++;
else *pc++=*pb++;
}
while(pa<=pa_last) *pc++=*pa++;
while(pb<=pb_last) *pc++=*pb++;
}//MergeList_Sq
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
Status GetElem_L(LinkList L,int i,ElemType &e){
LinkList p=L->next;int j=1;
while(p&&j<=i){
p=p->next;++j;
}
if(!p||j>i) return ERROR;
e=p->data;
return OK;
}//GetElem_L
Status ListInsert_L(LinkList &L,int i,ElemType e){
LinkList P=L;int j=0;
while(p&&j
if(!p||j>i-1) return ERROR;
LinkList s=(LinkList)malloc(sizeof(LNode));
s->data=e;s->next=p->next;
p->next=s;
return OK;
}//ListInsert_L
Status ListDelete_L(LinkList &L,int i,ElemType e){
LinkList P=L;int j=0;
while(p->next&&j
}
if(!(p->next)||j>i-1) return ERROR;
LinkList q=(LinkList)malloc(sizeof(LNode));
q=p->next; p->next=q->next;
e=q->data;free§;
return OK;
}//ListDelete_L
void CreateList_L(LinkList &L,int n){
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
for(int i=n;i>0;–i){
LinkList p=(LinkList)malloc(sizeof(LNode));
scanf("%d",&p->data);
p->next=L->next;L->next=p;
}
}//CreateList_L
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
LinkList pa=La->next,pb=Lb->next;
Lc=La;LinkList pc=La;
while(pa&&pb){
if(pa->data<=pb->data){
pc->next=pa;pc=pa;pa=pa->next;
}
else{pc=pb->next;pc=pb;pb=pb->next;}
}
pc->next=pa?pa:pb;
free(Lb);
}//MergeList_L
#define MAXSIZE 1000
typedef struct{
ElemType data;
int cur;
}component,SlinkList[MAXSIZE];
int LocateElem_SL(SlinkList S,ElemType e)
{
int i=S[0].cur;
while(i&&S[i].data!=e) i=S[i].cur;
return i;
}//LocateElem_SL
void InitSpace_SL(SlinkList &space){
for(int i=0;i
}//InitSpace_SL
int Malloc_SL(SlinkList &space){
int i=space[0].cur;
if(space[0].cur) space[0].cur=space[i].cur;
return i;
}//Malloc_SL
void Free_SL(SlinkList &space,int k){
space[k].cur=space[0].cur;space[0].cur=k;
}//Free_SL
void difference(SlinkList &space,int &S){
InitSpace_SL(space);
S=Malloc_SL(space);
int r=s;
for(int j=1;j<=m;++j){
int i=Malloc_SL(space);
scanf("%d",&space[i].data);
space[r].cur=i;r=i;
}
space[0].cur=0;
for(int j=1;j<=n;++j){
scanf("%d",&b);int p=s;int k=space[S].cur;
while(k!=space[r].cur&&space[k].data!=b){
p=k;k=space[k].cur;
}
if(kspace[r].cur){
int i=Malloc_SL(space);
space[i].data=b;
space[i].cur=space[r].cur;
space[i].cur=i;
}
else{
space[p].cur=space[k].cur;
Free_SL(space,k);
if(rk) r=p;
}
}
}
//循环链表
typedef struct DuLNode{
ElemType data;
struct DuLNode *prior;
struct DuLNode *next;
}DuLNode,*DuLinkList;
Status ListInsert_DuL(DuLinkList &L,int i,ElemType e){
DuLinkList p,s;
if(!(p=GetElem_DuL(L,i)))
return ERROR;
if(!(s=(DuLinkList)malloc(sizeof(DuLNode)))) return ERROR;
s->data=e;
s->prior=p->prior;p->prior->next=s;
s->next=p;
return OK;
}//ListInsert_DuL
Status LinkDelete_DuL(DuLinkList &L,int i,ElemType &e){
DuLinkList p;
if(!(p=GetElem_L(L,i)))
return ERROR;
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
free§; return OK;
}//LinkDelete_DuL
typedef struct LNode{
ElemType data;
struct LNode;
}*Link,*Position;
typedef struct{
Link head,tail;
int len;
}LinkList;
Status MakeNode(Link &p,ElemType e)
void FreeNode(Link &p)
Status InitList(LinkList &L)
Status DestoryList(LinkList &L)
Status ClearList(LinkList &L)
Status InsFirst(Link h,Link s)
Status DelFirst(Link h,Link &q)
Status Append(LinkList &L,Link s)
Status Remove(LinkList &L,Link &q)
Status InsBefore(LinkList &L,Link &p,Link s)
Status InsAfter(LinkList &L,Link &L,Link s)
Status SetCurElem(Link &p,ElemType e)
ElemType GetCurElem(Link p)
Status ListEmpty(LinkList L)
int ListLength(LinkList L)
Position GetHead(LinkList L)
Position GetLast(LinkListL L)
Position PriorPos(LinkList L,Link p)
Position NextPos(LinkList L,Link p)
Position LocatePos(LinkList L,int i,Link &p)
Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
Position ListTraverse(LinkList L,Status (*visit)())
Status ListInsert_L(LinkList &L,int i,ElemType e){
Link h,s;
if(!LocateElem(L,i-1,h)) return ERROR;
if(!MakeNode(s,e)) return ERROR;
InsFirst(h,s);
return OK;
}//ListInsert_L
Status MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc,int (*compare)(ElemType,ElemType)){
if(!InitList(Lc)) return ERROR;
Position ha=GetHead(La),hb=GetHead(Lb);
Position pa=NextPos(La,ha),pb=NextPos(Lb,hb);
while(pa&&pb){
ElemType a=GetCurElem(pa),b=GetCurElem(pb);
if((*compare)(a,b)<=0){
DelFirst(ha,q);Append(Lc,q);pa=NextPos(La,ha);}
else{
DelFirst(hb,q);Append(Lc,q);pb=NextPos(Lb,hb);}
}
if(pa) Append(Lc,pa);
else Append(Lc,pb);
FreeNode(ha);FreeNode(hb);
return OK;
}//MergeList_L
ADT Polynomial{
D;
R1;
GreatPolyn(&P,n)
DestoryPolyn(&P)
PrintPolyn§
PolynLength§
AddPolyn(&Pa,&Pb)
SubtractPolyn(&Pa,&Pb)
MultiplyPolyn(&Pa,&Pb)
}ADT Polynomial
Status LocatElem(LinkList L,ElemType e,Position &q,int (*compare)(ElemType,ElemType))
Status OrderElem(LinkList &L,ElemType e,int (*compare)(ElemType,ElemType))
typedef struct{
float coef;
int expn;
}term,ElemType;
typedef LinkList polynomial;
void GreatPolyn(polynomial &P,int m)
void DestoryPolyn(polynomial &P)
void PrintPolyn(polynomial P)
void PolynLength(polynomial P)
void AddPolyn(polynomial &Pa,polynomial &Pb)
void SubtractPolyn(polynomial &Pa,polynomial &Pb)
void MultiplyPolyn(polynomial &Pa,polynomial&Pb)
int cmp(term a,term b)
void GreatPolyn(polynomial &P,int m){
InitList§;Position h=GetHead§;
term e;
e.ceof=0.0;e.expn=-1; SetCurElem(h,e);
for(int i=0;i<=m;i++){
scanf("%d%d",&e.coef,&e.expn);
if(!LocateElem(P,e,q,(*com)())){
if(MakeNode(s,e)) InsFirst(q,s);
}
}
}
void AddPolyn(polynomial &Pa,polynomial &Pb){
Position ha=GetHead(La),hb=GetHead(Lb);
Position qa=NextPos(La,ha),qb=NextPos(Lb,hb);
while(qa&&qb){
ElemType a=GetCurElem(qa),b=GetCurElem(qb);
switch(*com(a,b)){
case -1:
ha=qa;qa=NextPos(Pa,qa);
break;
case 0:
float sum=a.coef+b.coef;
if(sum!=0.0){
SetCurElem(qa,sum);ha=qa;}
else{
DelFirst(ha,qa);FreeNode(qa);}
DelFirst(hb,qb);FreeNode(qb);qb=NextPos(Pb,hb);
qa=NextPos(Pa,ha);break;
case 1:
DelFirst(hb,pb);InsFirst(ha,qb);
qb=NextPos(Pb,hb);ha=NextPos(Pa,ha);break;
}
}
if(!ListEmpty(Pb)) Append(Pa,qb);
FreeNode(hb);
}