数据结构c语言入门代码.docx
《数据结构c语言入门代码.docx》由会员分享，可在线阅读，更多相关《数据结构c语言入门代码.docx（21页珍藏版）》请在冰豆网上搜索。
数据结构c语言入门代码
本文档适用于数据结构初学者,前提是你要有c语言基础。
作为刚接触编程的人,数据结构是比较蛋疼的。
有参考书但是没源代码,一样蛋疼。
这就是我这个文档存在的意义了。
数据结构就是数据的一种组织结构。
根据数据之间的关系,可以分为线性结构,树形结构和图。
具体到机器中,就是定义一种数据对内存中的一组数据进行组织,然后编写对这种数据的一系列操作接口。
以得到我们想要的数据结构。
本人比较随性,书写可能不太规范。
以下的代码可以编译运行
数据结构1:
线性表
#include
#include
#defineincrment10
#definen10
typedefcharelem;
typedefstruct
{
elem*head;
intsize;
intlenth;
}list;
intinit（list&l,ints）
{
l.head=（elem*）malloc（s*sizeof（elem））;
if（!
l.head）return-1;
l.size=s;
l.lenth=0;
}
intclear（list&l）
{
l.lenth=0;
return1;
}
intdestroy（list&l）
{
free（l.head）;
return1;
}
intempty（listl）
{
if（l.lenth）return0;
elsereturn1;
}
intgetelem（listl,inti,elem&e）
{
e=*（l.head+i-1）;
return1;
}
intlctelem（listl,eleme）
{
inti=0;
for（i;iif（*（l.head+i）==e）return1;
return0;
}
intinsert（list&l,inti,eleme）
{
intj;
l.lenth++;
if（l.lenth>l.size）
{
l.head=（elem*）realloc（l.head,（l.size+incrment）*sizeof（elem））;
}
if（!
l.head）return-1;
if（i>l.lenth||i<0）return0;
for（j=l.lenth;j>i;j--）
{
*（l.head+j-1）=*（l.head+j-2）;
}
*（l.head+i-1）=e;
}
intdlt（list&l,inti）
{
intj;
if（!
l.lenth）return-1;
l.lenth--;
if（i>l.lenth+1||i<0）return0;
for（j=i;j*（l.head+j-1）=*（l.head+j）;
return1;
}
//以上就是数据结构的定义和操作部分voidfun1（）
{
listl;
inti;
chare;
init（l,20）;
insert（l,1,'a'）;
insert（l,2,'b'）;
insert（l,3,'d'）;
for（i=1;i<=3;i++）
{
getelem（l,i,e）;
printf（"%c\n",e）;
}
printf（"\n"）;
insert（l,1,'c'）;
for（i=1;i<=4;i++）
{
getelem（l,i,e）;
printf（"%c\n",e）;
}
printf（"\n"）;
insert（l,3,'e'）;
for（i=1;i<=5;i++）
{
getelem（l,i,e）;
printf（"%c\n",e）;
}
printf（"\n"）;
if（empty（l））printf（"nowthelistisempty\n"）;
insert（l,1,'a'）;
insert（l,2,'b'）;
insert（l,3,'d'）;
for（i=1;i<=3;i++）
{
getelem（l,i,e）;
printf（"%c\n",e）;
}
printf（"\n"）;
dlt（l,1）;
for（i=1;i<=2;i++）
{
getelem（l,i,e）;
printf（"%c\n",e）;
}
printf（"\n"）;
if（lctelem（l,'b'））printf（"bisinthelist\n"）;
destroy（l）;
}
voidpr_min（listl）
{
inti;
elemmin;
min=*l.head;
for（i=1;iif（*（l.head+i）min=*（l.head+i）;
printf（"min=%d\n",min）;
}
voidmain（）
{
listl;
inti;
init（l,20）;
l.lenth=n;
for（i=0;i*（l.head+i）=i+1;
pr_min（l）;
}
数据结构2:
线性链表
#include
#include
typedefcharelem;
typedefstructnode{
elemdata;
structnode*next;
}node,*linklist;
intcreat（linklist&l）
{
l=（linklist）malloc（sizeof（node））;
l->next=NULL;
if（!
l）return0;
return1;
}
intlenth（linklistl）
{
intj=1;
linklistgetl=l;
while（getl->next）
{
getl=getl->next;
j++;
}
returnj;
}
intput（linklistl,inti,eleme）
{
intj;
linklistgetl=l;
for（j=1;jgetl=getl->next;//findtheinodeif（!
getl）return0;
getl->data=e;
return1;
}
intaddone（linklistl,linklistb）
{
linklistcur_node=l;
//findthelastnode
while（cur_node->next）
{
cur_node=cur_node->next;
}
cur_node->next=b;
b->next=NULL;
return1;
}
intinsert（linklistl,inti,linklistb）
{
intj;
linklistgetl=l;
linklistq;
for（j=1;jgetl=getl->next;//findthei-1node
q=getl->next;
getl->next=b;
b->next=q;
return1;
}
intdlt（linklistl,inti）
{
intj;
linklistgetl=l;
linklistq;
for（j=1;jgetl=getl->next;//findthei-1node
q=getl->next;//findtheinode
getl->next=q->next;
free（q）;
return1;
}
intvisit（linklistl）
{
linklistcur_node=l;
while（cur_node）
{
printf（"%c\n",cur_node->data）;
cur_node=cur_node->next;
}
return1;
voiddao_visit（linklistl）
{
linklistrcv=l;
linklistrcv2=rcv;
elem*a;
intlenth=0;
inti=0;
while（rcv）
{
lenth++;
rcv=rcv->next;
}
a=（elem*）malloc（lenth*sizeof（elem））;
while（rcv2）
{
a[i]=rcv2->data;
rcv2=rcv2->next;
i++;
}
for（i=0;iprintf（"%c\n",a[lenth-1-i]）;
}
//以上是数据结构定义,以及对它的操作voidmain（）
{
linklistft;//a
linklista;//b
linklistb;//c
linklistc;//i
//char*a;
//charb[10]="hello";
//a=b;
//printf（"%s",a）;
creat（ft）;
creat（a）;
creat（b）;
creat（c）;
put（ft,1,'a'）;
addone（ft,a）;
put（ft,2,'b'）;
addone（ft,b）;
put（ft,3,'c'）;
insert（ft,3,c）;
put（ft,3,'i'）;
dlt（ft,2）;
visit（ft）;
dao_visit（ft）;
//printf（"%d\n",lenth（ft））;
//visit（b）;
//printf（"%d\n",lenth（b））;}
数据结构3:
栈
#include"stdlib.h"
#include"stdio.h"
typedefintelmtp;
typedefstruct{
elmtp*base;
elmtp*top;
intstksize;
}stack;
intinit（stack&s,intsize）
{
s.base=（elmtp*）malloc（size*sizeof（char））;
if（!
s.base）return0;
s.top=s.base;
s.stksize=size;
return1;
}
intpush（stack&s,elmtpe）
{
*s.top=e;
s.top++;
return1;
}
intgettop（stacks,elmtp&e）
{
if（s.base==s.top）return0;
e=*（s.top-1）;
}
intpop（stack&s,elmtp&e）
{
if（s.base==s.top）return0;
e=*（s.top-1）;
s.top--;
return1;
}
//以上是。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
//下面这个main函数是将10进制数转为8进制voidmain（）
{
intn;
stacks;
init（s,10）;
scanf（"%d",&n）;
while（n）
{
push（s,n%8）;
n=n/8;
}
while（pop（s,n））
{
printf（"%d\t",n）;
}
}
数据结构4:
树
#include
#include
#defineprprintf
typedefcharelem;
inta=48;
structnode
{
structnode*parent;
structnode*lchild;
structnode*rchild;
elemdata;
};
typedefstructnode*root;
intcreat（root&r）//创建结点
{
r=（root）malloc（sizeof（node））;
if（!
r）return0;
r->parent=0;
r->lchild=0;
r->rchild=0;
r->data=a++;
return1;
}
//添加关系
voidaddparent_lchild（rootparent,rootb）{
b->parent=parent;//成员赋值
parent->lchild=b;
}
voidaddparent_rchild（rootparent,rootb）{
b->parent=parent;
parent->rchild=b;
}
//先序遍历
voidpre_traverse（rootr）
{
printf（"%c\n",r->data）;
if（r->lchild）
pre_traverse（r->lchild）;
if（r->rchild）
pre_traverse（r->rchild）;
//if（!
（r->lchild||r->rchild））
}
//以上是。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
。
voidmain（）
{
inti;
rootr[10];
creat（r[0]）;
//pr（"%c\n",r[0]->data）;
//pr（"%d\n",r[0]）;//536
//pr（"%d\n",&r[0]->parent）;//536
//pr（"%d\n",&r[0]->lchild）;//540
//pr（"%d\n",&r[0]->rchild）;//544
//pr（"%d\n",&r[0]->data）;//548random7;&r->data=r+12;
creat（r[1]）;
creat（r[2]）;
creat（r[3]）;
creat（r[4]）;
creat（r[5]）;
addparent_lchild（r[0],r[1]）;
addparent_rchild（r[0],r[2]）;
addparent_lchild（r[1],r[3]）;
addparent_rchild（r[1],r[4]）;
addparent_lchild（r[2],r[5]）;
for（i=0;i<6;i++）
pr（"%c\n",r[i]->data）;
pre_traverse（r[0]）;
}
附:
一道程序题
12345
23456
34567
45678
从1开始到8结束,可以横向和纵向移动,每次一格,问,共有多少总路径代码:
#include
#include"stdlib.h"
//#include
#defineincrement10
typedefstruct{
intx;
inty;
}posion;
typedefstruct{
intid;
intde;
//posioncur;
}array;
typedefstruct{
posioncur_p;
arraycur_a;
}elem;
typedefstruct{
elem*base;
elem*top;
intstksize;
}stack;
//staticintx=0,y=0;
intinit（stack&s,intsize）
{
s.base=（elem*）malloc（size*sizeof（elem））;
if（!
s.base）exit（0）;
s.top=s.base;
s.stksize=size;
return1;
}
elemgettop（stacks）
{
//if（s.top==s.base）return;
return*（s.top-1）;
}
intempty（stacks）
{
if（s.top==s.base）return0;
elsereturn1;
}
intpush（stack&s,eleme）
{
if（s.top-s.base>=s.stksize）
{
s.base=（elem*）realloc（s.base,（s.stksize+increment）*sizeof（elem））;
}
if（!
s.base）exit（0）;
*s.top=e;
s.top++;
return1;
}
intpop（stack&s）
{
if（s.top==s.base）return0;
//e=*（s.top-1）;
s.top--;
return1;
}
voidmain（）
{
arraya[5][6];
inti=0,j=0;
stacks;
intcount=0;
elemcur_e;
//initposition
posionnow={0,0};
//inita[5][6]
for（i=0;i<4;i++）
for（j=0;j<5;j++）
{
a[i][j].id=i+j+1;
a[i][j].de=0;
}
for（i=0;i<4;i++）
{
a[i][5].id=0;
a[i][5].de=0;
}
for（j=0;j<6;j++）
{
a[4][j].id=0;
a[4][j].de=0;
}
//initstack
init（s,30）;
//for（i=0;i<5;i++）
//{
//for（j=0;j<6;j++）
//printf（"%d",a[i][j].de）;
//printf（"\n"）;
//}
//i=j=0;/*
cur_e.cur_p=now;
cur_e.cur_a=a[now.x][now.y];
push（s,cur_e）;
while（empty（s））
{
switch（gettop（s）.cur_a.id）
{
case8:
count++;pop（s）;
if（a[gettop（s）.cur_p.x][gettop（s）.cur_p.y].de==1）now.y--;
elsenow.x--;
break;
case0:
pop（s）;
if（a[gettop（s）.cur_p.x][gettop（s）.cur_p.y].de==1）now.y--;
elsenow.x--;
break;
default:
if（a[now.x][now.y].de==0）
{
a[now.x][now.y].de++;
now.y++;
//gettop（s）.de+=1;
//x++;
cur_e.cur_p=now;
cur_e.cur_a=a[now.x][now.y];
push（s,cur_e）;
}
elseif（a[now.x][now.y].de==1）
{
a[now.x][now.y].de++;
now.x++;
//gettop（s）.de+=1;
cur_e.cur_p=now;
cur_e.cur_a=a[now.x][now.y];
push（s,cur_e）;
}
else
{
a[now.x][now.y].de=0;
pop（s）;
if（empty（s））
{
if（a[gettop（s）.cur_p.x][gettop（s）.cur_p.y].de==1）now.y--;
elsenow.x--;
}
break;
}
break;
}
}
printf（"%d\n",count）;
}
喜欢的话,多下几次,给好评吧
升级会员 