数据结构算法举例.docx
《数据结构算法举例.docx》由会员分享，可在线阅读，更多相关《数据结构算法举例.docx（34页珍藏版）》请在冰豆网上搜索。
数据结构算法举例
一、顺序表的算法
1、使用结构描述顺序表
#defineListSize100//假定表容量为100
typedefintDataType;//DataType代表的类型为int型
typedefstruct{
DataTypedata[ListSize];//数组data用于存放表结点
intlength;//当前表的长度（结点数）
}SeqList;
1、顺序表的初始化
voidinitList（SeqList*L）
{//将当前表L的表长L->length置为0
L->length=0;
}
2、求顺序表的长度
intLengthList（SeqList*L）
{//返回顺序表L的表长L->length
returnL->length;
}
3、取表元
DataTypeGetList（SeqList*L,inti）
{//返回顺序表L的第i个结点的值L->data[i-1]
returnL->data[i-1];
}
4、顺序表插入操作
voidInsertList（SeqList*L,DataTypet,inti）
{//将t插入顺序表L的第i个结点的位置上
intj;
if（i<1||i>L->length+1）
{puts（"插入位置错"）;exit（0）;}
if（L->length>=ListSize）
{puts（"表满不能插入"）;exit（0）;}
else
{
for（j=L->length-1;j>=i-1;j--）
L->data[j+1]=L->data[j];//结点依次后移
L->data[i-1]=t;//插入t
L->length++;//表长加1
}
}
5、顺序表删除操作
voidDeleteList（SeqList*L,inti）
{//从顺序表L中删除第i个结点
intj;
if（i<1||i>L->length）
{puts（"删除位置错"）;exit（0）;}
if（L->length==0）
{puts（"空表不能删除"）;exit（0）;}
else
{for（j=i;j<=L->length-1;j++）
L->data[j-1]=L->data[j];//结点依次前移
L->length--;//表长减1
}
}
6、顺序表按值查找
intSearchList（SeqList*L,DataTypet）
{
//从顺序表L中查找值为t的结点，找到返回位置值i，否则返回-1
inti=1;
while（i<=L->length&&L->data[i-1]!
=t）
i++;
if（L->data[i-1]==t）
returni;
else
return-1;
}
二、链表的算法举例
0、（链表）结点的描述
typedefcharDataType;//定义结点的数据域类型
typedefstructnode{
//结点类型定义
DataTypedata;//结点数据域
structnode*next;//结点指针域
}ListNode;//结构体类型标识符
typedefListNode*LinkList;
ListNode*p;//定义一个指向结点的指针
LinkListhead;//定义指向链表的头指针
2、节点的申请和释放
p=（ListNode*）malloc（sizeof（ListNode））;//申请节点
free（p）;//释放节点
2、头插法建单链表算法的实现
LinkListCreatListF（void）
{//返回单链表的头指针
DataTypech;
LinkListhead;//头指针
ListNode*s;//工作指针
head=NULL;//链表开始为空
printf（"请输入链表各结点的数据:
\n"）;
while（（ch=getchar（））!
='\n'）
{
s=（ListNode*）malloc（sizeof（ListNode））;
s->data=ch;
s->next=head;
head=s;
}
returnhead;
}
3、尾插法建单链表算法的实现
LinkListCreatListR（void）
{//返回单链表的头指针
DataTypech;
LinkListhead;//头指针
ListNode*s,*r;//工作指针
head=NULL;//链表开始为空
r=NULL;//尾指针初值为空
while（（ch=getchar（））!
='\n'）
{
s=（ListNode*）malloc（sizeof（ListNode））;
s->data=ch;
if（head==NULL）head=s;//新结点插入空表
elser->next=s;//将新结点插到链表尾
r=s;//尾指针指向新表尾
}
if（r!
=NULL）
r->next=NULL;
returnhead;
}
4、尾插法建立带头结点的单链表算法的实现
LinkListCreatListRH（void）
{//用尾插法建立带头结点的单链表
DataTypech;
LinkListhead;
ListNode*s,*r;//工作指针
head=（ListNode*）malloc（sizeof（ListNode））;
r=head;//尾指针初值也指向头结点
printf（"请输入链表各结点的数据（字符型）:
\n"）;
while（（ch=getchar（））!
='\n'）{
s=（ListNode*）malloc（sizeof（ListNode））;
s->data=ch;
r->next=s;//将新结点插到链表尾
r=s;//尾指针指向新表尾
}
r->next=NULL;
returnhead;
}
5、求带头结点的单链表表长算法实现
intLengthListH（LinkListhead）
{//求带头结点的单链表的表长
ListNode*p=head;//p指向头结点
intj=0;
while（p->next）{
p=p->next;//使p指向下一个结点
j++;
}
returnj;
}
6、求不带头结点的单链表表长算法实现
intLengthList（LinkListhead）
{//求不带头结点的单链表的表长
ListNode*p=head;//p指向开始结点
intj;
if（p==NULL）//处理空表
return0;
j=1;//处理非空表
while（p->next）{
p=p->next;//使p指向下一结点
j++;
}
returnj;
}
7、按序号在带头结点的单链表中查找算法实现
ListNode*GetNode（LinkListhead,inti）
{//在带头结点的单链表head中查找第i个结点，若找到（0≤i≤n），则返回该结点的存储地址，否则返回NULL。
intj=0;
ListNode*p=head;//从头结点开始扫描
while（p->next!
=NULL&&jp=p->next;
j++;
}
if（i==j）
returnp;//找到了第i个结点
elsereturnNULL;
}
8、按值在带头结点的单链表中查找算法实现
ListNode*LocateNode（LinkListhead,DataTypekey）
{//在带头结点的单链表head中查找其值为key的结点
ListNode*p=head->next;
while（p&&p->data!
=key）//p等价于p!
=NULL
p=p->next;
returnp;
}
9、带头结点单链表的插入算法实现
voidInsertList（LinkListhead,DataTypex,inti）
{//将值为x的新结点插入到带头结点的单链表head的第i个结点的位置上
ListNode*p,*s;
p=GetNode（head,i-1）;//寻找第i-1个结点
if（p==NULL）
{printf（"未找到第%d个结点",i-1）;exit（0）;}
s=（ListNode*）malloc（sizeof（ListNode））;
s->data=x;
s->next=p->next;
p->next=s;
}
10、带头结点单链表的删除算法实现
voidDeleteList（LinkListhead,inti）
{//删除带头结点的单链表head上的第i个结点
ListNode*p,*r;
p=GetNode（head,i-1）;//找到第i-1个结点
if（p==NULL||p->next==NULL）
{printf（"未找到第%d个结点",i-1）;exit（0）;}
r=p->next;//使r指向被删除的结点ai
p->next=r->next;//将ai从链上摘下
free（r）;//释放结点ai的空间
}
11、双向链表的描述：
typedefcharDataType;//定义结点的数据域类型
typedefstructdlistnode
{//结点类型定义
DataTypedata;//结点的数据域
structdlistnode*prior,*next;//结点的指针域
}DListNode;//结构体类型标识符
typedefDListNode*DLinkList;//定义新指针类型
DListNode*p,*s;//定义工作指针
DLinkListhead;//定义头指针
12、双向链表的前插操作算法
voidDInsertBefore（DListNode*p,DataTypex）
{
DListNode*s=malloc（sizeof（DListNode））;
s->data=x;
s->prior=p->prior;
s->next=p;
p->prior->next=s;
p->prior=s;
}
13、双向链表的当前结点的删除操作算法
voidDDeleteNode（DListNode*p）
{
p->prior->next=p->next;
p->next->prior=p->prior;
free（p）;
}
14、顺序表的划分算法：
voidPart（SeqList*L）
{
inti,j;
DataTypex,y;//存放基准和当前小于基准的结点
x=L->data[0];//将基准置入x中
for（i=1;ilength;i++）
if（L->data[i]{
y=L->data[i];//将当前小于基准的置入y
for（j=i-1;j>=0;j--）
L->data[j+1]=L->data[j];
L->data[0]=y;
}
}
15、顺序表的合并算法：
voidMerge（SeqListA,SeqListB,SeqList*C）
{
inti,j,k;
i=0;j=0;k=0;
while（iif（A.data[i]C->data[k++]=A.data[i++];
else
C->data[k++]=B.data[j++];
while（iC->data[k++]=A.data[i++];
while（jC->data[k++]=B.data[j++];
C->length=k;
}
三、栈的算法举例
0、顺序栈的描述
#defineStackSize100//假定栈空间最多为100个元素
typedefcharDataType;//假定栈元素的类型为字符类型
typedefstruct{
DataTypedata[StackSize];//栈元素定义
inttop;//栈指针定义
}SeqStack;
SeqStack*S;//栈定义
1、置栈空
voidInitStack（SeqStack*S）
{//将顺序栈置空
S->top=-1;
}
1、判栈空
intStackEmpty（SeqStack*S）
{
returnS->top==-1;
}
3、判栈满
intStackFull（SeqStack*S）
{
returnS->top==StackSize-1;
}
4、进栈
voidPush（SeqStack*S，DataTypex）
{
if（StackFull（S））
{puts（"栈满"）;exit（0）;}//栈满时，退出程序运行
S->data[++S->top]=x;//栈顶指针加1后将x入栈
}
5、退栈
DataTypePop（SeqStack*S）
{
if（StackEmpty（S））
{puts（"栈空"）;exit（0）;}//栈空时，退出程序运行
returnS->data[S->top--];//返回栈顶元素并将栈顶指针减1
}
6、取栈顶元素
DataTypeStackTop（SeqStack*S）
{
if（StackEmpty（S））
{puts（"栈空"）;exit（0）;}
returnS->data[S->top];
}
7、链栈的描述
typedefcharDataType;//假定栈元素类型为字符型
typedefstructstacknode{ DataTypedata;
structstacknode*next;
}StackNode;
typedefstruct{//栈的描述
StackNode*top; //栈顶指针
}LinkStack;
8、置链栈空
voidInitStack（LinkStack*S）
{//将链栈置空
S->top=NULL;
}
9、判链栈空
intStackEmpty（LinkStack*S）
{
returnS->top==NULL;
}
10、进链栈
voidPush（LinkStack*S，DataTypex）
{//将元素x插入链栈头部
StackNode*p=
（StackNode*）malloc（sizeof（StackNode））;
p->data=x;
p->next=S->top;//将新结点*p插入链栈头部
S->top=p;//栈顶指针指向新结点
}
11、退链栈
DataTypePop（LinkStack*S）
{
DataTypex;
StackNode*p=S->top;//保存栈顶指针
if（StackEmpty（S））
{puts（“栈空”）;exit（0）;}//下溢，退出运行
x=p->data; //保存栈顶结点数据
S->top=p->next; //将栈顶结点从链上摘下
free（p）;
returnx;
}
12、取链栈栈顶顶元素
DataTypeStackTop（LinkStack*S）
{
if（StackEmpty（S））
{puts（“栈空”）;exit（0）;}
returnS->top->data;
}
四、队列的算法举例
1、循环队列的描述
#defineQueueSize100 //定义队列最大容量
typedefcharDataType; //定义队列元素类型
typedefstructcirqueue
{
DataTypedata[QueueSize];//队列元素定义
intfront; //头指针定义
intrear; //尾指针定义
intcount;//计数器定义
}CirQueue;
2、置队空
voidInitQueue（CirQueue*Q）
{
Q->front=Q->rear=0;
Q->count=0; //计数器置0
}
3、判队空
intQueueEmpty（CirQueue*Q）
{
returnQ->count==0; //队列无元素为空
}
4、判队满
intQueueFull（CirQueue*Q）
{
returnQ->count==QueueSize;
//队中元素个数等于QueueSize时队满
}
5、入队
voidEnQueue（CirQueue*Q,DataTypex）
{
if（QueueFull（Q））
{puts（“队满”）;exit（0）;} //队满上溢
Q->count++; //队列元素个数加1
Q->data[Q->rear]=x; //新元素插入队尾
Q->rear=（Q->rear+1）%QueueSize; //循环意义下将尾指针加1
}
6、出队
DataTypeDeQueue（CirQueue*Q）
{
DataTypetemp;
if（QueueEmpty（Q））
{puts（“队空”）;exit（0）;} //队空下溢
temp=Q->data[Q->front];
Q->count--; //队列元素个数减1
Q->front=（Q->front+1）%QueueSize; //循环意义下的头指针加1
returntemp;
}
7、取队头元素
DataTypeQueueFront（CirQueue*Q）
{
if（QueueEmpty（Q））
{puts（“队空”）;exit（0）;}
returnQ->data[Q->front];
}
8、链队列的描述
typedefstructqueuenode
{//队列中结点的类型
DataTypedata;
structqueuenode*next;
}QueueNode;
typedefstruct
{
QueueNode*front; //队头指针
QueueNode*rear; //队尾指针
}LinkQueue;
9、链队列置空
voidInitQueue（LinkQueue*Q）
{
Q->front=Q->rear=NULL;
}
10、链队列判队空
intQueueEmpty（LinkQueue*Q）
{
returnQ->front==NULL&&Q->rear==NULL;
//实际上只须判断队头指针是否为空即可
}
11、链队列入队
voidEnQueue（LinkQueue*Q,DataTypex）
{//将元素x插入链队列尾部
QueueNode*p;
p=（QueueNode*）malloc（sizeof（QueueNode））;
p->data=x; p->next=NULL;
if（QueueEmpty（Q））
Q->front=Q->rear=p; //将x插入空队列
else{//x插入非空队列的尾
Q->rear->next=p; //*p链到原队尾结点后
Q->rear=p; //队尾指针指向新的尾
}
}
12、链队列出队
DataTypeDeQueue（LinkQueue*Q）
{
DataTypex;
QueueNode*p;
if（QueueEmpty（Q））
{puts（“队空”）;exit（0）;}
p=Q->front; //指向队头结点
x=p->data; //保存队头结点的数据
Q->front=p->next; //将对头结点从链上摘下
if（Q->rear==p）//原队中只有一个结点，删去后队列变空，此时队头指针已为空
Q->rear=NULL;
free（p）; //释放被删队头结点
returnx; //返回原队头数据
}
13、取队头元素
DataTypeQueueFront（LinkQueue*Q）
{
if（QueueEmpty（Q））
{puts（“队空”）;exit（0）;}
returnQ->front->data;
}
五、树的算法举例
1、二叉树顺序存储结构的描述
#defineMAXSIZE50//设置二叉树的最大结点数
typedefcharDataType;//定义结点类型
typedefstruct
{//定义二叉树结构
DataTypebt[MAXSIZE];//存放二叉树的结点
intnum;//存放二叉树的结点数
}SeqBT;
2、结点的类型说明
typedefcharDataType;//定义结点数据域类型
typedefstructnode
{//定义结点结构
DataTypedata；
structnode*lchild，*rchild；//左右孩子指针
}Bin
升级会员 