数据结构代码.docx
《数据结构代码.docx》由会员分享，可在线阅读，更多相关《数据结构代码.docx（22页珍藏版）》请在冰豆网上搜索。
数据结构代码
数据结构代码
P20，例2-1
voidunion（List&La,ListLb）{
La_len=ListLength（La）;Lb_len=ListLength（Lb）;
for（i=1;i<=Lb_len;i++）{
GetElem（Lb,i,e）;
if（!
LocateElem（La,e,equal））
ListInsert（La,++La_len,e）;
}
}
P21,例2-2,将
voidMergeList（ListLa,ListLb,List&Lc）{
InitList（Lc）;
i=j=1;k=0;
La_len=ListLength（La）;Lb_len=ListLength（Lb）;
while（（i<=La_Len）&&（j<=Lb_len））{
GetElem（La,i,ai）;GetElem（Lb,j,bj）;
if（ai<=bj）{ListInsert（Lc,++k,ai）;++i;}
else{ListInsert（Lc,++k,bj）;++j}
}
while（i<=La_len）{
GetElem（La,i++,ai）;ListInsert（Lc,++k,ai）;
}
while（j<=Lb_len）{
GetElem（Lb,i++,bj）;ListInsert（Lc,++k,bj）;
}
}
P22,线性表的顺序存储结构
#defineLIST_INIT_SIZE100
#defineLISTINCREMENT10
typedefstruct
{
ElemType*elem;/*线性表占用的数组空间*/
intlength；
intlistsize;
}SqList；
P23,线性表顺序存储结构上的基本运算
初始化操作
StatusIniList_Sq（SqList&L）{
L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;
if（!
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））;
if（!
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=&（L.elem[i-1]）;
e=*p;
q=L.elem+L.length-1;
for（++p;p<=q;++p）*（p-1）=*p;
--L.length;
returnOK;
}
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 LNode *next;
}LNode ,*LinkList;/*LinkList为结构指针类型*/
P29,查找元素
Status GetElem_L（LinkList L,int i,ElemType&e）{
p=L->next;
j=1;
while （p&&j p=p->next;
++j;
}
if （!
p||j>i）return ERROR;
e=p->data;
return ok;
}
P29,在单链表中插入一个元素
Status ListInsert_L（LinkList &L, int i,ElmeType e ）{
p=L;j=0;
while（p&&jp=p->next;
++j;
}
if（!
p||j>i-1） return ERROR;
s=（LinkList）malloc（sizeof（LNode））;
s->data=e;
s->next=p->next;
p->next=s;
return OK;
}
P30,在单链表中删除一个元素
Status ListDelete_L（LinkList &L, int i, Elemtype &e）{
p=L;j=0;
while （p->next&&jp=p->next;
++j;
}
if （!
（p->next）||j>i-1） return ERROR ;
q=p->next;
p->next=q->next;
e=q->data;
free（q）;
return OK;
}
P30,建立单链表
void CreateList_L（LinkList &L, int n）{
L=（Linklist）malloc（sizeof（Lnode））;
L->next=NULL;
for（i=n;i>0;--i）{
p=（LinkList）malloc（sizeof（Lnode））;
scanf（&p->data）;
p->next=L->next;
L->next=p;
}
}
P31,合并单链表
void mergelist_L（LinkList &La,LinkList&Lb,LinkList &Lc）{
pa=La->next;pb=Lb->next;
Lc=pc=La;
while（pa&&pb） {
if（pa->data<=pb->data）{
pc->next=pa;pc=pa;pa=pa->next;
}
else{
pc->next=pb;pc=pb;pb=pb->next;
}
}
pc->next=pa?
pa:
pb;
free（Lb）;
}
P31,线性表的静态单链表存储结构
#define MAXSIZE 1000
typedef struct {
ElemType data;
int cur;
}component,SlinkList[MAXSIZE];
P32,定位函数
int LocateElem_SL（SlinkList s,ElemType e）{
i=s[0].cur;
while（i&&s[i].data!
=e） i=s[i].cur;
return i;
}
P33,
void IniteSpace_SL（SlinkList &space）{
for（i=0;ispace[MAXSIZE-1].cur=0;
}
int Malloc_SL（SlinkList &space）{
i=space[0].cur;
if （space[0].cur）
space[0].cur=space[i].cur;
returni;
}
P35,线性表的双链表存储结构
typedef struct DulNode{
ElemType data;
struct DulNode *prior, *next;
}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;
returnOK;
}
取栈顶元素
StatusGetTop（SqStackS,SElemType&e）{
if（S.top==S.base）returnERROR;
e=*（S.top-1）;
returnOK;
}
入栈
StatusPush（SqStack&S,SElemTypee）{
if（S.top-S.base>=S.stacksize）{
S.base=（SElemType*）realloc（S.base,
（S.stacksize+STACKINCREMENT）*sizeof（SElemType））;
if（!
S.base）exit（OVERFLOW）;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
returnOK;
}
出栈
StatusPop（SqStack&S,SelemType&e）{
if（S.top==S.base）returnERROR;
e=*--S.top;
returnOK;
}
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,链式队列的定义
＃defineTRUE1
＃defineFALSE0
typedefstructQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{
QueuePtrfront;
QueuePtrrear;
}LinkQueue;
P62,初始化
StatusInitQueue（LinkQueue&Q）
{
Q.front=Q.rear=（Queueptr）malloc（sizeof（QNode））;
if（!
Q.front）exit（OVERFLOW）;
Q.front->next=NULL;
returnOK;
}
销毁队列
StatusDestroyQueue（LinkQueue&Q）
{
while（Q.front）{
Q.rear=Q.front->next;
free（Q.front）;
Q.front=Q.rear;
}
returnOK;
}
入队操作
StatusEnQueue（LinkQueue&Q,QelemTypee）
{
p=（QueuePtr）malloc（sizeof（QNode））;
if（!
p）exit（OVERFLOW）;
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
returnOK;
}
出队操作
StatusDeQueue（LinkQueue&Q,QelemType&e）
{
if（Q.front==Q.rear）returnERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if（Q.rear==p）Q.rear=Q.front;
free（p）;
returnOK;
}
P64，循环对列定义
#defineMAXQSIZE100/*队列的最大长度*/
typedefstruct{
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;
returnOK;
}
入队操作
StatusEnQueue（SqQueue&Q,QElemTypee）{
if（（Q.rear+1）%MAXQSIZE==Q.front）returnERROR;
Q.base[Q.rear]=e;
Q.rear=（Q.rear+1）%MAXQSIZE;
returnOK;
}
）出队操作
StatusDeQueue（SqQueue&Q,QElemType&e）{
if（Q.front==Q.rear）returnERROR;
e=Q.base[Q.front];
Q.front=（Q.front+1）%MAXQSIZE;
returnOK;
}
求队列长度
intQueueLength（SqQueueQ）
{
return（Q.rear-Q.front+MAXQSIZE）%MAXQSIZE;
}
P93//------数组的顺序存储表示―――――
＃include
#defineMAX_ARRAY_DIM8
typedefstruct{
ELemType*base;//数组元素基址
intdim;//数组维数
int*bounds;//数组维数基址
int*constants;//数组映像函数常量基址
}Array;
P98,三元数组顺序表存储
#defineMAXSIZE12500
typedefstruct{
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;p<=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;
}
}
returnOK;
}//TransposeSMatrix
P100
StatusFastTransposeSMatrix（TSMatrixM,TSMatrix&T）
{//采用三元组顺序表存储表示，求稀疏矩阵M的转置矩阵T。
T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;
if（T.tu）{
for（col=1;col<＝M.nu；col++）num[col]=0;
for（t=1;t<=M.nu;++t）
++num[M.data[t].j];//求M中每一列含非零元个数。
copt[1]=1;
//求第col列中第一个非零元在b.data中的序号
for（col=2;col<=M.nu;++col）cpot[col]=cpot[col-1]+num[col-1];
for（p=1;p<=M.tu;++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））
1{
2if（T）
3{
4if（InOrderTraverse（T->lchild,Visit））
5if（Visit（T->data））
6if（InOrderTraverse（T->rchild,Visit））returnOK;
7returnERROR;
8}
9elsereturnOK;
10}
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）;
if（!
StackEmpty（S））
{
Pop（S,p）;if（!
Visit（p->data））returnERROR;
Push（S,p->rchild）;
}//if
}//While
returnOK;
}//InOrderTraverse
StatusInOrderTraverse（BiTreeT,Status（*Visit）（TelemTypee））
{
InitStack（S）;p=T;
While（p||!
StackEmpty（S））
{
if（p）{Push（S,p）;p=p->lchild;}
else{
Pop（S,p）;if（!
Visit（p->data））returnE
升级会员 