C数据结构实例代码.docx

C数据结构实例代码.docx

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

C数据结构实例代码

1线性表的顺序表示

#include"iostream"

#include"malloc.h"

usingnamespacestd;

typedefstruct{

int*elem;

intlength;

intlistsize;

}SqList;

intInit_Sq（SqList&L）{

L.elem=（int*）malloc（100*sizeof（int））;

if（!

L.elem）

exit（-2）;

L.length=0;

L.listsize=100;

return1;

}

intListInsert（SqList&L,inti,inte）{

if（i<1||i>L.length+1）

return0;

if（L.length>=L.listsize）{

int*newbase=（int*）realloc（L.elem,（L.listsize+10）*sizeof（int））;

if（!

newbase）

exit（-2）;

L.elem=newbase;

L.listsize+=10;

}

int*q=&（L.elem[i-1]）;

int*p=&（L.elem[L.length-1]）;

for（p;p>=q;--p）{

*（p+1）=*p;

}

*q=e;

++L.length;

return1;

}

intListDelete（SqList&L,inti,int&e）{

if（i<1||i>L.length）

return0;

int*p=&（L.elem[i-1]）;

e=*p;

int*q=L.elem+L.length-1;

for（++p;p<=q;++p）{

*（p-1）=*p;

}

--L.length;

returne;

}

intmain（）{

inta[6]={1,2,3,4,5};

int*q=&a[1];

int*p=&a[4];

for（p;p>=q;--p）{

*（p+1）=*p;

}

*q=3;

for（inti=0;i<6;i++）{

cout<

}

cout<

SqListlx;

Init_Sq（lx）;

for（intj=1;j<10;j++）{

ListInsert（lx,j,j）;

}

ListInsert（lx,3,55）;

inte_return;

ListDelete（lx,4,e_return）;

for（intm=0;m<10;m++）{

cout<<*（lx.elem+m）<<"";

}

cout<

cout<

system（"pause"）;

return0;

}

132345

12554567899

3请按任意键继续...

2线性表的链性表示

#include"iostream"

#include"malloc.h"

usingnamespacestd;

typedefstructLNode

{

intdata;

structLNode*next;

}LNode,*LinkList;

intInitList（LinkList&L）

{

L=（LinkList）malloc（sizeof（LNode））;

L->next=NULL;

return1;

}

intListInsert（LinkList&L,inti,inte）

{

LinkListp=L;

intj=0;

while（p&&j

p=p->next;

++j;

}

if（!

p||j>i-1）

return0;

LinkLists=（LinkList）malloc（sizeof（LNode））;

s->data=e;

s->next=p->next;

p->next=s;

return1;

}

intListDelete（LinkList&L,inti）

{

LinkListp=L;

intj=0;

while（p->next&&j

p=p->next;

++j;

}

if（!

（p->next）||j>i-1）

return0;

LinkListq=p->next;

p->next=q->next;

free（q）;

return1;

}

intGetElem（LinkListL,inti）

{

LinkListp=L->next;

intj=1;

while（p&&j

{

p=p->next;

++j;

}

if（!

p||j

return0;

inte=p->data;

returne;

}

intmain（）

{

LinkListlx;

InitList（lx）;

for（inti=1;i<6;i++）{

ListInsert（lx,i,i）;

}

ListDelete（lx,2）;

for（intj=1;j<5;j++）

{

cout<

}

cout<

LinkListlx1,lx2;

InitList（lx1）;

InitList（lx2）;

for（intm=1;m<6;m++）{

ListInsert（lx1,m,m）;

}

for（intn=1;n<6;n++）{

ListInsert（lx2,n,2*n）;

}

for（intj=1;j<6;j++）

{

cout<

}

system（"pause"）;

return0;

}

1345

12345请按任意键继续...

3双向链表

#include"iostream"

#include"malloc.h"

usingnamespacestd;

typedefstructdlist

{

intdata;

structdlist*prior;

structdlist*next;

}DList,*DLinkList;

voidInitList（DLinkList&L）

{

L=（DLinkList）malloc（sizeof（DList））;

L->next=L;

L->prior=L;

}

intListInsert（DLinkList&L,inti,inte）

{

DLinkListp,s;

p=L->next;

intj=1;

while（p&&j

p=p->next;

++j;

}

if（!

p||j>i）

return0;

s=（DLinkList）malloc（sizeof（DList））;

s->data=e;

s->prior=p->prior;

p->prior->next=s;

