数据结构源代码C语言描述.docx

数据结构源代码C语言描述.docx

《数据结构源代码C语言描述.docx》由会员分享，可在线阅读，更多相关《数据结构源代码C语言描述.docx（41页珍藏版）》请在冰豆网上搜索。

数据结构源代码C语言描述

数据结构源代码归纳

（一）

2008年08月01日星期五23:

46

第一章  绪论

P8

例：

计算f=1！

+2！

+3！

+…+n！

，用C语言描述。

voidfactorsum（n）

intn；

{

inti，j；

intf，w；

f=0；

for（i=1；i〈=n；i++）

{

w=1；

for（j=1；j〈=i；j++）

w=w*j；

f=f+w；

}

return；

}

第二章线性表

P16【算法2.1顺序表的插入】

intInsert（ElemtypeList[],int*num,inti,Elemtypex）

{/*在顺序表List[]中，*num为表尾元素下标位置，在第i个元素前插入数据元素x，若成功，返回TRUE，否则返回FALSE。

*/

intj;

if（i<0||i>*num+1）

   {printf（"Error!

"）;      /*插入位置出错*/

   returnFALSE;}

if（*num>=MAXNUM-1）

   {printf（"overflow!

"）;

   returnFALSE;}    /*表已满*/

for（j=*num;j>=i;j--）

List[j+1]=List[j];   /*数据元素后移*/

List[i]=x;        /*插入x*/

（*num）++;    /*长度加1*/

returnTRUE;}

P18【算法2.2顺序表的删除】

intDelete（ElemtypeList[],int*num,inti）

