数据结构.docx

数据结构.docx

《数据结构.docx》由会员分享，可在线阅读，更多相关《数据结构.docx（15页珍藏版）》请在冰豆网上搜索。

数据结构

静态链表

初始化

voidInitList（SLinkListSL）{

SL.Nodes[0].link=-1;

SL.newptr=1;//当前可分配空间从1开始

//建立带表头结点的空链表

for（inti=1;i

SL.Nodes[i].link=i+1;

//构成空闲链接表

SL.Nodes[MaxSize-1].link=-1;

//链表收尾

}

查找元素

intFind（SLinkListSL,ListDatax）{

intp=SL.Nodes[0].link;

//指针p指向链表第一个结点

while（p!

=-1）

if（SL.Nodes[p].data!

=x）

p=SL.Nodes[p].link;

elsebreak;

//逐个结点检测查找具有给定值的结点

returnp;

}

表尾追加新节点

intAppend（SLinkListSL,ListDatax）{

if（SL.newptr==-1）return0;//追加失败

intq=SL.newptr;//分配结点

SL.newptr=SL.Nodes[SL.newptr].link;

SL.Nodes[q].data=x;

SL.Nodes[q].link=-1;

intp=0;//查找表尾

while（SL.Nodes[p].link!

=-1）

p=SL.Nodes[p].link;

SL.Nodes[p].link=q;//追加

return1;

}

通过键盘输入一组多项式的系数和指数，以输入系数0为结束标志，并约定建立多项式链表时，总是按指数从大到小的顺序排列。

算法描述：

从键盘接受输入的系数和指数；用尾插法建立一元多项式的链表。

polylistpolycreate（）

{

polynode*head,*rear,*s;intc,e;

head=（Polynode*）malloc（sizeof（Polynode））;

rear=head;

scanf（″%d,%d″,&c,&e）;

while（c!

=0）{

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

s->coef=c;s->exp=e;

rear->next=s;rear=s;

scanf（″%d,%d″,&c,&e）;}

rear->next=NULL;return（head）;

}

多项式相加过程

voidpolyadd（Polylistpolya;Polylistpolyb）

{

Polynode*p,*q,*pre;*temp;

intsum;

p=polya->next;

q=polyb->next;

pre=polya;/*pre指向和多项式的尾结点*/

while（p!

=NULL&&q!

=NULL）

{

if（p->expexp）

{pre->next=p;pre=pre->next;p=p->next;}

elseif（p->exp==q->exp）

{sum=p->coef+q->coef;

if（sum!

=0）

{p->coef=sum;pre->next=p;

pre=pre->next;p=p->next;}

else

{temp=p->next;free（p）;p=temp;

temp=q->next;free（q）;q=temp;}

}

else

{pre->next=q;pre=pre->next;q=q->next;}

}

if（p!

=NULL）pre->next=p;

elsepre->next=q;

}

#include

#include

typedefstructnode

{

intnDate;

structnode*pstnext;

}Node;

//链表输出

voidoutput（Node*head）

{

Node*p=head->pstnext;

while（NULL!

=p）

{

printf（"%d",p->nDate）;

p=p->pstnext;

}

printf（"\r\n"）;

}

//链表建立

Node*creat（）

{

Node*head=NULL,*p=NULL,*s=NULL;

intDate=0,cycle=1;

head=（Node*）malloc（sizeof（Node））;

if（NULL==head）

{

printf（"分配内存失败\r\n"）;

returnNULL;

}

head->pstnext=NULL;

p=head;

while（cycle）

{

printf（"请输入数据且当输入数据为0时结束输入\r\n"）;

scanf（"%d",&Date）;

if（0!

=Date）

{

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

if（NULL==s）

{

printf（"分配内存失败\r\n"）;

returnNULL;

}

s->nDate=Date;

p->pstnext=s;

p=s;

}

else

{

cycle=0;

}

}

p->pstnext=NULL;

return（head）;

}

//单链表测长

voidlength（Node*head）

