数据结构所有算法代码Word文档格式.docx
《数据结构所有算法代码Word文档格式.docx》由会员分享,可在线阅读,更多相关《数据结构所有算法代码Word文档格式.docx(112页珍藏版)》请在冰豆网上搜索。
}
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->
voidInsertQueue