{/*在线性表List[]中，*num为表尾元素下标位置，删除第i个长度，线性表的长度减1，若成功，则返回TRUE；否则返回FALSE。

*/

intj;

if（i<0||i>*num）

{printf（"Error!

"）;returnFALSE;}/*删除位置出错！

*/

for（j=i+1;j<=*num;j++）

List[j-1]=List[j];    /*数据元素前移*/

  （*num）--;     /*长度减1*/

returnTRUE;}

P19例：

将有序线性表La={2,4,6,7,9}，Lb={1,5,7,8}，合并为Lc={1,2,4,5,6,7,7,8,9}。

voidmerge（ElemtypeLa[],ElemtypeLb[],Elemtype**Lc）

{inti,j,k;

  intLa_length,Lb_length;

  i=j=0;k=0;

  La_length=Length（La）;Lb_length=Length（Lb）;/*取表La,Lb的长度*/

  Initiate（Lc）;       /*初始化表Lc*/

  While（i<=La_length&&j<=Lb_length）

    {a=get（La,i）;b=get（Lb,j）;

       if（a

       else{insert（Lc,++k,b）;++j;}

     }         /*将La和Lb的元素插入到Lc中*/

while（i<=La_length）{a=get（La,i）;insert（Lc,++k,a）;}

while（j<=lb_length）{b=get（La,j）;insert（Lc,++k,b）;}  }

P21例如：

下面定义的结点类型中，数据域包含三个数据项：

学号、姓名、成绩。

Structstudent

{charnum[8];         /*数据域*/

harname[8];       /*数据域*/

intscore;          /*数据域*/

structstudent*next;/*指针域*/

}

P21单链表结点结构定义为：

Typedefstructslnode

{Elemtypedata;

  structslnode*next;

}slnodetype;

slnodetype*p,*q,*s;

P21【算法2.3单链表的初始化】

intInitiate（slnodetype**h）

{if（（*h=（slnodetype*）malloc（sizeof（slnodetype）））==NULL）returnFALSE;

  （*h）->next=NULL;

  returnTRUE;}

P22【算法2.4单链表的后插入】

{s=（slnodetype*）malloc（sizeof（slnodetype））;

  s->data=x;

  s->next=p->next;p->next=s;}

P22【算法2.5单链表的结点插入】

{q=head;

while（q->next!

=p）q=q->next;

s=（slnodetype*）malloc（sizeof（slnodetype））;

s->data=x;

s->next=p;

q->next=s;}

P23【算法2.6单链表的前插入】

intinsert（slnodetype*h,inti,Elemtypex）

{/*在链表h中，在第i个数据元素前插入一个数据元素x*/

slnodetype*p,*q,*s;

intj=0;

p=h;

while（p!

=NULL&&jnext;j++;  /*寻找第i-1个结点*/}

if（j!

=i-1）{printf（"Error!

"）;returnFALSE;  /*插入位置错误*/}

if（（s=（slnodetype*）malloc（sizeof（slnodetype）））==NULL）returnFALSE;

s->data=x;

s->next=p->next;

q->next=s;

returnTRUE;}

P23例：

下面C程序中的功能是，首先建立一个线性链表head={3，5，7，9}，其元素值依次为从键盘输入正整数（以输入一个非正整数为结束）；在线性表中值为x的元素前插入一个值为y的数据元素。

若值为x的结点不存在，则将y插在表尾。

#include"stdlib.h"

#include"stdio.h"

structslnode

{intdata;

structslnode*next;}  /*定义结点类型*/

main（）

{intx,y,d;

structslnode*head,*p,*q,*s;

head=NULL;  /*置链表空*/

q=NULL;  

scanf（"%d",&d）;/*输入链表数据元素*/

while（d>0）

{p=（structslnode*）malloc（sizeof（structslnode））;/*申请一个新结点*/

  p->data=d;

  p->next=NULL;

  if（head==NULL）head=p;/*若链表为空，则将头指针指向当前结点p*/

  elseq->next=p;  /*链表不为空时，则将新结点链接在最后*/

  q=p;/*将指针q指向链表的最后一个结点*/

scanf（"%d",&d）;}

scanf（"%d,%d",&x,&y）;

s=（structslnode*）malloc（sizeof（structslnode））;

s->data=y;

q=head;p=q->next;

while（（p!

=NULL）&&（p->data!

=x））{q=p;p=p->next;}/*查找元素为x的指针*/

s->next=p;q->next=s;/*插入元素y*/

}

P24【算法2.7单链表的删除】

intDelet（slnodetype*h,inti）

{/*在链表h中删除第i个结点*/

slnodetype*p,*s;

  intj;

  p=h;j=0;

while（p->next!

=NULL&&j

{p=p->next;j=j+1;/*寻找第i-1个结点,p指向其前驱*/}

if（j!

=i-1）

    {printf（"Error!

"）;/*删除位置错误!

*/

      returnFALSE;}

s=p->next;

p->next=p->next->next;/*删除第i个结点*/

free（s）;/*释放被删除结点空间*/

returnTRUE;

}

P25例：

假设已有线性链表La，编制算法将该链表逆置。

voidconverse（slnodetype*head）

{slnodetype*p,*q;

p=head->next;

head->next=NULL;

while（p!

=NULL）

  {q=p->next;

    p->next=head->next;

    head->next=p;

    p=q;}

}

P27例：

将两个循环链表首尾相接。

La为第一个循环链表表尾指针，Lb为第二个循环链表表尾指针。

合并后Lb为新链表的尾指针。

Voidmerge（slnodetype*La,slnodetype*Lb）

{slnodetype*p;

  p=La->next;

  Lb->next=La->next;

  La->next=p->next;

  free（p）;

}

P29【算法2.8双向链表的插入】

intinsert_dul（dlnodetype*head,inti,Elemtypex）

{/*在带头结点的双向链表中第i个位置之前插入元素x*/

dlnodetype*p,*s;

intj;

p=head;

j=0;

while（p!

=NULL&&j

{p=p->next;

  j++;}

if（j!

=i||i<1）

{printf（"Error!

"）;

   returnFALSE;}

if（（s=（dlnodetype*）malloc（sizeof（dlnodetype）））==NULL）returnFALSE;

s->data=x;

s->prior=p->prior;/*图中步骤①*/

p->prior->next=s;/*图中步骤②*/

s->next=p;/*图中步骤③*/

p->prior=s;/*图中步骤④*/

returnTRUE;}

P30【算法2.9双向链表的删除】

intDelete_dl（dlnodetype*head,inti）

{dlnodetype*p,*s;

intj;

p=head;

j=0;

while（p!

=NULL&&j

{p=p->next;

  j++;}

if（j!

=i||i<1）

{printf（"Error!

"）;

  returnFALSE;}

s=p;

p->prior->next=p->next;/*图中步骤①*/

p->next->prior=p->prior;/*图中步骤②*/

free（s）;

returnTRUE;}

P32【算法2.10多项式相加】

structpoly*add_poly（structpoly*Ah,structpoly*Bh）

{structpoly*qa,*qb,*s,*r,*Ch;

qa=Ah->next;qb=Bh->next;  /*qa和qb分别指向两个链表的第一结点*/

r=qa;Ch=Ah;  /*将链表Ah作为相加后的和链表*/

while（qa!

=NULL&&qb!

=NULL）  /*两链表均非空*/

{if（qa->exp==qb->exp）   /*两者指数值相等*/

     {x=qa->coef+qb->coef;

       if（x!

=0）

           {qa->coef=x;r->next=qa;r=qa;

            s=qb++;free（s）;qa++;

            }      /*相加后系数不为零时*/

       else{s=qa++;free（s）;s=qb++;free（s）;}/*相加后系数为零时*/

       }

elseif（qa->expexp）{r->next=qa;r=qa;qa++;}/*多项式Ah的指数值小*/

      else{r->next=qb;r=qb;qb++;}    /*多项式Bh的指数值小*/

}

if（qa==NULL）r->next=qb;

elser->next=qa;        /*链接多项式Ah或Bh中的剩余结点*/

return（Ch）;

}

第三章栈和队列

P35相应的C语言函数是：

floatfact（intn）

{floats;

if（n==0||n==1）s=1;

elses=n*fact（n-1）;

return（s）;}

P38用C语言定义的顺序存储结构的栈如下：

#defineMAXNUM<最大元素数>

typedefstruct{

Elemtypestack[MAXNUM];

inttop;}sqstack;

P39【算法3.1栈的初始化】

intinitStack（sqstack*s）

{/*创建一个空栈由指针S指出*/

if（（s=（sqstack*）malloc（sizeof（sqstack）））==NULL）returnFALSE;

s->top=-1;

returnTRUE;

}

P39【算法3.2入栈操作】

intpush（sqstack*s,Elemtypex）

{/*将元素x插入到栈s中，作为s的新栈顶*/

if（s->top>=MAXNUM-1）returnFALSE;/*栈满*/

s->top++;

s->stack[s->top]=x;

returnTRUE;

}

P39【算法3.3出栈操作】

Elemtypepop（sqstack*s）

{/*若栈s不为空，则删除栈顶元素*/

Elemtypex;

if（s->top<0）returnNULL;  /*栈空*/

x=s->stack[s->top];

s->top--;

returnx;

}

P39【算法3.4取栈顶元素】

ElemtypegetTop（sqstack*s）

{/*若栈s不为空，则返回栈顶元素*/

if（s->top<0）returnNULL;  /*栈空*/

return（s->stack[s->top]）;

}

P40【算法3.5判栈空操作】

intEmpty（sqstack*s）

{/*栈s为空时，返回为TRUE；非空时，返回为FALSE*/

if（s->top<0）returnTRUE;

returnFALSE;

}

P40【算法3.6栈置空操作】

voidsetEmpty（sqstack*s）

{/*将栈s的栈顶指针top，置为-1*/

s->top=-1;

}

P40C语言定义的这种两栈共享邻接空间的结构如下：

Typedefstruct{

Elemtypestack[MAXNUM];

intlefttop;  /*左栈栈顶位置指示器*/

intrighttop;/*右栈栈顶位置指示器*/

}dupsqstack;

P41【算法3.7共享栈的初始化】

intinitDupStack（dupsqstack*s）

{/*创建两个共享邻接空间的空栈由指针S指出*/

if（s=（dupsqstack*）malloc（sizeof（dupsqstack）））==NULL）returnFALSE;

s->lefttop=-1;

s->righttop=MAXNUM;

returnTRUE;

}

P41【算法3.8共享栈的入栈操作】

intpushDupStack（dupsqstack*s,charstatus,Elemtypex）

{*把数据元素x压入左栈（status='L'）或右栈（status='R'）*/

if（s->lefttop+1==s->righttop）returnFALSE;  /*栈满*/

if（status='L'）s->stack[++s->lefttop]=x;   /*左栈进栈*/

   elseif（status='R'）s->stack[--s->righttop]=x;/*右栈进栈*/

   elsereturnFALSE;      /*参数错误*/

returnTRUE;

}

P42【算法3.9共享栈的出栈操作】

ElemtypepopDupStack（dupsqstack*s,charstatus）

{/*从左栈（status='L'）或右栈（status='R'）退出栈顶元素*/

  if（status=='L'）

   {if（s->lefttop<0）

       returnNULL;    /*左栈为空*/

elsereturn（s->stack[s->lefttop--]）;    /*左栈出栈*/

}

  elseif（status=='R'）

  {if（s->righttop>MAXNUM-1）

       returnNULL;    /*右栈为空*/

elsereturn（s->stack[s->righttop++]）;/*右栈出栈*/

}

  elsereturnNULL;    /*参数错误*/

}

P42链栈的C语言定义为：

typedefstructStacknode

{

Elemtypedata;

StructStacknode*next;

}slStacktype;

P43【算法3.10单个链栈的入栈操作】

intpushLstack（slStacktype*top,Elemtypex）

{/*将元素x压入链栈top中*/

slStacktype*p;

if（（p=（slStacktype*）malloc（sizeof（slStacktype）））==NULL）returnFALSE;/*申请一个结点*/

p->data=x;p->next=top;top=p;returnTRUE;

}

P43【算法3.11单个链栈的出栈操作】

ElemtypepopLstack（slStacktype*top）

{/*从链栈top中删除栈顶元素*/

slStacktype*p;

Elemtypex;

if（top==NULL）returnNULL;   /*空栈*/

p=top;top=top->next;

x=p->data;free（p）;returnx;

}

P44【算法3.12多个链栈的入栈操作】

intpushDupLs（slStacktype*top[M],inti,Elemtypex）

{/*将元素x压入链栈top[i]中*/

slStacktype*p;

if（（p=（slStacktype*）malloc（sizeof（slStacktype）））==NULL）returnFALSE;/*申请一个结点*/

p->data=x;p->next=top[i];top[i]=p;returnTRUE;

}

P44【算法3.13多个链栈的出栈操作】

ElemtypepopDupLs（slStacktype*top[M],inti）

{/*从链栈top[i]中删除栈顶元素*/

slStacktype*p;

Elemtypex;

if（top[i]==NULL）returnNULL;   /*空栈*/

p=top[i];top[i]=top[i]->next;

x=p->data;free（p）;returnx;

}

P47【算法3.14中缀表达式变为后缀表达式】

#defineMAXNUM40

#defineFALSE0

#defineTRUE1

#include"stdio.h"

#include"stdlib.h"

#include"string.h"

typedefstruct{

charstack[MAXNUM];

inttop;}sqstack;

intinitStack（sqstack*s）

{/*初始化栈*/

s->top=-1;

returnTRUE;

}

intpush（sqstack*s,charx）

{/*将元素x插入到栈s中，作为s的新栈顶*/

if（s->top>=MAXNUM-1）returnFALSE;/*栈满*/

   s->top++;

s->stack[s->top]=x;

returnTRUE;

}

charpop（sqstack*s）

{/*若栈s不为空，则删除栈顶元素*/

charx;

if（s->top<0）returnNULL;   /*栈空*/

   x=s->stack[s->top];

s->top--;

returnx;

}

chargettop（sqstack*s）

{/*若栈s不为空，则返回栈顶元素*/

  if（s->top<0）returnNULL;   /*栈空*/

return（s->stack[s->top]）;

}

charprecede（charx1,charx2）

{/*比较运算符x1与x2的优先*/

charresult='<';

charsting[2];

sting[0]=x2;

sting[1]='\0';

if（（（x1=='+'||x1=='-'）&&（strstr（"+-）#",sting）!

=NULL））||

（（x1=='*'||x1=='/'）&&strstr（"+-*/）#",sting）!

=NULL）||

（x1=='）'&&strstr（"+-*/）#",sting）!

=NULL））

  {result='>';}

elseif（x1=='（'&&x2=='）'||x1=='#'&&x2=='#'）

  {result='=';}

elseif（x1=='）'&&x2=='（'||x1==