数据结构代码Word文档下载推荐.docx
《数据结构代码Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《数据结构代码Word文档下载推荐.docx（22页珍藏版）》请在冰点文库上搜索。
intlistsize;
}SqList；
P23,线性表顺序存储结构上的基本运算
初始化操作
StatusIniList_Sq（SqList&
L）{
L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;
L.elem）exit（OVERFLOW）;
L.length=0;
L.listsize=LIST_INIT_SIZE;
returnOK;
P24,在顺序表里插入一个元素
StatusListInsert_sq（SqList&
L,inti,ElemTypee）{
if（i<
1||i>
=L.length+1）returnERROR;
if（L.length>
=L.listsize）{
newbase=（ElemType*）realloc（L.elem,
（L.listsize+LISTINCREMENT）*sizeof（ElemType））;
newbase）exit（OVERFLOW）;
L.elem=newbase;
L.listsize+=LISTINCREMENT;
q=&
（L.elem[i-1]）;
for（p=&
（L.elem[L.length-1]））;
p>
=q;
--p）*（p+1）=*p;
*q=e;
++L.length;
returnOK；
P24,在顺序表里删除一个元素
StatusListDelete_Sq（SqList&
L,inti,ElemType&
e）{
if（（i<
1）||（i>
L.length））returnERROR;
p=&
e=*p;
q=L.elem+L.length-1;
for（++p;
p<
++p）*（p-1）=*p;
--L.length;
P25,在顺序表里查找一个元素
intLocatElem_Sq（SqListL,ElemTypee,
Status（*compare）（ElemType,ElemType））{
i=1;
p=L.elem;
while（i<
=L.length&
!
（*compare）（*p++,e））
++i;
if（i<
=L.length）returni;
elsereturn0;
P26,顺序表的合并
voidMergeList_Sq（SqListLa,SqListLb,SqList&
Lc）{
pa=La.elem;
pb=Lb.elem;
Lc.listsize=Lc.length=La.length+Lb.length;
pc=Lc.elem=（ElemType*）malloc（Lc.listsize*sizeof（ElemTpe））;
if（!
Lc.elem）exit（OVERFLOW）;
pa_last=La.elem+La.length-1;
pb_last=Lb.elem+Lb.length-1;
while（pa<
=pa_last&
pb<
=pb_last）{
if（*pa<
=*pb）*pc++=*pa++;
else*pc++=*pb++;
while（pa<
=pa_last）*pc++=*pa++;
while（pb<
=pb_last）*pc++=*pb++;
P28,线性表的单链表存储结构
Typedef
struct
LNode
{
ElemType
data;
struct
*next;
}LNode
*LinkList;
/*LinkList为结构指针类型*/
P29,查找元素
Status
GetElem_L（LinkList
L,int
i,ElemType&
p=L->
next;
j=1;
while
（p&
j<
i）{
p=p->
++j;
if
（!
p||j>
i）return
ERROR;
e=p->
return
ok;
P29,在单链表中插入一个元素
ListInsert_L（LinkList
L,
int
i,ElmeType
e
）{
p=L;
j=0;
while（p&
i-1）{
p=p->
++j;
if（!
i-1）
return
s=（LinkList）malloc（sizeof（LNode））;
s->
data=e;
s->
next=p->
p->
next=s;
OK;
P30,在单链表中删除一个元素
ListDelete_L（LinkList
i,
Elemtype
（p->
next&
i-1）{
++j;
（p->
next）||j>
ERROR
;
q=p->
p->
next=q->
e=q->
free（q）;
P30,建立单链表
void
CreateList_L（LinkList
n）{
L=（Linklist）malloc（sizeof（Lnode））;
L->
next=NULL;
for（i=n;
i>
0;
--i）{
p=（LinkList）malloc（sizeof（Lnode））;
scanf（&
p->
data）;
next=L->
L->
next=p;
P31,合并单链表
mergelist_L（LinkList
La,LinkList&
Lb,LinkList
pa=La->
pb=Lb->
Lc=pc=La;
while（pa&
pb）
if（pa->
data<
=pb->
data）{
pc->
next=pa;
pc=pa;
pa=pa->
}
else{
pc->
next=pb;
pc=pb;
pb=pb->
pc->
next=pa?
pa:
pb;
free（Lb）;
P31,线性表的静态单链表存储结构
#define
MAXSIZE
1000
typedef
int
cur;
}component,SlinkList[MAXSIZE];
P32,定位函数
LocateElem_SL（SlinkList
s,ElemType
i=s[0].cur;
while（i&
s[i].data!
=e）
i=s[i].cur;
i;
P33,
IniteSpace_SL（SlinkList
space）{
for（i=0;
i<
MAXSIZE-1;
++i）space[i].cur=i+1;
space[MAXSIZE-1].cur=0;
Malloc_SL（SlinkList
i=space[0].cur;
（space[0].cur）
space[0].cur=space[i].cur;
returni;
P35,线性表的双链表存储结构
DulNode{
DulNode
*prior,
}DulNode,*DuLinklist;
P46,栈的顺序存储
＃defineTRUE1
＃defineFALSE0
typedefstruct{
SElemType*base;
SElemType*top;
intstacksize;
//栈可使用的最大容量
}SqStack;
P47，栈的初始化
StatusInitStack（SqStack&
S）{
S.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;
if（!
S.base）exit（OVERFLOW）;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
取栈顶元素
StatusGetTop（SqStackS,SElemType&
if（S.top==S.base）returnERROR;
e=*（S.top-1）;
入栈
StatusPush（SqStack&
S,SElemTypee）{
if（S.top-S.base>
=S.stacksize）{
S.base=（SElemType*）realloc（S.base,
（S.stacksize+STACKINCREMENT）*sizeof（SElemType））;
S.base）exit（OVERFLOW）;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
*S.top++=e;
出栈
StatusPop（SqStack&
S,SelemType&
if（S.top==S.base）returnERROR;
e=*--S.top;
P48,转换为8进制
voidconversion（）
InitStack（S）;
scanf（“%d”,&
N）;
while（N）
{
Push（s,N%8）;
N=N/8;
while（!
StackEmpty（s））{
Pop（S,e）;
printf（“%d”,e）;
P55,移动圆盘
voidhanoi（intn,charx,chary,charz）/*将塔座X上按直径由小到大且至上而下编号为1至n的n个圆盘按规则搬到塔座Z上，Y可用作辅助塔座*/
{
if（n==1）
move（x,1,z）;
/*将编号为1的圆盘从X移动Z*/
else{
hanoi（n-1,x,z,y）;
/*将X上编号为1至n-1的圆盘移到Y,Z作辅助塔*/
move（x,n,z）;
/*将编号为n的圆盘从X移到Z*/
hanoi（n-1,y,x,z）;
/*将Y上编号为1至n-1的圆盘移动到Z，X作辅助塔*/
}
}
P61,链式队列的定义
typedefstructQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{
QueuePtrfront;
QueuePtrrear;
}LinkQueue;
P62,初始化
StatusInitQueue（LinkQueue&
Q）
Q.front=Q.rear=（Queueptr）malloc（sizeof（QNode））;
Q.front）exit（OVERFLOW）;
Q.front->
next=NULL;
销毁队列
StatusDestroyQueue（LinkQueue&
while（Q.front）{
Q.rear=Q.front->
free（Q.front）;
Q.front=Q.rear;
入队操作
StatusEnQueue（LinkQueue&
Q,QelemTypee）
p=（QueuePtr）malloc（sizeof（QNode））;
p）exit（OVERFLOW）;
data=e;
Q.rear->
next=p;
Q.rear=p;
出队操作
StatusDeQueue（LinkQueue&
Q,QelemType&
e）
if（Q.front==Q.rear）returnERROR;
p=Q.front->
Q.front->
next=p->
if（Q.rear==p）Q.rear=Q.front;
free（p）;
P64，循环对列定义
#defineMAXQSIZE100/*队列的最大长度*/
QElemType*base;
/*队列的元素空间*/
intfront;
/*头指针指示器*
intrear;
/*尾指针指示器*/
}SqQueue;
初始化操作
StatusInitQueue（SqQueue&
Q）{
Q.base=（QElemType*）malloc（MAXQSIZE*sizeof（QElemType））;
if（!
Q.base）exit（OVERFLOW）;
Q.front=Q.rear=0;
StatusEnQueue（SqQueue&
Q,QElemTypee）{
if（（Q.rear+1）%MAXQSIZE==Q.front）returnERROR;
Q.base[Q.rear]=e;
Q.rear=（Q.rear+1）%MAXQSIZE;
）出队操作
StatusDeQueue（SqQueue&
Q,QElemType&
e）{
if（Q.front==Q.rear）returnERROR;
e=Q.base[Q.front];
Q.front=（Q.front+1）%MAXQSIZE;
求队列长度
intQueueLength（SqQueueQ）
return（Q.rear-Q.front+MAXQSIZE）%MAXQSIZE;
P93//------数组的顺序存储表示―――――
＃include<
string.h>
#defineMAX_ARRAY_DIM8
ELemType*base;
//数组元素基址
intdim;
//数组维数
int*bounds;
//数组维数基址
int*constants;
//数组映像函数常量基址
}Array;
P98,三元数组顺序表存储
#defineMAXSIZE12500
inti,j;
ElemTypee;
}Triple;
typedefunion{
Tripledata[MAXSIZE+1];
intmu,nu,tu;
}TSMatrix;
P99，矩阵转置
StatusTransposeSMatrix（TSMatrixM,TSMatrix&
T）{
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if（T.tu）{
q=1;
for（col=1;
col<
=M.nu;
++col）
for（p=1;
=M.tu;
++p）
if（M.data[p].j==col）{
T.data[q].i=M.data[p].j;
T.data[q].j=M.data[p].i;
T.data[q].e=M.data[p].e;
++q;
}//TransposeSMatrix
P100
StatusFastTransposeSMatrix（TSMatrixM,TSMatrix&
T）
{//采用三元组顺序表存储表示，求稀疏矩阵M的转置矩阵T。
if（T.tu）{
for（col=1;
col<
＝M.nu；
col++）num[col]=0;
for（t=1;
t<
++t）
++num[M.data[t].j];
//求M中每一列含非零元个数。
copt[1]=1;
//求第col列中第一个非零元在b.data中的序号
for（col=2;
++col）cpot[col]=cpot[col-1]+num[col-1];
for（p=1;
++p）{
col=M.data[p].j;
q=cpot[col];
T.data[q].i=M.data[p].j;
T.data[q].j=M.data[p].i;
T.data[q].e=M.data[p].e;
++cpot[col];
}//for
}//if
returnok;
}//FastTranposeSMatrix;
P129,先序遍历
StatusPreOrderTraverse（BitreeT,Status（*Visit）（TelemTypee））
1{
2if（T）
3{
4if（Visit（T->
data））
5if（PreOrderTraverse（T->
lchild,Visit））
6if（PreOrderTraverse（T->
rchild,Visit））returnOK;
7returnERROR;
8}
9elsereturnOK;
10}
中序遍历
StatusInOrderTraverse（BitreeT,Status（*Visit）（TelemTypee））
4if（InOrderTraverse（T->
lchild,Visit））
5if（Visit（T->
6if（InOrderTraverse（T->
P131,中序遍历二叉树
StatusInOrderTraverse（BiTreeT,Status（*Visit）（TelemTypee））
InitStack（S）;
Push（S,T）;
While（!
StackEmpty（S））
while（GetTop（S,p）&
p）Push（S,p->
lchild）;
Pop（S,p）;
Visit（p->
data））returnERROR;
Push（S,p->
rchild）;
}//if
}//While
}//InOrderTraverse
StatusInOrderTraverse（BiTreeT,Status（*Visit）（TelemTypee））
p=T;
While（p||!
if（p）{Push（S,p）;
lchild;
else{
data））returnE
升级会员 