{

Node*p=head->pstnext;

intj=0;

while（NULL!

=p）

{

p=p->pstnext;

j++;

}

printf（"%d\r\n",j）;

}

//链表按值查找

voidresearch_Date（Node*head,intdate）

{

Node*p;

intn=1;

p=head->pstnext;

while（NULL!

=p&&date!

=p->nDate）

{

p=p->pstnext;

++n;

}

if（NULL==p）

{

printf（"链表中没有找到该值"）;

}elseif（date==p->nDate）

{

printf（"要查找的值%d在链表中第%d个位置\r\n",date,n）;

}

return;

}

//按序号查找

voidresearch_Number（Node*head,intNum）

{

Node*p=head;

inti=0;

while（NULL!

=p&&i

{

p=p->pstnext;

i++;

}

if（p==NULL）

{

printf（"查找位置不合法\r\n"）;

}elseif（i==0）

{

printf（"查找位置为头结点\r\n"）;

}elseif（i==Num）

{

printf（"第%d个位置数据为%d\r\n",i,p->nDate）;

}

}

//在指定元素之前插入新结点

voidinsert_1（Node*head,inti,intNewdate）

{

Node*pre=head,*New=NULL;

intj=0;

while（NULL!

=pre&&j

{

pre=pre->pstnext;

j++;

}

if（NULL==pre||j>i-1）

{

printf（"插入位置不存在\r\n"）;

}else

{

New=（Node*）malloc（sizeof（Node））;

if（NULL==New）

{

printf（"分配内存失败\r\n"）;

return;

}

New->nDate=Newdate;

New->pstnext=pre->pstnext;

pre->pstnext=New;

}

}

//在指定元素之后插入新结点

voidinsert_2（Node*head,inti,intNewdate）

{

Node*pre=head,*New=NULL;

intj=0;

while（NULL!

=pre->pstnext&&j

{

pre=pre->pstnext;

j++;

}

if（j==i）

{

New=（Node*）malloc（sizeof（Node））;

if（NULL==New）

{

printf（"分配内存失败\r\n"）;

return;

}

New->nDate=Newdate;

New->pstnext=pre->pstnext;

pre->pstnext=New;

}else

{

printf（"插入位置不存在\r\n"）;

}

}

//删除第一个结点

voiddelete_list（Node*head）

{

Node*p=head->pstnext;

head->pstnext=p->pstnext;

free（p）;

}

//删除指定结点

voidDelete_1（Node*head,inti3）

{

Node*p=head,*pre=NULL;

intj=0;

while（NULL!

=p&&j

{

pre=p;

p=p->pstnext;

j++;

}

if（NULL==p）

{

printf（"删除位置不存在\r\n"）;

}else

{

pre->pstnext=p->pstnext;

free（p）;

}

}

//指定删除单链表中某个数据，并统计删除此数据的个数

intDelete_2（Node*head,intDelete_date）

{

intcount=0;

Node*p=head,*q;

while（NULL!

=p->pstnext）

{

q=p->pstnext;

if（q->nDate==Delete_date）

{

p->pstnext=q->pstnext;

free（q）;

++count;

}

else

{

p=q;

}

}

returncount;

}

//链表逆置

voidReverse_list（Node*head）

{

Node*q,*s;

if（NULL==head->pstnext||NULL==head->pstnext->pstnext）

{

return;

}

q=head->pstnext->pstnext;

head->pstnext->pstnext=NULL;

while（NULL!

=q）

{

s=q->pstnext;

q->pstnext=head->pstnext;

head->pstnext=q;

q=s;

}

}

//单链表的连接

voidconnect_list（Node*head,Node*head_New）

{

Node*p=head;

while（NULL!

=p->pstnext）

{

p=p->pstnext;

}

p->pstnext=head_New->pstnext;

}

voidmain（）

