数据结构第二章.docx
《数据结构第二章.docx》由会员分享，可在线阅读，更多相关《数据结构第二章.docx（12页珍藏版）》请在冰豆网上搜索。
数据结构第二章
第二章
一、求AUB（即A与B的并集）。
Voidunion（Linear_listLA,linear_listLB）
{//假定linear_List是线型表类型
N=ListLength（LA）;//求表的表长
For（i=1;i<=ListLength（LB）;i++）（
X=GetNode（LB,i）;//取LB中第i个元素赋给x
If（LocateNode（LA,x）==0）//若没有找到
InsertList（LA,++n,x）;
}
二、删除线性表L中重复的元素。
Voidpurge（Linear_ListL）
{i=1;
While（i<=Listlength（L））{
X=GetNode（L,i）;j=i+1;
While（j<=ListLength（l））{
Y=GetNode（L,j）;
If（x==y）//表示x与y内容相同
DeleteList（L,j）;
Else
J++;
}
i++;
}
三、定义顺序表
#defineListSize100//定义表空间为100
TypedefintDataType;//datatype类型为int
Typedefstruct{
Datatypedata（listSize）;//数组data用来存放表结点
Intlength;//线性表的表长
}seqlist;
四、顺序表插入算法
VoidInsertlist（SeqList*L,intI,DataTypex）
{//在顺序表L中第i个位置之前插入一个新元素a
Intj;
If（i<1||i>i->length+1）（
Printf（“positionerror”）;
Return;
}
If（L->length>=ListSize）（
Printf（“overfloew”）;
Return;
For（j=L->length-1;j>=i-1;j--）
L->data（j+1）=l->data[j]//从最后一个元系开始后移
L->data[i-1]=x;//插入新元素x，i-1个元素实际为第i个元素
L->Length++;//表长度加1
五、顺序表L中删除第i个元素
DataTypeDeletelist（Seqlist*L,inti）
{//顺序表L中删除第i个元素，并返回被删除元素
Intj;
DataTypex;//DataType是一个通用标识符，在使用时再定义实际类型
If（i<1||i>L->length）
Printf（“positionerror”）;
Exit（0）;
}
X=L->data[i];//保存被删除元素
For（j=1;j<=L->Length-1;j++）
L->data[j-1]=L-data[j];//元素前移
L->length--;//实际表长减1
Returnx;//返回被删除的元素
六、将顺序线性表，将该线性表逆置
SeqListConverts[SeqListL]
{DataTypex;
K=l.length/2;
For（i=0;iX=L.data[i];
L.data[i]=L.data[L.length-i-1];
L.data[L.length-i-1]=x;
}
ReturnL;
七、找到最大值及最小值及位置
VoidMaxMin（SeqListL,DataType*max,DataType*min,int*k,int*j）
{inti;
*max=L.data[0];*min=L.data[0];
*k=*j=1;//先假设第一个元素就是最大值，也是最小值
For（i=1;i<=L.length;i++）
If（L.data[i]>*.max）{
*max=L.data[i];*k=i;
}
Whileif（L.data[i]<*min）{
*min=L.data[i];*j=i;
}
七、链式存储（头插法）
LinklistCreaateListF（0
LinkListhead;
ListNode*p;
Charch;
Head=NULL;//置空单链表
Ch=getchar（）;读入第一个字符
While（ch!
=’\n’）{
P=（ListNode*）malloc（sizef（listNode））;//申请新节点
p->data=ch;//数据域赋值
p->next=head;//指针域赋值
head=p;//头指针指向新节点
ch=getchar（）;//读入下一个字符
}
Returnhead;//返回链表头指针
八、尾插法
LinkListCreatelistR（）
{LinkListhead,rear;
ListNode*p;
Charch;
Head=NULL;rear=NULL;//置空单链表
Ch=getchar（）;//读入第一个字符
While（ch!
=’\n’）{
P=（ListNode*）malloc（sizeof（ListNode））;//申请新结点
p->data=ch;//读入数据赋值
if（head==NULL）head=p;//新结点*P插入空表
elserear->next=p;//新结点*p插入到非空结点
rear=p;//尾指针指向新表尾
ch=getchar（）;
if（rear!
=NULL）rear->next=NULL;//终端结点域置空
returnhead;
}
另引入头结点后，尾插法可简化为：
p->data=ch;
r=next=p;//新结点连接到尾结点之后
r=p;//尾指针指向新结点
九、带头结点单链表的查找算法
ListNode*GetNode（LinkListhead,inti）
//head为带头结点的单链表头指针，i为要查找的序号
//若查找成功，则返回查找结点存储地址，否则返回NULL
ListNode*p;intj;
p-head->next;j=1;//使p指向第一个结点，j置1
while（p!
=NULL&&jp=p->next;++j;
}
If（j==i）
ReturnP;
Else
ReturnNULL;
按值查找：
ListNode*locatenodek（Linklisthead,DataTypek）
//head为带头结点单链表的头指针，k要查找的结点的值
ListNode*p=head->next;
While（p&&p-data!
=k）
P=p->next;
Returnp;
在P结点之后插入新结点*S
VoidinsertList（LinkListhead,intI,DataTypex）
//在以head为头指针的带头结点的单链表中第i个结点位置插入一个x新结点
ListNode*p,*s;intj;
P=head;j=0;
While（p!
=NULL&&jP=p->next;++j;
}
If（p==NULL）{
Printf”（error\n”）;return;
}
Else{
S=（ListNode*）malloc（sizef（ListNode））;
S->data=x;s->next=p->next;
P->next=s;
}
删除操作：
s=p->next;
p->next=s->next;
x=s->data;
free（s）;returnx;
十、单链表A分解马A和B，其中头结点分别为a和b，使得A中为奇数元素，B中为偶数元素。
VoidsPlit（LinkLista,linkListb）
{//按序号奇偶分解单链表，注意b在调用前是一个带头结点的空链表
ListNode*p,*r,*r;
P=a->next;//p指向表头结点
R=a;//r指向表A的当前结点
S=b;//s指向表B的当前结点
While（p!
=NULL）{
r->next=p;//把序号为奇数的结点链接到A表上
r=p;//r总是指向A表的最后一个结点
p=next;
if（p）{
s->next=p;//序号为偶数的结点链接到B表上
s=p;//s总是指向B表的最后一个结点
p=next;//P指向原链表A中的偶数序号的结点
}
r->next=s->next=NULL;
十二、将La和Lb单链表（带头结点），两个单链表都是按数值递增有序的，将这两个表合并成为一个有序表Lc。
LinkListMergeList（LinkListla,LinklistLb）
{//归并两个有序表la和lb为有序表lc
ListNode*pa,*pb,*pc;LinkListLc;
Pa=La->next;pb=Lb->next;//pa,pb分别指向两个链表开始结点
Lc=pc=La;//用La的头结点做为Lc的头结点
While（pa!
=NULL&&pb!
=NULL）{
If（pa->data<=pb->data）{
Pc->next=pa;pc=pa;pa=pa->next;//将pa指向结点指向pc
}
Else{
Pc->next=pb;pc=pb;pb=pb->next;//将pb指向结点指向pc
}
Pc->next=pa!
=NULL?
pa:
pb;/插入剩余部分，哪个不空，就插哪个
Free（Lb）;//释放lb头结点
ReturnLc;//返回合并后的表
十三、从大到小顺序排列的头结点指针为L的非空单循环链表，插入一个结点并保持有序。
Voidinsertlist（LinkListL,intx）
{//将值为x的新结点插入到有序循环表中适当位置
listNode*s,*p,*q;
s=（ListNOde*）malloc（sizeof（ListNode））;//申请结点存储空间
s->data=x;p=L;
q=p->next;//q指向开始结点
while（q->data>x&&q!
=L）{
p=->next;//p指向q的前趋
q=p->next;//q指向当前节点
}
p-next=s;//插入*s结点
s->next=q;
}
十四、在双负链表*P之前插入一结点
VoidDLInsert（Dlnode*p,DataTypex）
{//将值为x的新结噗插入到带头结点的双向链表的*P之前
DLNode*s=（DLNOde*）malloc（sizeof（DLNode））;
s->data=x;
s-prior=prior;s->next=p;
p->prior->next=s;p->prior=s;
}
双向链表删除结点：
DataTypeDLDelete（DlNode*P）
p->prior->next=p->next;
p->next->prior=p->prior;
x=p->data;
free（p）;
returnx;
十五、将一个头结点指针为head的循环链表，写一算法，将其修改为真正的双向循环链表
Voidtrans（Dlinklisthead）
{
Dlnode*p;
P=head;//使p指向头结点
While（p->next!
=head）{
p->next->prior=p;//p指结点的直接后继的前趋就是p
p=p->next;//p指向下一个结点
}
Head->prior=p;//head的前趋指向表的终端结点
两个顺序表A和B，都递增有序，从A中删除与B相同的元素。
带头结点的单链表，将P指向结点与后继结点位置交换。
已知两个集合A，B，递增有序，设计A与B的交集。
设带头结点的双向循环链表，head为头指针，在x之前插入一个值为y的结点
升级会员 