数据结构总结.docx

资源描述

数据结构总结.docx

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

数据结构总结.docx

数据结构总结

实验内容与步骤：

实现顺序表初始化、插入、删除算法，代码如下：

#include

#defineMaxSize100

typedefcharElemType;

typedefstruct{

ElemType*elem;

intlength;

}SqList;

intInitList_Sq（SqList&L）{

L.elem=（ElemType*）malloc（MaxSize*sizeof（ElemType））;

if（!

L.elem）return0;

L.length=0;

return1;

}

intListInsert_Sq（SqList&L,inti,ElemTypee）{

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

ElemType*p;

ElemType*q=&L.elem[i-1];

for（p=&L.elem[L.length-1];p>=q;--p）

*（p+1）=*p;

*q=e;

++L.length;

return1;

}

intListDelete_Sq（SqList&L,inti,ElemType&e）{

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

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

e=*p;

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

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

*（p-1）=*p;

--L.length;

return1;

}

voidDisp_Sq（SqListL）{

if（L.length==0）printf（"此顺序表为空表！

\n"）;

for（inti=0;i

printf（"%c",L.elem[i]）;

printf（"\n"）;

}

voidmain（）{

ElemTypee;

SqListL;

InitList_Sq（L）;

Disp_Sq（L）;

ListInsert_Sq（L,1,'A'）;

ListInsert_Sq（L,2,'B'）;

ListInsert_Sq（L,1,'C'）;

Disp_Sq（L）;

ListDelete_Sq（L,1,e）;

Disp_Sq（L）;

printf（"删除的元素是：

%c\n",e）;

}

实验指导与数据处理：

实验结果：

此顺序表为空表！

ABC

删除的元素是：

实验内容与步骤：

实现循环队列初始化、入队、出队、求队列长度算法，代码如下：

#include

#defineMAXQSIZE5

typedefcharQElemType;

typedefstruct{

QElemType*base;

intfront;

intrear;

}SqQueue;

intInitQueue（SqQueue&Q）{

Q.base=（QElemType*）malloc（MAXQSIZE*sizeof（QElemType））;

if（!

Q.base）return0;

Q.front=Q.rear=0;

return1;

}

intQueueLength（SqQueueQ）{

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

}

intEnQueue（SqQueue&Q,QElemTypee）{

if（（Q.rear+1）%MAXQSIZE==Q.front）{

printf（"队列为满队列！

！

\n"）;

return0;}

Q.base[Q.rear]=e;

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

return1;

}

intDeQueue（SqQueue&Q,QElemType&e）{

if（Q.front==Q.rear）return0;

e=Q.base[Q.front];

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

return1;

}

voidDispQueue（SqQueueQ）{

intm,i;

m=QueueLength（Q）;

if（m==0）printf（"该队列为空队列！

！

\n"）;

for（i=Q.front;i%MAXQSIZE!

=Q.rear;i++）

printf（"%c",Q.base[i%MAXQSIZE]）;

printf（"\n"）;

}

voidmain（）{

SqQueueQ;

QElemTypee;

InitQueue（Q）;

DispQueue（Q）;

EnQueue（Q,'A'）;

EnQueue（Q,'B'）;

EnQueue（Q,'C'）;

EnQueue（Q,'D'）;

printf（"队列长度为：

"）;

printf（"%d\n",QueueLength（Q））;

printf（"队列为:

"）;

DispQueue（Q）;

DeQueue（Q,e）;

printf（"队列长度为：

"）;

printf（"%d\n",QueueLength（Q））;

printf（"队列为:

"）;

DispQueue（Q）;

EnQueue（Q,'E'）;

printf（"队列长度为：

"）;

printf（"%d\n",QueueLength（Q））;

printf（"队列为:

"）;

DispQueue（Q）;

EnQueue（Q,'F'）;

printf（"队列为:

"）;

DispQueue（Q）;

}

实验指导与数据处理：

实验结果：

该队列为空队列！

！

队列长度为：

队列为:

ABCD

队列长度为：

队列为:

BCD

队列长度为：

队列为:

BCDE

队列为满队列！

！

队列为:

BCDE

实验内容与步骤：

实现顺序栈初始化、入栈、出栈、取栈顶元素算法，代码如下：