s->next=p;

p->prior=s;

return1;

}

intListDelete（DLinkList&L,inti,int&e）

{

DLinkListp;

p=L->next;

intj=1;

while（p&&j

p=p->next;

++j;

}

if（!

p||j>i）

return0;

e=p->data;

p->prior->next=p->next;

p->next->prior=p->prior;

free（p）;

return1;

}

intGetElem（DLinkList&L,inti）

{

DLinkListp,s;

p=L->next;

intj=1;

while（p&&j

p=p->next;

++j;

}

if（!

p||j>i）

return0;

inte=p->data;

returne;

}

intmain（）

{

DLinkListlx;

InitList（lx）;

for（inti=1;i<6;i++）

{

ListInsert（lx,i,2*i-1）;

}

for（intj=1;j<6;j++）{

cout<

}

cout<

inte;

ListDelete（lx,2,e）;

cout<

for（intj=1;j<5;j++）{

cout<

}

system（"pause"）;

return0;

}

13579

3

1579请按任意键继续...

4顺序栈

#include"iostream"

#include"malloc.h"

usingnamespacestd;

#defineSTACK_INIT_SIZE100//存ä?

储ä¡é空?

间?

初?

始º?

分¤?

配?

量¢?

#defineSTACKINCREMENT10//存ä?

储ä¡é空?

间?

分¤?

配?

增?

量¢?

typedefstruct{

int*base;

int*top;

intstacksize;

}Stack;

intInitStack（Stack&S）

{

S.base=（int*）malloc（STACK_INIT_SIZE*sizeof（int））;

if（!

S.base）

exit（-2）;

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

return1;

}

intGetTop（Stack&S,int&e）

{

if（S.top==S.base）

return0;

e=*（S.top-1）;

return1;

}

intPush（Stack&S,inte）

{

if（S.top-S.base>=S.stacksize）{

S.base=（int*）realloc（S.base,（S.stacksize+STACKINCREMENT）*sizeof（int））;

if（!

S.base）

exit（-2）;

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*S.top++=e;

}

intPop（Stack&S,int&e）

{

if（S.top==S.base）

return0;

e=*--S.top;

return1;

}

intmain（）

{

Stacklx;

InitStack（lx）;

for（inti=1;i<6;i++）

{

Push（lx,i）;

}

inte;

GetTop（lx,e）;

cout<

inte1;

Pop（lx,e1）;

cout<

GetTop（lx,e1）;

cout<

system（"pause"）;

return0;

}

5

5

4

请按任意键继续...

5队列

#include"iostream"

#include"malloc.h"

usingnamespacestd;

typedefstructQNode{

intdata;

structQNode*next;

}QNode,*QueuePtr;

typedefstruct{

QueuePtrfront;

QueuePtrrear;

}LinkQueue;

intInitQueue（LinkQueue&Q）

{

Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;

if（!

Q.front）

exit（-2）;

Q.front->next=NULL;

return1;

}

intDestroyQueue（LinkQueue&Q）

{

while（Q.front）{

Q.rear=Q.front->next;

free（Q.front）;

Q.front=Q.rear;

}

return1;

}

intInsert（LinkQueue&Q,inte）

{

QueuePtrp=（QueuePtr）malloc（sizeof（QNode））;

if（!

p）

exit（-2）;

p->data=e;

p->next=NULL;

Q.rear->next=p;

Q.rear=p;

return1;

}

intGetFront（LinkQueue&Q,int&e）

{

if（Q.front==Q.rear）

return0;

e=Q.front->next->data;

return1;

}

intGetRear（LinkQueue&Q,int&e）

{

if（Q.front==Q.rear）

return0;

e=Q.rear->data;

return1;

}

intDelete（LinkQueue&Q,int&e）

{

if（Q.front==Q.rear）

return0;

QueuePtrp;

p=Q.front->next;

e=p->data;

Q.front->next=p->next;

if（Q.rear==p）

Q.rear=Q.front;

free（p）;

return1;

}

intmain（）

{

LinkQueuelx;

InitQueue（lx）;

for（inti=1;i<6;i++）{

Insert（lx,i）;

}

intfront;

GetFront（lx,front）;

cout<

intrear;

GetRear（lx,rear）;

cout<

inte;

Delete（lx,e）;

cout<

GetFront（lx,front）;

cout<

system（"pause"）;

return0;

}

1

5

1

2

请按任意键继续...

6循环队列

#include"iostream"

#include"malloc.h"

usingnamespacestd;

#defineMAXSIZE100

typedefstruct{

int*base;

intfront;

intrear;

}SqQueue;

intInit（SqQueue&Q）

{

Q.base=（int*）malloc（MAXSIZE*sizeof（int））;

if（!

Q.base）

exit（-2）;

Q.front=Q.rear=0;

return1;

}

intQueueLength（SqQueue&Q）

{

return（Q.rear-Q.front+MAXSIZE）%MAXSIZE;

}

intEnQueue（SqQueue&Q,inte）

{

if（（Q.rear+1）%MAXSIZE==Q.front）

return0;

Q.base[Q.rear]=e;

Q.rear=（Q.rear+1）%MAXSIZE;

return1;

}

intDeQueue（SqQueue&Q,int&e）

{

if（Q.front==Q.rear）

return0;

e=Q.base[Q.front];

Q.front=（Q.front+1）%MAXSIZE;

return1;

}

intGetFront（SqQueue&Q）

{

inte=Q.base[Q.front];

returne;

}

intGetrear（SqQueue&Q）

{

inte=Q.base[Q.rear-1];

returne;

}

intmain（）

{

SqQueuelx;

Init（lx）;

for（inti=1;i<6;i++）{

EnQueue（lx,i）;

}

cout<

cout<

cout<

intm;

DeQueue（lx,m）;

cout<

cout<

system（"pause"）;

return0;

}

5

1

5

1

2

请按任意键继续...

7顺序表字符串

#include"iostream"

#include"malloc.h"

usingnamespacestd;

#defineOK1

#defineERROR0

typedefstruct{

char*ch;

intlength;

}HString;

intStrAssign（HString&T,char*chars）

{

T.ch=（char*）malloc（sizeof（char））;

if（T.ch）

free（T.ch）;

//inti=strlen（chars）;

inti=0;

char*c;

for（c=chars;*c;++i,++c）;//判D断?

条¬?

件t为a*c!

='\0'

if（!

i）{

T.ch=NULL;

T.length=0;

}

T.ch=（char*）malloc（i*sizeof（char））;

for（intj=0;j

{

T.ch[j]=chars[j];

}

T.length=i;

returnOK;0

}

intStrLength（HString&S）

{

returnS.length;

}

intConcat（HString&T,HString&S1,HString&S2）

{

T.ch=（char*）malloc（（S1.length+S2.length）*sizeof（char））;

for（inti=0;i

T.ch[i]=S1.ch[i];

}

T.length=S1.length+S2.length;

for（intj=0;j

{

T.ch[S1.length+j]=S2.ch[j];

}

returnOK;

}

