数据结构之线性表Word下载.docx
《数据结构之线性表Word下载.docx》由会员分享，可在线阅读，更多相关《数据结构之线性表Word下载.docx（20页珍藏版）》请在冰豆网上搜索。
StatusInitList_Sq（SqList&
L）
{//构造一个空的线性表
L.elem=（ElemType*）
malloc（LIST_INIT_SIZE*sizeof（ElemType））;
if（!
L.elem）return（OVERFLOW）;
//存储分配失败
L.length=0;
//空表长度为0
L.listsize=LIST_INIT_SIZE;
//初始存储容量
returnOK;
}
按值查找：
找x在表中的位置，若查找成功，返回表项的位置，否则返回-1
intFind（SqList&
L,ElemTypex）{
inti=0;
while（i<
L.length&
L.elem[i]!
=x）
i++;
if（i<
L.length）returni;
elsereturn-1;
判断x是否在表中
intIsIn（SqList&
L,ElemTypex）
{inti=0,found=0;
!
found）
if（L.elem[i]!
=x）i++;
elsefound=1;
returnfound;
求表的长度
intLength（SqList&
L）{
returnL.length;
提取函数：
在表中提取第i个元素的值
ElemTypeGetData（SqList&
L,inti）{
if（i>
=0&
i<
L.length）
returnL.elem[i];
elseprintf（“参数i不合理！
\n”）;
▪按值查找：
寻找x的后继
intNext（SqList&
inti=Find（x）;
=0&
L.length-1）returni+1;
elsereturn-1;
▪寻找x的前驱
0&
L.length）returni-1;
▪顺序表的插入
intInsert（SqList&
L,ElemTypex,inti）{
//在表中第i个位置插入新元素x
if（i<
0||i>
L.length||L.length==ListSize）
return0;
//插入不成功
else{
for（intj=L.length;
j>
i;
j--）
L.elem[j]=L.elem[j-1];
L.elem[i]=x;
L.length++;
return1;
//插入成功
▪顺序表的删除
intDelete（SqList&
//在表中删除已有元素x
inti=Find（L,x）;
//在表中查找x
=0）{
L.length--;
for（intj=i;
j<
L.length;
j++）
L.elem[j]=L.elem[j+1];
return1;
//成功删除
//表中没有x
顺序表的应用:
集合的“并”运算
voidUnion（SqList&
A,SqList&
B）{
intn=Length（A）;
intm=Length（B）;
for（inti=0;
m;
i++）{
intx=GetData（B,i）;
//在B中取一元素
intk=Find（A,x）;
//在A中查找它
if（k==-1）//若未找到插入它
{Insert（A,x,n）;
n++;
集合的“交”运算
voidIntersection（SeqList&
A,SeqList&
n）{
intx=GetData（A,i）;
//在A中取一元素
intk=Find（B,x）;
//在B中查找它
if（k==-1）{Delete（A,i）;
n--;
elsei++;
//未找到在A中删除它
单链表的类型定义
typedefcharElemType;
typedefstructLNode{//链表结点
ElemTypedata;
//结点数据域
structLNode*next;
//结点链域
}LNode,*LinkList;
LinkListhead;
//链表头指针
算法描述
StatusListInsert（LinkList&
L,inti,ElemTypee）{
//在链表l的第i个结点处插入新元素x
ListNode*p=L;
j=0;
while（p!
=NULL&
i-1）
{p=p->
next;
j++;
}//找第i-1个结点
if（p==NULL||j>
i-1）{
printf（“无效的插入位置!
//终止插入
ListNode*s=//创建新结点
（ListNode*）malloc（sizeof（ListNode））;
s->
data=x;
if（i==1）{//插入空表或非空表第一个结点之前
next=L;
//新结点成为第一个结点
L=s;
else{//插在表中间或末尾
s->
next=p->
p->
next=s;
在单链表中删除ai结点
q=p->
p->
next=q->
StatusListDelete（LinkList&
L,inti,ElemType&
e）{
//在链表中删除第i个元素，并由e返回其值
ListNode*p,*q;
if（i==1）//删除表中第1个结点
{q=L;
L=L->
next;
p=L;
intj=0;
i-1）
}//找第i-1个结点
if（p->
next==NULL||j>
i-1）{//找不到第i-1个结点
printf（“无效的删除位置!
else{//删除中间结点或尾结点元素
q=p->
p->
link=q->
e=q->
data;
free（q）;
//取出被删结点数据并释放q
带表头结点的单链表
•表头结点位于表的最前端，本身不带数据，仅标志表头。
•设置表头结点的目的:
简化链表操作的实现。
插入
q->
p->
next=q;
intInsertList_L（LinkList&
//将新元素x插入在链表中第i号结点位置
ListNode*p=Locate（L,i-1）;
if（p==NULL）return0;
//参数i值不合理返回0
ListNode*s=//创建新结点
（ListNode*）malloc（sizeof（ListNode））;
//链入
intDeleteList_L（LinkList&
//将链表第i号元素删去
ListNode*p,*q
p=Locate（L,i-1）;
//寻找第i-1个结点
if（p==NULL||p->
next==NULL）
//i值不合理或空表
q=p->
//删除结点
//释放
前插法建立单链表
从一个空表开始，重复读入数据：
生成新结点
将读入数据存放到新结点的数据域中
将该新结点插入到链表的前端
直到读入结束符为止。
voidcreateListH_L（LinkList&
L）{
//逆序输入若干元素的值，建立带表头结点的单链线性表L.
//建立表头结点
L=（LinkList）malloc（sizeof（ListNode））;
L->
next=NULL;
charch;
LinkListq;
while（（ch=getchar（））!
=‘\n’）{
q=（listNode*）malloc（sizeof（ListNode））;
q->
data=ch;
//建立新结点
next=head->
//插入到表前端
后插法建立单链表
▪每次将新结点加在链表的表尾；
尾指针r,总是指向表中最后一个结点，新结点插在它的后面；
VoidcreateListR_L（LinkList&
L=//建立表头结点
（LinkList）malloc（sizeof（ListNode））;
ListNode*q,*r=L;
r->
r=q;
//插入到表末端
}
单链表清空
VoidEmptyList_L（LinkListL）{
//删去链表中除表头结点外的所有其它结点
ListNode*q;
while（L->
next!
=NULL）{//当链不空时，循环逐个删去所有结点
q=L->
free（q）;
//释放
计算单链表长度
intLength_L（LinkListL）{
ListNode*p=L->
//指针p指示第一个结点
intcount=0;
=NULL）{//逐个结点检测
count++;
p=p->
}
returncount;
按值查找
ListNode*Find（LinkListL,ElemTypevalue）{
//在链表中从头搜索其数据值为value的结点
ListNode*p=L->
data!
=value）
returnp;
按序号查找（定位）
ListNode*Locate（LinkListL,inti）{
//返回表中第i个元素的地址
0）returnNULL;
intk=0;
k<
i）
k++;
}//找第i个结点
if（k==i）returnp;
//返回第i个结点地址
elsereturnNULL;
静态链表
▪定义
constintMaxSize=100;
//静态链表大小
typedefintListData;
typedefstructnode{//静态链表结点
ListDatadata;
intlink;
}SNode;
typedefstruct{//静态链表
SNodeNodes[MaxSize];
intnewptr;
//当前可分配空间首地址
}SLinkList;
链表空间初始化
voidInitList（SLinkListSL）{
SL.Nodes[0].link=1;
SL.newptr=1;
//当前可分配空间从1开始
//建立带表头结点的空链表
for（inti=1;
MaxSize-1;
i++）
SL.Nodes[i].link=i+1;
//构成空闲链接表
SL.Nodes[MaxSize-1].link=-1;
//链表收尾
在静态链表中查找具有给定值的结点
intFind（SLinkListSL,ListDatax）{
intp=SL.Nodes[0].link;
//指针p指向链表第一个结点
while（p!
=-1）//逐个查找有给定值的结点
if（SL.Nodes[p].data!
=x）
p=SL.Nodes[p].link;
elsebreak;
returnp;
在静态链表中查找第i个结点
intLocate（SLinkListSL,inti）{
0）return-1;
//参数不合理
intj=0,p=SL.Nodes[0].link;
=-1&
i）{//循环查找第i号结点
p=SL.Nodes[p].link;
if（i==0）return0;
在静态链表第i个结点处插入一个新结点
intInsert（SLinkListSL,inti,ListDatax）{
intp=Locate（SL,i-1）;
if（p==-1）return0;
//找不到结点
intq=SL.newptr;
//分配结点
SL.newptr=SL.Nodes[SL.newptr].link;
SL.Nodes[q].data=x;
SL.Nodes[q].link=SL.Nodes[p].link;
SL.Nodes[p].link=q;
//插入
在静态链表中释放第i个结点
intRemove（SLinkListSL,inti）{
//找不到结点
intq=SL.Nodes[p].link;
//第i号结点
SL.Nodes[p].link=SL.Nodes[q].link;
SL.Nodes[q].link=SL.newptr;
//释放
SL.newptr=q;
循环链表（CircularList）
循环链表的插入
约瑟夫问题的解法
#include<
iostream.h>
TypedefstructCircleNode{
intindex;
structCircleNode*next;
}CircleNode,*CircList;
CircleListclist=NULL;
voidJosephus（intn,intm）{
for（inti=0;
n-1;
i++）{//执行n-1次
for（intj=1;
j<
m-1;
j++）clist=clist->
next;
printf（“Deleteperson:
%d”,clist->
next->
data）;
//数m-1个人
q=clist->
clist->
next=clist->
//删去
free（q）;
clist=clist->
voidmain（）{
intn,m;
printf（“EntertheNumberofContestants?
”）;
scanf（“%d,%d”,&
n,&
m）;
CircleListr=NULL;
for（inti=1;
=n;
i++）//形成约瑟夫环
{CircleLists=（CircleNode*）
malloc（sizeof（CircleNode））;
data=i;
if（r==NULL）{clist=s;
next=s;
r=s;
else{r->
next=clist;
Josephus（n,m）;
//解决约瑟夫问题
多项式及其相加
•在多项式的链表表示中每个结点增加了一个数据成员link，作为链接指针。
•
•优点是：
–多项式的项数可以动态地增长，不存在存储溢出问题。
–插入、删除方便，不移动元素。
多项式链表的相加
AH=1-10x6+2x8+7x14
BH=-x4+10x6-3x10+8x14+4x18
Polynomialoperator+（constPolynomial
&
ah,constPolynomial&
bh）{
Term*pa,*pb,*pc,*p;
ListIterator<
Element>
Aiter（ah.poly）;
Biter（bh.poly）;
//建立两个多项式对象Aiter、Biter
pa=pc=Aiter.First（）;
//pa检测指针
pb=Biter.First（）;
//pb检测指针
pa=Aiter.Next（）;
pb=Biter.Next（）;
//pa,pb越过表头结点
deletepb;
while（Aiter.NotNull（）&
Biter.NotNull（））
switch（compare（pa→exp,pb→exp））{
case'
='
:
pa→coef=pa→coef+pb→coef;
p=pb;
pb=Biter.Next（）;
deletep;
if（!
pa→coef）{
p=pa;
}
else{
pc→link=pa;
pc=pa;
}
break;
<
'
pc→next=pb;
pc=pb;
pb=Biter.Next（）;
break;
case'
>
pc→next=pa;
pa=Aiter.Next（）;
if（Aiter.NotNull（））pc→next=pa;
elsepc→next=pb;
双向链表（DoublyLinkedList）
双向循环链表的定义
typedefstructdnode{
升级会员 