#include

#defineSTACK_INIT_SIZE100

#defineSTACKINCREMENT10

typedefcharSElemType;

typedefstruct

{

SElemType*base;

SElemType*top;

intstacksize;

}SqStack;

intInitStack（SqStack&S）

{

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

if（!

S.base）return0;

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

return1;

}

intGetTop（SqStackS,SElemType&e）

{

if（S.top==S.base）return0;

e=*（S.top-1）;

return1;

}

intPush（SqStack&S,SElemTypee）

{

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

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

if（!

S.base）return0;

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

S.stacksize+=STACKINCREMENT;

}

*S.top++=e;

return1;

}

intPop（SqStack&S,SElemType&e）

{

if（S.top==S.base）return0;

e=*--S.top;

return1;

}

voidDispStack（SqStackS）//从栈顶到栈底输出元素

{

inti;

if（S.top==S.base）printf（"空栈！

"）;

for（i=S.top-S.base;i>0;i--）

printf（"%c",S.base[i-1]）;

printf（"\n"）;

}

voidmain（）

{

SElemTypee;

SqStackS;

InitStack（S）;

Push（S,'A'）;

Push（S,'B'）;

Push（S,'C'）;

Push（S,'D'）;

printf（"栈S为：

"）;

DispStack（S）;

GetTop（S,e）;

printf（"栈顶元素是：

"）;

printf（"%c\n",e）;

Pop（S,e）;

printf（"栈S为：

"）;

DispStack（S）;

}

实验指导与数据处理：

实验结果：

栈S为：

DCBA

栈顶元素是：

栈S为：

CBA

实验内容与步骤：

掌握将一个链表删除得元素插入到另一个链表的算法。

实现创建链表La,Lb，利用链表La和Lb构建一个新的链表Lc,使得链表Lc中包含属于La但不属于Lb中的元素算法，代码如下：

#include

typedefcharElemType;

typedefstructLNode{

ElemTypedata;

structLNode*next;

}LNode,*LinkList;

//链表的初始化

intInitList_L（LinkList&L）{

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

L->next=NULL;

return1;

}

//链表插入

