数据结构常用算法数据结构算法.docx
《数据结构常用算法数据结构算法.docx》由会员分享，可在线阅读，更多相关《数据结构常用算法数据结构算法.docx（92页珍藏版）》请在冰豆网上搜索。
数据结构常用算法数据结构算法
数据结构常用算法集合
voidUnion（List&La,ListLb）{//算法2.1
//将所有在线性表Lb中但不在La中的数据元素插入到La中
intLa_len,Lb_len,i;
ElemTypee;
La_len=ListLength（La）;//求线性表的长度
Lb_len=ListLength（Lb）;
for（i=1;i<=Lb_len;i++）{
GetElem（Lb,i,e）;//取Lb中第i个数据元素赋给e
if（!
LocateElem（La,e,equal））//La中不存在和e相同的数据元素
ListInsert（La,++La_len,e）;//插入
}
}//union
voidMergeList（ListLa,ListLb,List&Lc）{//算法2.2
//已知线性表La和Lb中的元素按值非递减排列。
//归并La和Lb得到新的线性表Lc，Lc的元素也按值非递减排列。
intLa_len,Lb_len;
ElemTypeai,bj;
inti=1,j=1,k=0;
InitList（Lc）;
La_len=ListLength（La）;
Lb_len=ListLength（Lb）;
while（（i<=La_len）&&（j<=Lb_len））{//La和Lb均非空
GetElem（La,i,ai）;
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
StatusInitList_Sq（SqList&L）{//算法2.3
//构造一个空的线性表L。
L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;
if（!
L.elem）returnOK;//存储分配失败
L.length=0;//空表长度为0
L.listsize=LIST_INIT_SIZE;//初始存储容量
returnOK;
}//InitList_Sq
StatusListInsert_Sq（SqList&L,inti,ElemTypee）{//算法2.4
//在顺序线性表L的第i个元素之前插入新的元素e，
//i的合法值为1≤i≤ListLength_Sq（L）+1
ElemType*p;
if（i<1||i>L.length+1）returnERROR;//i值不合法
if（L.length>=L.listsize）{//当前存储空间已满，增加容量
ElemType*newbase=（ElemType*）realloc（L.elem,
（L.listsize+LISTINCREMENT）*sizeof（ElemType））;
if（!
newbase）returnERROR;//存储分配失败
L.elem=newbase;//新基址
L.listsize+=LISTINCREMENT;//增加存储容量
}
ElemType*q=&（L.elem[i-1]）;//q为插入位置
for（p=&（L.elem[L.length-1]）;p>=q;--p）*（p+1）=*p;
//插入位置及之后的元素右移
*q=e;//插入e
++L.length;//表长增1
returnOK;
}//ListInsert_Sq
StatusListDelete_Sq（SqList&L,inti,ElemType&e）{//算法2.5
//在顺序线性表L中删除第i个元素，并用e返回其值。
//i的合法值为1≤i≤ListLength_Sq（L）。
ElemType*p,*q;
if（i<1||i>L.length）returnERROR;//i值不合法
p=&（L.elem[i-1]）;//p为被删除元素的位置
e=*p;//被删除元素的值赋给e
q=L.elem+L.length-1;//表尾元素的位置
for（++p;p<=q;++p）*（p-1）=*p;//被删除元素之后的元素左移
--L.length;//表长减1
returnOK;
}//ListDelete_Sq
intLocateElem_Sq（SqListL,ElemTypee,
Status（*compare）（ElemType,ElemType））{//算法2.6
//在顺序线性表L中查找第1个值与e满足compare（）的元素的位序。
//若找到，则返回其在L中的位序，否则返回0。
inti;
ElemType*p;
i=1;//i的初值为第1个元素的位序
p=L.elem;//p的初值为第1个元素的存储位置
while（i<=L.length&&!
（*compare）（*p++,e））
++i;
if（i<=L.length）returni;
elsereturn0;
}//LocateElem_Sq
voidMergeList_Sq（SqListLa,SqListLb,SqList&Lc）{//算法2.7
//已知顺序线性表La和Lb的元素按值非递减排列。
//归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列。
ElemType*pa,*pb,*pc,*pa_last,*pb_last;
pa=La.elem;pb=Lb.elem;
Lc.listsize=Lc.length=La.length+Lb.length;
pc=Lc.elem=（ElemType*）malloc（Lc.listsize*sizeof（ElemType））;
if（!
Lc.elem）
exit（OVERFLOW）;//存储分配失败
pa_last=La.elem+La.length-1;
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++;//插入La的剩余元素
while（pb<=pb_last）*pc++=*pb++;//插入Lb的剩余元素
}//MergeList
StatusGetElem_L（LinkList&L,inti,ElemType&e）{//算法2.8
//L为带头结点的单链表的头指针。
当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
LinkListp;
p=L->next;intj=1;//初始化，p指向第一个结点，j为计数器
while（p&&jp=p->next;++j;
}
if（!
p||j>i）returnERROR;//第i个元素不存在
e=p->data;//取第i个元素
returnOK;}//GetElem_L
StatusListInsert_L（LinkList&L,inti,ElemTypee）{//算法2.9
//在带头结点的单链线性表L的第i个元素之前插入元素e
LinkListp,s;
p=L;
intj=0;
while（p&&jp=p->next;
++j;
}
if（!
p||j>i-1）returnERROR;//i小于1或者大于表长
s=（LinkList）malloc（sizeof（LNode））;//生成新结点
s->data=e;s->next=p->next;//插入L中
p->next=s;
returnOK;
}//LinstInsert_L
StatusListDelete_L（LinkList&L,inti,ElemType&e）{//算法2.10
//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
LinkListp,q;
p=L;intj=0;
while（p->next&&jp=p->next;++j;
}
if（!
（p->next）||j>i-1）returnERROR;//删除位置不合理
q=p->next;
p->next=q->next;//删除并释放结点
e=q->data;
free（q）;
returnOK;
}//ListDelete_L
voidCreateList_L（LinkList&L,intn）{//算法2.11
//逆位序输入（随机产生）n个元素的值，建立带表头结点的单链线性表L
LinkListp;
inti;
L=（LinkList）malloc（sizeof（LNode））;
L->next=NULL;//先建立一个带头结点的单链表
for（i=n;i>0;--i）{
p=（LinkList）malloc（sizeof（LNode））;//生成新结点
p->data=random（200）;//改为一个随机生成的数字（200以内）
p->next=L->next;L->next=p;//插入到表头
}
}//CreateList_L
voidMergeList_L（LinkList&La,LinkList&Lb,LinkList&Lc）{
//算法2.12
//已知单链线性表La和Lb的元素按值非递减排列。
//归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
LinkListpa,pb,pc;
pa=La->next;pb=Lb->next;
Lc=pc=La;//用La的头结点作为Lc的头结点
while（pa&&pb）{
if（pa->data<=pb->data）{
pc->next=pa;pc=pa;pa=pa->next;
}
else{pc->next=pb;pc=pb;pb=pb->next;}
}
pc->next=pa?
pa:
pb;//插入剩余段
free（Lb）;//释放Lb的头结点
}//MergeList_L
intLocateElem_SL（SLinkListS,ElemTypee）{//算法2.13
//在静态单链线性表L中查找第1个值为e的元素。
//若找到，则返回它在L中的位序，否则返回0。
inti;
i=S[0].cur;//i指示表中第一个结点
while（i&&S[i].data!
=e）i=S[i].cur;//在表中顺链查找
returni;
}//LocateElem_SL
voidInitSpace_SL（SLinkListspace）{//算法2.14
//将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，
//"0"表示空指针
for（inti=0;ispace[i].cur=i+1;
space[MAXSIZE-1].cur=0;
}//InitSpace_SL
intMalloc_SL（SLinkList&space）{//算法2.15
//若备用空间链表非空，则返回分配的结点下标，否则返回0
inti=space[0].cur;
if（space[0].cur）space[0].cur=space[space[0].cur].cur;
returni;
}//Malloc_SL
voidFree_SL（SLinkList&space,intk）{//算法2.16
//将下标为k的空闲结点回收到备用链表
space[k].cur=space[0].cur;space[0].cur=k;
}//Free_SL
voiddifference（SLinkList&space,int&S）{//算法2.17
//依次输入集合A和B的元素，在一维数组space中建立表示集合（A-B）∪（B-A）
//的静态链表,S为头指针。
假设备用空间足够大，space[0].cur为头指针。
inti,j,k,m,n,p,r;
ElemTypeb;
InitSpace_SL（space）;//初始化备用空间
S=Malloc_SL（space）;//生成S的头结点
r=S;//r指向S的当前最后结点
m=random（2,8）;//输入A的元素个数
n=random（2,8）;//输入B的元素个数
printf（"A=（"）;
initrandom_c1（）;
for（j=1;j<=m;++j）{//建立集合A的链表
i=Malloc_SL（space）;//分配结点
//printf（"i=%d",i）;
space[i].data=random_next_c1（）;//输入A的元素值
printf（"%c",space[i].data）;//输出A的元素
space[r].cur=i;r=i;//插入到表尾
}
printf（"）\n"）;
space[r].cur=0;//尾结点的指针为空
initrandom_c1（）;
printf（"B=（"）;
for（j=1;j<=n;++j）{
//依次输入B的元素,若不在当前表中,则插入,否则删除
b=random_next_c1（）;//输入B的元素值
printf（"%c",b）;//输出B的元素
p=S;k=space[S].cur;//k指向集合A中第一个结点
while（k!
=space[r].cur&&space[k].data!
=b）{//在当前表中查找
p=k;k=space[k].cur;
}
if（k==space[r].cur）{
//当前表中不存在该元素,插入在r所指结点之后，且r的位置不变
i=Malloc_SL（space）;
space[i].data=b;
space[i].cur=space[r].cur;
space[r].cur=i;
}else{//该元素已在表中,删除之
space[p].cur=space[k].cur;
Free_SL（space,k）;
if（r==k）r=p;//若删除的是尾元素，则需修改尾指针
}
}
printf（"）\n"）;
}//difference
DuLinkListGetElemP_DuL（DuLinkListva,inti）{
//L为带头结点的单链表的头指针。
//当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
DuLinkListp;
p=va->next;
intj=1;//初始化，p指向第一个结点，j为计数器
while（p!
=va&&jp=p->next;
++j;
}
if（p==va&&jelsereturnp;
}//GetElem_L
StatusListInsert_DuL（DuLinkList&L,inti,ElemTypee）{//算法2.18
//在带头结点的双链循环线性表L的第i个元素之前插入元素e，
//i的合法值为1≤i≤表长+1。
DuLinkListp,s;
if（!
（p=GetElemP_DuL（L,i）））//在L中确定第i个元素的位置指针p
returnERROR;//p=NULL,即第i个元素不存在
if（!
（s=（DuLinkList）malloc（sizeof（DuLNode））））
returnERROR;
s->data=e;
s->prior=p->prior;
p->prior->next=s;
s->next=p;
p->prior=s;
returnOK;
}//ListInsert_DuL
DuLinkListGetElemP_DuL（DuLinkListva,inti）{
//L为带头结点的单链表的头指针。
//当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
DuLinkListp;
p=va->next;
intj=1;//初始化，p指向第一个结点，j为计数器
while（p!
=va&&jp=p->next;
++j;
}
if（p==va||jelsereturnp;
}//GetElem_L
StatusListDelete_DuL（DuLinkList&L,inti,ElemType&e）{//算法2.19
//删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
DuLinkListp;
if（!
（p=GetElemP_DuL（L,i）））//在L中确定第i个元素的位置指针p
returnERROR;//p=NULL,即第i个元素不存在
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
free（p）;
returnOK;
}//ListDelete_DuL
StatusListInsert_L（NLinkListL,inti,ElemTypee）{//算法2.20
//在带头结点的单链线性表L的第i个元素之前插入元素e
NLinkh,s;
if（!
LocatePos（L,i-1,h））
returnERROR;//i值不合法
if（!
MakeNode（s,e））
returnERROR;//结点存储分配失败
InsFirst（h,s）;//对于从第i结点开始的链表，第i-1结点是它的头结点
returnOK;
}//ListInsert_L
StatusMergeList_L（NLinkList&La,NLinkList&Lb,NLinkList&Lc,
int（*compare）（ElemType,ElemType））{//算法2.21
//已知单链线性表La和Lb的元素按值非递减排列。
//归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
NLinkha,hb;
Positionpa,pb,q;
ElemTypea,b;
if（!
InitList（Lc））returnERROR;//存储空间分配失败
ha=GetHead（La）;//ha和hb分别指向La和Lb的头结点
hb=GetHead（Lb）;
pa=NextPos（La,ha）;//pa和pb分别指向La和Lb中当前结点
pb=NextPos（Lb,hb）;
while（pa&&pb）{//La和Lb均非空
a=GetCurElem（pa）;//a和b为两表中当前比较元素
b=GetCurElem（pb）;
if（（*compare）（a,b）<=0）{//a≤b
DelFirst（ha,q）;Append（Lc,q）;pa=NextPos（La,pa）;
}else{//a＞b
DelFirst（hb,q）;Append（Lc,q）;pb=NextPos（Lb,pb）;
}
}//while
if（pa）Append（Lc,pa）;//链接La中剩余结点
elseAppend（Lc,pb）;//链接Lb中剩余结点
FreeNode（ha）;FreeNode（hb）;//释放La和Lb的头结点
returnOK;
}//MergeList_L
Statuscmp（PElemTypea,PElemTypeb）{
if（a.expn>=b.expn）return1;
elsereturn0;
}
voidCreatPolyn（PLinkList&P,intm）{//算法2.
升级会员 