数据结构程序.docx
《数据结构程序.docx》由会员分享，可在线阅读，更多相关《数据结构程序.docx（16页珍藏版）》请在冰豆网上搜索。
数据结构程序
十进制转化为二进制
#include
main（）
{
intn,i,a[80],t;
i=0;
printf（"输入一个十进制数\n"）;
scanf（"%d",&n）;
do
{
a[i]=n%2;
n=n/2;
i++;
}
while（n!
=0）;
t=i;
for（i=t-1;i>=0;i--）
printf（"%d",a[i]）;
return0;
}
二叉树
#include
#include
#defineMAX20
typedefstructBTNode{/*节点结构声明*/
chardata;/*节点数据*/
structBTNode*lchild;
structBTNode*rchild;/*指针*/
}*BiTree;
voidcreateBiTree（BiTree*t）{/*先序遍历创建二叉树*/
chars;
BiTreeq;
printf（"\npleaseinputdata:
（exitfor#）"）;
s=getche（）;
if（s=='#'）{*t=NULL;return;}
q=（BiTree）malloc（sizeof（structBTNode））;
if（q==NULL）{printf（"Memoryallocfailure!
"）;exit（0）;}
q->data=s;
*t=q;
createBiTree（&q->lchild）;/*递归建立左子树*/
createBiTree（&q->rchild）;/*递归建立右子树*/
}
voidPreOrder（BiTreep）{/*先序遍历二叉树*/
if（p!
=NULL）{
printf（"%c",p->data）;
PreOrder（p->lchild）;
PreOrder（p->rchild）;
}
}
voidInOrder（BiTreep）{/*中序遍历二叉树*/
if（p!
=NULL）{
InOrder（p->lchild）;
printf（"%c",p->data）;
InOrder（p->rchild）;
}
}
voidPostOrder（BiTreep）{/*后序遍历二叉树*/
if（p!
=NULL）{
PostOrder（p->lchild）;
PostOrder（p->rchild）;
printf（"%c",p->data）;
}
}
voidPreorder_n（BiTreep）{/*先序遍历的非递归算法*/
BiTreestack[MAX],q;
inttop=0,i;
for（i=0;iq=p;
while（q!
=NULL）{
printf（"%c",q->data）;
if（q->rchild!
=NULL）stack[top++]=q->rchild;
if（q->lchild!
=NULL）q=q->lchild;
else
if（top>0）q=stack[--top];
elseq=NULL;
}
}
voidrelease（BiTreet）{/*释放二叉树空间*/
if（t!
=NULL）{
release（t->lchild）;
release（t->rchild）;
free（t）;
}
}
intmain（）{
BiTreet=NULL;
createBiTree（&t）;
printf（"\n\nPreOrderthetreeis:
"）;
PreOrder（t）;
printf（"\n\nInOrderthetreeis:
"）;
InOrder（t）;
printf（"\n\nPostOrderthetreeis:
"）;
PostOrder（t）;
printf（"\n\n先序遍历序列（非递归）:
"）;
Preorder_n（t）;
release（t）;
return0;
}
●运行程序
输入：
ABC##DE#G##F###
运行结果：
ABCDEGF
蛇形填数
#include
//因为最先竖着赋值，而核心代码里面最初的i在变，所以i代表行。
。
intmain（）
{
inta[20][20];
inti,j,n,tot=0;
printf（"输入一个10进制数（20以内）\n"）;
scanf（"%d",&n）;
for（i=0;i<20;i++）//使每个数组元素都写上0以便赋值用作判断该元素是否已经赋过值了
{
for（j=0;j<20;j++）
{
a[i][j]=0;
}
}
j=n-1;
i=-1;//使要赋的值时a[++i][j]的位置指向右上角。
。
。
while（tot{
while（i+1a[i+1][j]）//开始竖着赋值，当下一个a[i][j]赋过值，即a[i+1][j]>0;
a[++i][j]=++tot;//或者出界时停止竖着赋值。
。
即跳出这个循环。
while（j-1>=0&&!
a[i][j-1]）//开始倒退着赋值。
。
//不过感觉这里应该是j-1>=0才对
a[i][--j]=++tot;
while（i-1>=0&&!
a[i-1][j]）
a[--i][j]=++tot;
while（j+1a[i][j+1]）
a[i][++j]=++tot;
}
for（i=0;i{
for（j=0;j{
printf（"%d",a[i][j]）;
}
printf（"\n"）;
}
return0;
}
单链表的插入删除
/*修改于2012.4.1218：
42
目的：
实现对单链表的基本操作如查找，删除，添加
*/
#include
#include
/*给char类型定义别名datatype*/
typedefchardatatype;
/*定义链表节点类型*/
typedefstructnode
{
datatypedata;
structnode*next;
}linklist;
/*函数声明部分*/
linklist*CreatList（）;
linklist*Get（linklist*,int）;
linklist*Locate（linklist*,datatype）;
voidPrintList（linklist*）;
voidInsertAfter（linklist*,datatype）;
voidInsertBefore（linklist*,int,datatype）;
voidDeleteAfter（linklist*）;
voidDeleter（linklist*,int）;
voidFreeList（linklist*）;
intmain（）
{
intpos;
datatypevalue;
printf（"*****************进入输入演示*****************\n"）;
/*测试创建链表函数*/
printf（"请输入一串字符，以0结束\n"）;
linklist*head,*p;
head=CreatList（）;
/*测试打印链表函数*/
printf（"\n你所输入的链表为：
\n"）;
PrintList（head）;
/*测试按序号查找函数*/
printf（"*****************进入查找演示*****************\n"）;
printf（"\n请输入要查找的节点序号:
\n"）;
scanf（"%d",&pos）;
getchar（）;
p=Get（head,pos）;
if（p!
=NULL）
{
printf（"%c\n",p->data）;
}
else
{
printf（"Can'tGetThisKey!
\n"）;
}
/*测试按值查找函数*/
//printf（"\n请输入要查找的值:
\n"）;
//scanf（"%c",&value）;
//p=Locate（head,value）;
//if（p!
=NULL）
//{
//printf（"%c\n",p->data）;
//}
//else
//{
//printf（"Can'tGetThisKey!
\n"）;
//}
/*测试插入节点函数*/
printf（"*****************进入插入演示*****************\n"）;
printf（"\n你想在第几个节点前插入？
\n"）;
scanf（"%d",&pos）;
getchar（）;
printf（"请输入要插入的值\n"）;
scanf（"%c",&value）;
InsertBefore（head,pos,value）;
PrintList（head）;
/*测试删除节点函数*/
printf（"*****************进入删除演示*****************\n"）;
printf（"\n你想删除第几个节点？
\n"）;
scanf（"%d",&pos）;
Deleter（head,pos）;
PrintList（head）;
/*销毁链表*/
FreeList（head）;
system（"pause"）;
return0;
}
/*带头结点后插法创建链表函数*/
linklist*CreatList（）
{
datatypekey;
/*head为头指针,s为新节点,r为尾指针*/
linklist*head,*s,*r;
head=（linklist*）malloc（sizeof（linklist））;
r=head;
key=getchar（）;
/*遇到$就停止创建*/
while（key!
='0'）
{
s=（linklist*）malloc（sizeof（linklist））;
s->data=key;
/*新节点插入表尾*/
r->next=s;
/*尾指针指向新的表尾*/
r=s;
key=getchar（）;
}
r->next=NULL;
/*返回头指针*/
returnhead;
}
/*打印链表函数*/
voidPrintList（linklist*head）
{
linklist*p;
p=head->next;
while（p!
=NULL）
{
printf（"%c",p->data）;
p=p->next;
}
printf（"\n"）;
}
/*查找链表中第i个节点*/
linklist*Get（linklist*head,inti）
{
/*j为扫描计数器*/
intj=0;
linklist*p;
/*p指向头节点*/
p=head;
/*到达表尾或序号不合法就退出循环*/
while（（p->next!
=NULL）&&（j{
p=p->next;
j++;
}
if（i==j）
{
returnp;
}
else
{
returnNULL;
}
}
/*在链表中查找值key并返回所在节点*/
linklist*Locate（linklist*head,datatypekey）
{
linklist*p;
/*p指向开始结点*/
p=head->next;
while（p!
=NULL）
{
if（p->data!
=key）
{
p=p->next;
}
else
{
break;
}
}
returnp;
}
/*在节点p后插入key*/
voidInsertAfter（linklist*p,datatypekey）
{
linklist*s;
s=（linklist*）malloc（sizeof（linklist））;
s->data=key;
/*先将s指向后一个节点，再将前一个节点指向s*/
s->next=p->next;
p->next=s;
}
/*将key插入链表第i个节点之前*/
voidInsertBefore（linklist*head,inti,datatypekey）
{
linklist*p;
intj=i-1;
/*找到第i-1个节点p*/
p=Get（head,j）;
if（p==NULL）
{
printf（"InsertError!
\n"）;
}
else
{
/*将key插入节点p之后*/
InsertAfter（p,key）;
}
}
/*删除p节点的后继节点*/
voidDeleteAfter（linklist*p）
{
linklist*r;
/*r指向要删除的节点*/
r=p->next;
/*将p直接与r下一个节点链接*/
p->next=r->next;
/*释放节点r*/
free（r）;
}
/*删除链表的第i个节点*/
voidDeleter（linklist*head,inti）
{
linklist*p;
intj=i-1;
/*找到第i-1个节点p*/
p=Get（head,j）;
if（（p!
=NULL）&&（p->next!
=NULL））
{
/*删除p的后继节点*/
DeleteAfter（p）;
}
else
{
printf（"DeleteError!
\n"）;
}
}
/*递归释放单链表*/
voidFreeList（linklist*p）
{
if（p->next!
=NULL）
{
FreeList（p->next）;
}
free（p）;
}
链表的插入
//ListInsert_L.cpp
//ThisprogramistoinsertaelementintotheLNode
#include
#include
#include
#include
#defineINIT_LENGTH10
#defineOK1
#defineERROR0
typedefstructLNode//defineLNodestructure
{intdata;
structLNode*next;
}LNode,*Linklist;
intListInsert_L（Linklist&L,inti,inte）//ListInsert_L（）sub-function
{LNode*p=L;
intj=0;
while（p&&j{p=p->next;
++j;
}
if（!
p||j>i-1）//outoflocation
{cout<<"Errer!
Thelocationisillegal!
"<return（ERROR）;
}
LNode*s;
s=（Linklist）malloc（sizeof（LNode））;//createnewLNode
s->data=e;
s->next=p->next;
p->next=s;
return（OK）;
}//ListInsert_L（）end
intmain（）//main（）function
{inti,j,e;
LNodenode[10];
LNode*L,*p;
intarray[INIT_LENGTH+1]={5,8,12,18,25,30,37,46,51,89};
L=node;
L=（Linklist）malloc（sizeof（LNode））;
L->next=NULL;
for（i=10;i>0;i--）
{p=（Linklist）malloc（sizeof（LNode））;
p->data=array[i-1];
p->next=L->next;
L->next=p;
}
p=L;
cout<cout<cout<";
for（i=0;i{p=p->next;
cout<data<<"";
}
cout<";
cin>>j;
cout<<"请输入插入的数（eg,58）:
";
cin>>e;
if（ListInsert_L（L,j,e））
{cout<";
p=L;
for（i=0;i<11;i++）
{p=p->next;
cout<data<<"";
}
}
cout<...";
getch（）;
}
升级会员 