{

intdate,num;//待查找数据

inti3;//指定删除元素的位置

inti1,i2,Newdate_1,Newdate_2;//待插入的新数据

intDelete_date,k;//待删除的数据与其个数

Node*Head=NULL;//定义头结点

Node*Head_New=NULL;

//链表建立

Head=creat（）;

printf（"输出建立的单链表\r\n"）;

output（Head）;

//单链表测长

printf（"单链表长度为\r\n"）;

length（Head）;

//链表按值查找

printf（"请输入待查找的数据\r\n"）;

scanf（"%d",&date）;

research_Date（Head,date）;

//链表按序号查找

printf（"请输入待查找序号\r\n"）;

scanf（"%d",&num）;

research_Number（Head,num）;

//在指定第i1个元素之前插入新元素Newdate

printf（"在指定第i个元素之前插入新元素Newdate"）;

printf（"请输入i与元素且以逗号间隔\r\n"）;

scanf（"%d,%d",&i1,&Newdate_1）;

insert_1（Head,i1,Newdate_1）;

printf（"插入后新链表\r\n"）;

output（Head）;

//在指定第i2个元素之后插入新元素Newdate

printf（"在指定第i个元素之后插入新元素Newdate"）;

printf（"请输入i与元素且以逗号间隔\r\n"）;

scanf（"%d,%d",&i2,&Newdate_2）;

insert_2（Head,i2,Newdate_2）;

printf（"插入后新链表\r\n"）;

output（Head）;

//删除链表第一个结点

delete_list（Head）;

printf（"输出删除后的链表\r\n"）;

output_list（Head）;

//指定删除i3元素

printf（"删除元素的位置\r\n"）;

scanf（"%d",&i3）;

Delete_1（Head,i3）;

printf（"删除后新链表\r\n"）;

output（Head）;

//指定删除单链表中某个数据，并统计删除此数据的个数

printf（"请输入待删除的元素\r\n"）;

scanf（"%d",&Delete_date）;

k=Delete_2（Head,Delete_date）;

printf（"删除后新链表\r\n"）;

output（Head）;

printf（"删除指定元素在链表中的个数为：

"）;

printf（"%d\r\n",k）;

//单链表逆置

Reverse_list（Head）;

printf（"逆置后输出\r\n"）;

output（Head）;

//单链表的连接

printf（"建立一个新链表\r\n"）;

Head_New=creat（）;

printf（"输出新链表"）;

output（Head）;

printf（"将新链表连接到原来链表的尾部并输出\r\n"）;

connect_list（Head,Head_New）;

output（Head）;

return;

}

二叉树的非递归算法

voidPreOrder（BiNode*root）

{

top=-1;//采用顺序栈，并假定不会发生上溢

while（root!

=NULL||top!

=-1）

{

while（root!

=NULL）

{

cout<data;

s[++top]=root;

root=root->lchild;

}

if（top!

=-1）{

root=s[top--];

root=root->rchild;

}

}

}

统计二叉树中叶子结点的个数

voidCountLeaf（BiTreeT,int&count）{

if（T）{

if（（!

T->lchild）&&（!

T->rchild））count++;//对叶子结点计数

CountLeaf（T->lchild,count）;

CountLeaf（T->rchild,count）;

}//if

}//CountLeaf

求二叉树的深度（后序）

intDepth（BiTreeT）{//返回二叉树的深度

if（!

T）depthval=0;

else{

depthLeft=Depth（T->lchild）;

depthRight=Depth（T->rchild）;

depthval=1+（depthLeft>depthRight?

depthLeft:

depthRight）;

}

returndepthval;

}

生成一个二叉树的结点（其数据域为item,左指针域为lptr,右指针域为rptr）

BiTNode*GetTreeNode（TElemTypeitem,BiTNode*lptr,BiTNode*rptr）

{

if（!

（T=newBiTNode））exit

（1）;

T->data=item;T->lchild=lptr;T->rchild=rptr;

returnT;

}

BiTNode*CopyTree（BiTNode*T）{

if（!

T）returnNULL;

if（T->lchild）newlptr=CopyTree（T->lchild）;//复制左子树

elsenewlptr=NULL;

if（T->rchild）newrptr=CopyTree（T->rchild）;//复制右子树

elsenewrptr=NULL;

newT=GetTreeNode（T->data,newlptr,newrptr）;

returnnewT;

}//CopyTree