intSubString（HString&Sub,HString&S,intpos,intlen）

{

if（pos<1||pos>S.length||len<0||len>S.length-pos+1）{

returnERROR;

}

Sub.length=len;

Sub.ch=（char*）malloc（len*sizeof（char））;

for（inti=0;i

Sub.ch[i]=S.ch[pos+i];

}

returnOK;

}

intPrint（HString&T）{

for（inti=0;i

{

cout<

}

cout<

returnOK;

}

intmain（）

{

HStringlx,hhc;

StrAssign（lx,"huanhuncao"）;

StrAssign（hhc,"lixing"）;

Print（lx）;

Print（hhc）;

cout<

cout<

HStringlx1;

lx1.ch=（char*）malloc（（lx.length+hhc.length）*sizeof（char））;

Concat（lx1,lx,hhc）;

Print（lx1）;

HStringlx2;

SubString（lx2,lx1,2,3）;

Print（lx2）;

system（"pause"）;

return0;

}

huanhuncao

lixing

10

6

huanhuncaolixing

anh

请按任意键继续...

8链式字符串就是线性表的链式表示一样

9数组的表示

#include"iostream"

#include"stdarg.h"//提供宏va_start

#include"malloc.h"

usingnamespacestd;

#defineMAX_ARRAY_DIM8

#defineOK1

#defineERROR0

typedefstruct

{

int*base;

intdim;

int*bounds;

int*constants;

intelemtotal;

}Array;

intInitArray（Array&A,intdim,...）

{

if（dim<1||dim>MAX_ARRAY_DIM）

returnERROR;

A.dim=dim;

cout<<"数组维数是：

"<

A.bounds=（int*）malloc（dim*sizeof（int））;

if（!

A.bounds）

exit（-2）;

intelemtotal=1;

va_listap;

va_start（