数据结构例题123.docx
《数据结构例题123.docx》由会员分享，可在线阅读，更多相关《数据结构例题123.docx（64页珍藏版）》请在冰豆网上搜索。
数据结构例题123
例一：
#include/*包含输入输出头文件*/
#include"SeqList.h"/*包含顺序表实现文件*/
voidDelElem（SeqList*A,SeqListB）;/*删除A中出现B的元素的函数声明*/
voidmain（）
{
inti,j,flag;
DataTypee;
SeqListA,B;/*声明顺序表A和B*/
InitList（&A）;/*初始化顺序表A*/
InitList（&B）;/*初始化顺序表B*/
for（i=1;i<=10;i++）/*将1-10插入到顺序表A中*/
{
if（InsertList（&A,i,i）==0）
{
printf（"位置不合法"）;
return;
}
}
for（i=1,j=1;j<=6;i=i+2,j++）/*插入顺序表B中六个数*/
{
if（InsertList（&B,j,i*2）==0）
{
printf（"位置不合法"）;
return;
}
}
printf（"顺序表A中的元素：
\n"）;
for（i=1;i<=A.length;i++）/*输出顺序表A中的每个元素*/
{
flag=GetElem（A,i,&e）;/*返回顺序表A中的每个元素到e中*/
if（flag==1）
printf（"%4d",e）;
}
printf（"\n"）;
printf（"顺序表B中的元素：
\n"）;
for（i=1;i<=B.length;i++）/*输出顺序表B中的每个元素*/
{
flag=GetElem（B,i,&e）;/*返回顺序表B中的每个元素到e中*/
if（flag==1）
printf（"%4d",e）;
}
printf（"\n"）;
printf（"将在A中出现B的元素删除后A中的元素：
\n"）;
DelElem（&A,B）;/*将在顺序表A中出现的B的元素删除*/
for（i=1;i<=A.length;i++）/*显示输出删除后A中所有元素*/
{
flag=GetElem（A,i,&e）;
if（flag==1）
printf（"%4d",e）;
}
printf（"\n"）;
}
voidDelElem（SeqList*A,SeqListB）
/*删除A中出现B的元素的函数实现*/
{
inti,flag,pos;
DataTypee;
for（i=0;i<=B.length;i++）
{
flag=GetElem（B,i,&e）;/*依次把B中每个元素取出给e*/
if（flag==1）
{
pos=LocateElem（*A,e）;/*在A中查找和B中取出的元素e相等的元素*/
if（pos>0）
DeleteList（A,pos,&e）;/*如果找到该元素，将其从A中删除*/
}
}
}
重点1：
#defineListSize100
typedefintDataType;
typedefstruct
{
DataTypelist[ListSize];
intlength;
}SeqList;
voidInitList（SeqList*L）
/*将线性表初始化为空的线性表只需要把线性表的长度length置为0*/
{
L->length=0;/*把线性表的长度置为0*/
}
intListEmpty（SeqListL）
/*判断线性表是否为空，线性表为空返回1，否则返回0*/
{
if（L.length==0）/*判断线性表的长度是否为9*/
return1;/*当线性表为空时，返回1；否则返回0*/
else
return0;
}
intGetElem（SeqListL,inti,DataType*e）
/*查找线性表中第i个元素。
查找成功将该值返回给e，并返回1表示成功；否则返回-1表示失败。
*/
{
if（i<1||i>L.length）/*在查找第i个元素之前，判断该序号是否合法*/
return-1;
*e=L.list[i-1];/*将第i个元素的值赋值给e*/
return1;
}
intLocateElem（SeqListL,DataTypee）
/*查找线性表中元素值为e的元素，查找成功将对应元素的序号返回，否则返回0表示失败。
*/
{
inti;
for（i=0;iif（L.list[i]==e）
returni+1;
return0;
}
intInsertList（SeqList*L,inti,DataTypee）
/*在顺序表的第i个位置插入元素e，插入成功返回1，如果插入位置不合法返回-1，顺序表满返回0*/
{
intj;
if（i<1||i>L->length+1）/*在插入元素前，判断插入位置是否合法*/
{
printf（"插入位置i不合法！
\n"）;
return-1;
}
elseif（L->length>=ListSize）/*在插入元素前，判断顺序表是否已经满，不能插入元素*/
{
printf（"顺序表已满，不能插入元素。
\n"）;
return0;
}
else
{
for（j=L->length;j>=i;j--）/*将第i个位置以后的元素依次后移*/
L->list[j]=L->list[j-1];
L->list[i-1]=e;/*插入元素到第i个位置*/
L->length=L->length+1;/*将顺序表长增1*/
return1;
}
}
intDeleteList（SeqList*L,inti,DataType*e）
{
intj;
if（L->length<=0）
{
printf（"顺序表已空不能进行删除!
\n"）;
return0;
}
elseif（i<1||i>L->length）
{
printf（"删除位置不合适!
\n"）;
return-1;
}
else
{
*e=L->list[i-1];
for（j=i;j<=L->length-1;j++）
L->list[j-1]=L->list[j];
L->length=L->length-1;
return1;
}
}
intListLength（SeqListL）
{
returnL.length;
}
voidClearList（SeqList*L）
{
L->length=0;
}
例二：
#include/*包含输入输出头文件*/
#defineListSize100
typedefintDataType;
typedefstruct
{
DataTypelist[ListSize];
intlength;
}SeqList;
#include"SeqList.h"/*包含顺序表实现文件*/
voidMergeList（SeqListA,SeqListB,SeqList*C）;/*合并顺序表A和B中元素的函数声明*/
voidmain（）
{
inti,flag;
DataTypea[]={6,11,11,23};
DataTypeb[]={2,10,12,12,21};
DataTypee;
SeqListA,B,C;/*声明顺序表A，B和C*/
InitList（&A）;/*初始化顺序表A*/
InitList（&B）;/*初始化顺序表B*/
InitList（&C）;/*初始化顺序表C*/
for（i=1;i<=sizeof（a）/sizeof（a[0]）;i++）/*将数组a中的元素插入到顺序表A中*/
{
if（InsertList（&A,i,a[i-1]）==0）
{
printf（"位置不合法"）;
return;
}
}
for（i=1;i<=sizeof（b）/sizeof（b[0]）;i++）/*将数组b中元素插入到顺序表B中*/
{
if（InsertList（&B,i,b[i-1]）==0）
{
printf（"位置不合法"）;
return;
}
}
printf（"顺序表A中的元素：
\n"）;
for（i=1;i<=A.length;i++）/*输出顺序表A中的每个元素*/
{
flag=GetElem（A,i,&e）;/*返回顺序表A中的每个元素到e中*/
if（flag==1）
printf（"%4d",e）;
}
printf（"\n"）;
printf（"顺序表B中的元素：
\n"）;
for（i=1;i<=B.length;i++）/*输出顺序表B中的每个元素*/
{
flag=GetElem（B,i,&e）;/*返回顺序表B中的每个元素到e中*/
if（flag==1）
printf（"%4d",e）;
}
printf（"\n"）;
printf（"将在A中出现B的元素合并后C中的元素：
\n"）;
MergeList（A,B,&C）;/*将在顺序表A和B中的元素合并*/
for（i=1;i<=C.length;i++）/*显示输出合并后C中所有元素*/
{
flag=GetElem（C,i,&e）;
if（flag==1）
printf（"%4d",e）;
}
printf（"\n"）;
}
voidMergeList（SeqListA,SeqListB,SeqList*C）
/*合并顺序表A和B的元素到C中，并保持元素非递减排序*/
{
inti,j,k;
DataTypee1,e2;
i=1;j=1;k=1;
while（i<=A.length&&j<=B.length）
{
GetElem（A,i,&e1）;/*取出顺序表A中的元素*/
GetElem（B,j,&e2）;/*取出顺序表B中的元素*/
if（e1<=e2）/*比较顺序表A和顺序表B中的元素*/
{
InsertList（C,k,e1）;/*将较小的一个插入到C中*/
i++;/*往后移动一个位置，准备比较下一个元素*/
k++;
}
else
{
InsertList（C,k,e2）;/*将较小的一个插入到C中*/
j++;/*往后移动一个位置，准备比较下一个元素*/
k++;
}
}
while（i<=A.length）/*如果A中元素还有剩余，这时B中已经没有元素*/
{
GetElem（A,i,&e1）;
InsertList（C,k,e1）;/*将A中剩余元素插入到C中*/
i++;
k++;
}
while（j<=B.length）/*如果B中元素还有剩余，这时A中已经没有元素*/
{
GetElem（B,j,&e2）;
InsertList（C,k,e2）;/*将B中剩余元素插入到C中*/
j++;
k++;
}
C->length=A.length+B.length;/*C的表长等于A和B的表长的和*/
}
重点2：
voidInitList（LinkList*head）
/*将单链表初始化为空。
动态生成一个头结点，并将头结点的指针域置为空。
*/
{
if（（*head=（LinkList）malloc（sizeof（ListNode）））==NULL）/*为头结点分配一个存储空间*/
exit（-1）;
（*head）->next=NULL;/*将单链表的头结点指针域置为空*/
}
intListEmpty（LinkListhead）
/*判断单链表是否为空，就是通过判断头结点的指针域是否为空*/
{
if（head->next==NULL）/*判断单链表头结点的指针域是否为空*/
return1;/*当单链表为空时，返回1；否则返回0*/
else
return0;
}
ListNode*Get（LinkListhead,inti）
/*查找单链表中第i个结点。
查找成功返回该结点的指针表示成功；否则返回NULL表示失败。
*/
{
ListNode*p;
intj;
if（ListEmpty（head））/*在查找第i个元素之前，判断链表是否为空*/
returnNULL;
if（i<1）/*在查找第i个元素之前，判断该序号是否合法*/
returnNULL;
j=0;
p=head;
while（p->next!
=NULL&&j{
p=p->next;
j++;
}
if（j==i）
returnp;/*找到第i个结点，返回指针p*/
else
returnNULL;/*如果没有找到第i个元素，返回NULL*/
}
ListNode*LocateElem（LinkListhead,DataTypee）
/*查找线性表中元素值为e的元素，查找成功将对应元素的结点指针返回，否则返回NULL表示失败。
*/
{
ListNode*p;
p=head->next;/*指针p指向第一个结点*/
while（p）
{
if（p->data!
=e）/*找到与e相等的元素，返回该序号*/
p=p->next;
else
break;
}
returnp;
}
intLocatePos（LinkListhead,DataTypee）
/*查找线性表中元素值为e的元素，查找成功将对应元素的序号返回，否则返回0表示失败。
*/
{
ListNode*p;
inti;
if（ListEmpty（head））/*在查找第i个元素之前，判断链表是否为空*/
return0;
p=head->next;/*指针p指向第一个结点*/
i=1;
while（p）
{
if（p->data==e）/*找到与e相等的元素，返回该序号*/
returni;
else
{
p=p->next;
i++;
}
}
if（!
p）/*如果没有找到与e相等的元素，返回0，表示失败*/
return0;
}
intInsertList（LinkListhead,inti,DataTypee）
/*在单链表中第i个位置插入一个结点，结点的元素值为e。
插入成功返回1，失败返回0*/
{
ListNode*p,*pre;/*定义指向第i个元素的前驱结点指针pre，指针p指向新生成的结点*/
intj;
pre=head;/*指针p指向头结点*/
j=0;
while（pre->next!
=NULL&&j{
pre=pre->next;
j++;
}
if（!
pre）/*如果没找到，说明插入位置错误*/
{
printf（"插入位置错"）;
return0;
}
/*新生成一个结点，并将e赋值给该结点的数据域*/
if（（p=（ListNode*）malloc（sizeof（ListNode）））==NULL）
exit（-1）;
p->data=e;
/*插入结点操作*/
p->next=pre->next;
pre->next=p;
return1;
}
intDeleteList（LinkListhead,inti,DataType*e）
/*删除单链表中的第i个位置的结点。
删除成功返回1，失败返回0*/
{
ListNode*pre,*p;
intj;
pre=head;
j=0;
while（pre->next!
=NULL&&pre->next->next!
=NULL&&j{
pre=pre->next;
j++;
}
if（j!
=i-1）/*如果没找到要删除的结点位置，说明删除位置错误*/
{
printf（"删除位置错误"）;
return0;
}
/*指针p指向单链表中的第i个结点，并将该结点的数据域值赋值给e*/
p=pre->next;
*e=p->data;
/*将前驱结点的指针域指向要删除结点的下一个结点，也就是将p指向的结点与单链表断开*/
pre->next=p->next;
free（p）;/*释放p指向的结点*/
return1;
}
intListLength（LinkListhead）
{
ListNode*p;
intcount=0;
p=head;
while（p->next!
=NULL）
{
p=p->next;
count++;
}
returncount;
}
voidDestroyList（LinkListhead）
{
ListNode*p,*q;
p=head;
while（p!
=NULL）
{
q=p;
p=p->next;
free（q）;
}
}
例三：
/*包含头文件*/
#include
#include
#include/*宏定义和单链表类型定义*/
#defineListSize100
typedefintDataType;
typedefstructNode
{
DataTypedata;
structNode*next;
}ListNode,*LinkList;
#include"LinkList.h"/*包含单链表实现文件*/
voidDelElem（LinkListA,LinkListB）;/*删除A中出现B的元素的函数声明*/
voidDelElem2（LinkListA,LinkListB）;
voidmain（）
{
inti;
DataTypea[]={2,3,6,7,9,14,56,45,65,67};
DataTypeb[]={3,4,7,11,34,54,45,67};
LinkListA,B;/*声明单链表A和B*/
ListNode*p;
InitList（&A）;/*初始化单链表A*/
InitList（&B）;/*初始化单链表B*/
for（i=1;i<=sizeof（a）/sizeof（a[0]）;i++）/*将数组a中元素插入到单链表A中*/
{
if（InsertList（A,i,a[i-1]）==0）
{
printf（"位置不合法"）;
return;
}
}
for（i=1;i<=sizeof（b）/sizeof（b[0]）;i++）/*将数组b中元素插入单链表B中*/
{
if（InsertList（B,i,b[i-1]）==0）
{
printf（"位置不合法"）;
return;
}
}
printf（"单链表A中的元素有%d个：
\n",ListLength（A））;
for（i=1;i<=ListLength（A）;i++）/*输出单链表A中的每个元素*/
{
p=Get（A,i）;/*返回单链表A中的每个结点的指针*/
if（p）
printf（"%4d",p->data）;/*输出单链表A中的每个元素*/
}
printf（"\n"）;
printf（"单链表B中的元素有%d个：
\n",ListLength（B））;
for（i=1;i<=ListLength（B）;i++）
{
p=Get（B,i）;/*返回单链表B中的每个每个结点的指针*/
if（p）
printf（"%4d",p->data）;/*输出单链表B中的每个元素*/
}
printf（"\n"）;
DelElem2（A,B）;/*将在单链表A中出现的B的元素删除，即A-B*/
printf（"将在A中出现B的元素删除后（A-B），现在A中的元素还有%d个：
\n",ListLength（A））;
for（i=1;i<=ListLength（A）;i++）
{
p=Get（A,i）;/*返回单链表A中每个结点的指针*/
if（p）
printf（"%4d",p->data）;/*显示输出删除后A中所有元素*/
}
printf（"\n"）;
}
voidDelElem（LinkListA,LinkListB）
/*删除A中出现B的元素的函数实现*/
{
inti,pos;
DataTypee;
ListNode*p;
/*在单链表B中，取出每个元素与单链表A中的元素比较，如果相等则删除A中元素对应的结点*/
for（i=1;i<=ListLength（B）;i++）
{
p=Get（B,i）;/*取出B中的每个结点，将指针返回给p*/
if（p）
{
pos=LocatePos（A,p->data）;/*比较B中的元素是否与A中的元素相等*/
if（pos>0）
DeleteList（A,pos,&e）;/*如果相等，将其从A中删除*/
}
}
}
voidDe
升级会员 