intListInsert（LinkList&L,inti,ElemTypee）{

LinkListp;

p=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_L（LinkList&L,inti,ElemType&e）{

LinkListp;

p=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;

e=q->data;

free（q）;

return1;

}

//链表显示

voidDisp_L（LinkListL）{

LinkListp=L->next;

if（!

p）printf（"此链表为空！

"）;

while（p）{

printf（"%c",p->data）;

p=p->next;

}

printf（"\n"）;

}

//假设利用两个单链表LA和LB分别表示两个集合A和B，现要求一个新的集合C=A-B，即两个集合的差。

voidsample（LinkListLa,LinkListLb,LinkList&Lc）

{LinkListpa,pb,r,s;

pa=La->next;

Lc=（LinkList）malloc（sizeof（LNode））;//生成新链表Lc的头结点

Lc->next=NULL;

r=Lc;

while（pa）

{

pb=Lb->next;

while（pb&&pb->data!

=pa->data）//查看La中当前结点数据是否存在于Lb中

pb=pb->next;

if（pb==NULL）{//若La中当前结点数据不存在于Lb中，则将其复制到Lc新节点中

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

s->next=NULL;

s->data=pa->data;

r->next=s;

r=s;

}

pa=pa->next;

}

voidmain（）{

LinkListLA,LB;

InitList_L（LA）;

ListInsert（LA,1,'A'）;

ListInsert（LA,2,'B'）;

ListInsert（LA,3,'C'）;

ListInsert（LA,4,'D'）;

ListInsert（LA,5,'D'）;

ListInsert（LA,6,'F'）;

ListInsert（LA,7,'B'）;

ListInsert（LA,8,'H'）;

Disp_L（LA）;

InitList_L（LB）;

ListInsert（LB,1,'1'）;

ListInsert（LB,2,'B'）;

ListInsert（LB,3,'D'）;

Disp_L（LB）;

sample（LA,LB,LC）;

printf（"\nsample后：

\n"）;

Disp_L（LA）;

Disp_L（LB）;

Disp_L（LC）;

getchar（）;

}

实验内容与步骤：

掌握将一个链表拆分成两个链表的算法。

将创建的链表La分解成La、Lb两个链表，La链表里的数据为奇数，Lb链表里的数据为偶数，除Lb的头结点之外不开辟新的存储空间并进行显示的操作，代码如下：

#include

typedefintElemType;

typedefstructLNode{

ElemTypedata;

structLNode*next;

}LNode,*LinkList;

//链表的初始化

intInitList_L（LinkList&L）{

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

L->next=NULL;

return1;

}

//链表插入

intListInsert（LinkList&L,inti,ElemTypee）{

LinkListp;

p=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_L（LinkList&L,inti,ElemType&e）{

LinkListp;

p=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;

e=q->data;

free（q）;

return1;

}

//链表显示

voidDisp_L（LinkListL）{

LinkListp=L->next;

if（!

p）printf（"此链表为空！

"）;

while（p）{

printf（"%d",p->data）;

p=p->next;

}

printf（"\n"）;

}

//将带头结点的链表LA分解成LA、LB两个链表，

//LA为数据域为奇数的结点，LB为数据域为偶数的结点，要求原地工作

voidsample（LinkList&La,LinkList&Lb）

{LinkListp,q,r;

Lb=（LinkList）malloc（sizeof（LNode））;//生成Lb链表新头结点

r=Lb;

p=La;

while（p->next）

{q=p->next;

if（q->data%2）p=p->next;//La中当前结点为奇数，继续处理下一个结点

else{p->next=q->next;r->next=q;r=q;}//La中当前结点为偶数，删除，插入Lb链尾

}

r->next=NULL;

}

voidmain（）{

LinkListLA,LB;

InitList_L（LA）;

ListInsert（LA,1,3）;

ListInsert（LA,2,4）;

ListInsert（LA,3,6）;

ListInsert（LA,4,7）;

ListInsert（LA,5,12）;

ListInsert（LA,6,13）;

ListInsert（LA,7,15）;

ListInsert（LA,8,8）;

Disp_L（LA）;

sample（LA,LB）;

printf（"\nsample后：

\n"）;

Disp_L（LA）;

Disp_L（LB）;

}

实验内容与步骤：

实现链表初始化、插入、删除算法，代码如下：

#include

typedefcharElemType;

typedefstructLNode{

ElemTypedata;

structLNode*next;

}LNode,*LinkList;

intInitList_L（LinkList&L）{

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

L->next=NULL;

return1;

}

intListInsert（LinkList&L,inti,ElemTypee）{

LinkListp;

p=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_L（LinkList&L,inti,ElemType&e）{

LinkListp;

p=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;

e=q->data;

free（q）;

return1;

}

voidDisp_L（LinkListL）{

LinkListp=L->next;

if（!

p）printf（"此链表为空！

"）;

while（p）{

printf（"%c",p->data）;

p=p->next;

}

printf（"\n"）;

}

voidmain（）{

LinkListL;

ElemTypee;

InitList_L（L）;

Disp_L（L）;

ListInsert（L,1,'A'）;

ListInsert（L,2,'B'）;

ListInsert（L,3,'C'）;

ListInsert（L,1,'X'）;

Disp_L（L）;

ListDelete_L（L,2,e）;

printf（"删除的元素是：

%c\n",e）;

Disp_L（L）;

}

实验指导与数据处理：

实验结果：

此链表为空！

XABC

删除的元素是：

XBC

实验内容与步骤：

掌握将一个链表删除得元素插入到另一个链表的算法。

要求完成链表的创建，实现将链表中删除的第i个元素起共k个元素插入到另一个链表的第j个元素之前算法，代码如下：

#include

typedefcharElemType;

typedefstructLNode{

ElemTypedata;

structLNode*next;

}LNode,*LinkList;

//链表的初始化

intInitList_L（LinkList&L）{

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

L->next=NULL;

return1;

}

//链表插入

intListInsert（LinkList&L,inti,ElemTypee）{

LinkListp;

p=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_L（LinkList&L,inti,ElemType&e）{

LinkListp;

p=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;

e=q->data;

free（q）;

return1;

}

//链表显示

voidDisp_L（LinkListL）{

LinkL

展开阅读全文