严蔚敏版大数据结构所有算法代码Word下载.docx
《严蔚敏版大数据结构所有算法代码Word下载.docx》由会员分享，可在线阅读，更多相关《严蔚敏版大数据结构所有算法代码Word下载.docx（131页珍藏版）》请在冰点文库上搜索。
}
else
线性表不存在！
intclearlist（list&
l）//将线性表置空操作
if（l.p==NULL）
returnfalse;
{
free（l.p）;
l.p=（node*）malloc（l.listsize*sizeof（node））;
l.length=0;
intlistempty（list&
l）//判断线性表是否为空表
returntrue;
intgetelem（list&
l,inti,node&
e）//用e返回表中第i个数据元素
e=l.p[i-1];
intpriorelem（list&
pre_e）//得到第i个元素的前驱元素
if（i==0||l.p==NULL）
pre_e=l.p[i-1];
intnextelem（list&
next_e）//得到表中第i个元素的后继元素
if（i>
=l.length||l.p==NULL）
next_e=l.p[i+1];
intinsertlist（list&
e）//将元素e插入到表l中第i个元素的后面
node*q,*k;
if（i<
1||i>
l.length+1）
if（l.length>
=l.listsize）
l.p=（node*）realloc（l.p,（l.listsize+LISTINCREMENT）*sizeof（node））;
if（!
l.p）
exit
（1）;
l.listsize+=LISTINCREMENT;
k=&
l.p[i-1];
for（q=&
l.p[l.length-1];
q>
k;
q--）
*（q+1）=*q;
*k=e;
l.length++;
intdeletelist（list&
e）//删除表中第i个元素并用e返回其值
node*q;
intj=i-1;
l.length）
e=l.p[i-1];
j<
l.length-1;
j++）
*q=*（++q）;
l.length--;
voidmergerlist（listla,listlb,list&
lc）//归并两个按非递减排列的线性表
intla_len,lb_len,i=1,j=1,k=0;
nodeai,bj;
la_len=la.length;
lb_len=lb.length;
while（i<
=la_len&
&
=lb_len）
getelem（la,i,ai）;
getelem（lb,j,bj）;
if（ai.a<
=bj.a）
insertlist（lc,++k,ai）;
i++;
}
else
insertlist（lc,++k,bj）;
j++;
=la_len）
insertlist（lc,++k,ai）;
i++;
while（j<
insertlist（lc,++k,bj）;
j++;
intListAscendingOrder（list&
l）//按结点中某一元素的比较升序排列线性表中的结点
nodee;
inti,j;
if（l.p==NULL||l.length==1）
returnERROR;
for（i=0;
i<
i++）
for（j=i+1;
l.length;
if（l.p[i].num>
=l.p[j].num）
{
e=l.p[i];
l.p[i]=l.p[j];
l.p[j]=e;
}
returnOK;
}//省略降序排列
voidMergerList（listla,listlb,list&
lc）//将两线性表升序排列后再归并
node*q,*k,e1;
inti=0,j=0,m=0,n;
ListAscendingOrder（la）;
ListAscendingOrder（lb）;
printf（"
表a升序排列后为：
la.length;
%d"
la.p[i].num）;
表b升序排列后为：
lb.length;
lb.p[i].num）;
i=0;
la.length&
lb.length）
if（la.p[i].num<
=lb.p[j].num）
e1=la.p[i];
e1=lb.p[j];
if（e1.num!
=lc.p[lc.length-1].num）
InsertList（lc,++m,e1）;
la.length）
while（i<
if（la.p[i].num!
InsertList（lc,++m,la.p[i]）;
if（j<
while（j<
if（lb.p[j].num!
InsertList（lc,++m,lb.p[j]）;
按升序排列再归并两表为：
for（n=0;
n<
lc.length;
n++）
printf（"
lc.p[n].num）;
----------------------链表-----------------------------
typedefstruct
intnum;
typedefstructLIST
nodedata;
structLIST*next;
}list,*slist;
intCreatList（slist&
head）//此处应为只针对的引用
head=（list*）malloc（sizeof（list））;
head）
returnERROR;
head->
next=NULL;
returnOK;
voidInvertedList（slist&
head1,slist&
head2）
{//构造新表逆置单链表函数
list*p,*q;
p=head1->
next;
q=p->
if（p==NULL）
链表为空无法实现逆置操作\n"
while（q!
p->
next=head2->
head2->
next=p;
p=q;
q=q->
p->
逆置成功！
?
voidInsertList（slist&
head,node&
e）//此处应为指针的引用
{//而不应该是list*head
p=（list*）malloc（sizeof（list））;
q=head;
while（q->
next!
q=q->
p->
next=q->
q->
data=e;
voidInvertedList（sqlist&
{//-------不构造新表逆置单链表函数---------//
list*p,*q,*k;
p=head->
k=q->
while（k!
q->
p=q;
q=k;
k=k->
next=q;
//----交换链表中第i个和第j个结点，函数实现如下——//
intSwapListNode（sqlist&
head,inti,intj）
intm,n,m1,n1,sum=0;
list*p,*q,*k,*c,*d,*ba;
ba=head->
while（ba!
sum++;
ba=ba->
if（i==j||i>
sum||j>
sum||i<
1||j<
1）
所要交换的两个结点有误！
j）
{m=i;
n=j;
{m=j;
n=i;
p=head;
q=head;
for（m1=1;
m1<
=m;
m1++）
p=p->
for（n1=1;
n1<
=n;
n1++）
if（p->
next==q）
{//如果结点相邻
k=head;
while（k->
=p）
k=k->
//相邻两结点的交换
k->
{//如果结点不相邻
c=head;
while（c->
=q）
c=c->
d=p->
//不相邻两结点之间的交换
c->
next=d;
//-----将链表中结点按结点中某一项大小升序排列，函数实现如下-----//
intAscendingList（sqlist&
intm,n,sum=0,i,j;
k=head->
for（i=1;
sum;
=sum;
p=head->
m=1;
while（m!
=i）
m++;
p=p->
q=head->
n=1;
while（n!
=j）
n++;
q=q->
if（p->
data.exp>
q->
data.exp）//如果按exp降序排列，则应将>
改为<
；
SwapListNode（head,i,j）;
returnOK;
//-----将两链表合并为一个链表------//
intAddList（sqlist&
head1,sqlist&
head2,sqlist&
head3）
{//已将表head1和表head2按某一项升序排列过
sqlistp,q;
q=head2->
while（p!
=NULL&
q!
if（p->
data.exp<
data.exp）
InsertList（head3,p->
data）;
p=p->
InsertList（head3,q->
data.exp==q->
e.coefficient=p->
data.coefficient+q->
data.coefficient;
e.exp=p->
data.exp;
//e.exp=q->
InsertList（head3,e）;
if（p!
while（p!
}//如果p中有剩余，则直接将p中剩余元素插入head3中
if（q!
}//如果q中有剩余，则直接将q中的剩余元素插入head3中
return0;
-----------------------栈------------------------------
//---------利用栈结构实现数制之间的转换------书3.2.1//
node*base;
node*top;
intstacksize;
}stack;
//顺序栈结构定义
intCreatStack（stack&
stackll）
stackll.base=（node*）malloc（INITSTACKSIZE*sizeof（node））;
stackll.base）
exit（OVERFLOW）;
stackll.top=stackll.base;
stackll.stacksize=INITSTACKSIZE;
voidpush（stack&
s,nodee）
{//进栈操作
if（s.top-s.base>
=s.stacksize）
{s.base=（node*）realloc（s.base,（s.stacksize+INCRESTACKMENT）*sizeof（node））;
s.base）
s.top=s.base+s.stacksize;
//可以不写此语句；
s.stacksize+=INCRESTACKMENT;
*（s.top++）=e;
//*s.top++=e;
voidpop（stack&
s,node&
e）
{//出栈操作
if（s.top==s.base||s.base==NULL）
信息有误！
e=*--s.top;
//-------取栈顶元素函数------//
voidgettop（stack&
if（s.base==s.top）
栈为空，无法取得栈顶元素！
e=*（s.top-1）;
//-----栈的应用：
括号匹配的检验------书3.2.2//
//省略了大部分上述已有代码//
intzypd（charc）
{//判断是否为左括号字符
if（c=='
['
||c=='
{'
（'
）
intmain（void）
stacks;
nodee1,e2,e3;
charst[INITSTACKSIZE];
inti=0,j;
CreatStack（s）;
请输入括号字符，以'
#'
做结束符：
"
scanf（"
%c"
&
st[i]）;
while（st[i]!
='
scanf（"
zypd（st[0]））
输入字符不合法！
for（j=0;
i;
{
if（zypd（st[j]））
{//如果是左括号则将此字符压入栈中
e1.c=st[j];
push（s,e1）;
else
{//如果当前st[j]元素不是左括号
//则取出栈顶元素，比较栈顶元素与当前st[j]元素是否项匹配
//如果匹配，则栈顶元素出栈
gettop（s,e2）;
if（e2.c=='
st[j]=='
]'
||e2.c=='
}'
）'
pop（s,e3）;
else
{
printf（"
括号验证失败！
break;
}
if（s.top==s.base）//当循环结束时，如果栈为空栈说明输入的括号合法
括号验证成功！
getchar（）;
system（"
pause"
//----------链栈描述---------//
typedefstructNode
structNode*next;
Node*top;
Node*base;
voidInitStack（stack&
s）
s.base=（Node*）malloc（sizeof（node））;
s.base->
s.top=s.base;
voidInsertStack（stack&
p=（node*）malloc（sizeof（node））;
p）
*p=e;
next=s.top;
s.top=p;
voidDeleteStack（stack&
if（s.top==s.base）
栈为空！
p=s.top;
s.top=s.top->
e=*p;
free（p）;
--------------------队列----------------------
//------链队列的描述及操作-------//
inta;
}Qnode,*QueuePtr;
QueuePtrfront;
QueuePtrrear;
}LinkQueue;
voidInitQueue（LinkQueue&
Q）
Q.front=（Qnode*）malloc（sizeof（Qnode））;
Q.front）
Q.rear=Q.front;
Q.front->
void
升级会员 