第二章 线性表Word文档下载推荐.docx

第二章 线性表Word文档下载推荐.docx

《第二章 线性表Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《第二章 线性表Word文档下载推荐.docx（17页珍藏版）》请在冰豆网上搜索。

voidInitList（SeqList&

L）{

L.data=（ListData*）malloc

（ListSize*sizeof（ListData））;

if（L.data==NULL）{

printf（“存储分配失败!

\n”）;

exit

（1）;

}

L.length=0;

L.size=ListSize;

▪按值查找：

找x在表中的位置，若查找成功，返回表项的位置，否则返回-1

intFind（SeqList&

L,ListDatax）{

inti=0;

while（i<

L.length&

&

L.data[i]!

=x）

i++;

if（i<

L.length）returni;

elsereturn-1;

▪插入

顺序表插入时，平均数据移动次数在各表项

插入概率相等时n/2

▪顺序表的插入

intInsert（SeqList&

L,ListDatax,inti）

{//在表中第i个元素前插入新元素x

if（i<

1||i>

L.length＋1）return0;

//插入不成功

if（L.length>

=L.size）

{newbase=（ListData*）realloc（L.data,（L.size+ListSize）*sizeof（ListData））;

if（newbase==NULL）exit（0）;

L.size=L.size+ListSize;

L.data=newbase;

for（intj=L.length;

j>

i-1;

j--）

L.data[j]=L.data[j-1];

L.data[i-1]=x;

L.length++;

return1;

//插入成功

}

▪删除

顺序表删除平均数据移动次数在各表项

删除概率相等时（n-1）/2

▪顺序表的删除

intdeleteList（Seqlist&

L，inti,typedata&

e）

{intj;

if（i<

1||i>

L.length）

{printf（“Positionerror”）;

return-1;

e=L.data[i-1];

for（j=i;

j<

=L.length-1;

j++）

L.data[j-1]=L.data[j];

L.length--;

⏹求表的长度

intLength（SeqList&

returnL.length;

⏹提取函数：

在表中提取第i个元素的值

ListDataGetData（SeqListL,inti）

{

if（i>

=1&

i<

=L.length）

returnL.data[i-1];

else{printf（“参数i不合理！

exit（0）;

}

顺序表的应用:

集合的“并”运算

voidUnion（SeqList&

A,SeqListB）{

intn=Length（A）;

intm=Length（B）;

for（inti=1;

=m;

i++）{

intx=GetData（B,i）;

//在B中取一元素

intk=Find（A,x）;

//在A中查找它

if（k==-1）//若未找到插入它

{Insert（A,x,n）;

n++;

▪集合的“交”运算

voidIntersection（SeqList&

inti=1;

=n）

{intx=GetData（A,i）;

//在A中取一元素

intk=Find（B,x）;

//在B中查找它

if（k==-1）

{Delete（A,i）;

n--;

}//未找到在A中删除它

elsei++;

顺序表的优、缺点：

优点：

（1）无须为表示结点间的逻辑关系而增加额外的存储空间。

（2）可以方便地随机存储表中的任一结点。

缺点：

（1）插入和删除平均须移动一半结点。

（2）存储分配只能预先进行（静态）

过大浪费过小溢出

链表（nextedList）

链表是线性表的链接存储表示

▪单链表

▪静态链表

▪循环链表

▪双向链表

单链表（SinglynextedList）

用一组地址任意的存储单元存放线性表中的数据元素。

链表的特点：

链表中结点的逻辑次序和物理次序不一定相同。

即：

逻辑上相邻未必在物理上相邻。

结点之间的相对位置由链表中的指针域指示，而结点在存储器中的存储位置是随意的。

每个元素由结点（Node）构成,它包括两个

域:

数据域Data和指针域next

说明：

p---指向链表中某一结点的指针。

*p---表示由指针p所指向的结点。

（*p）.data或p->

data----表示由p所指向结点的数据域。

（*p）.next或p->

next----表示由p所指向结点的指针域。

▪单链表的类型定义

typedefcharListData;

typedefstructnode{//链表结点

ListDatadata;

//结点数据域

structnode*next;

//结点链域

}Lnode;

typedefLnode*Linklist;

//链表头指针

Linklisthead;

//链表头指针

在单链表中插入元素

newnode->

next=p->

next;

p->

next=newnode；

算法描述

intInsert（Linklist&

head,ListDatax,inti）{

//在带头结点的链表第i个结点处插入新元素x

Lnode*p,*newnode;

p=head;

intk=0;

while（p!

=NULL&

k<

i-1）

{p=p->

k++;

}//找第i-1个结点

if（p==NULL||k>

i-1）{

printf（“无效的插入位置!

return0;

//插入位置错误（i<

1或大于表长＋1）

newnode=（Lnode*）malloc（sizeof（Lnode））;

newnode->

data=x;

next=newnode;

newnode=（Lnode*）malloc（sizeof（Lnode））;

⏹删除

在单链表中删除ai结点

q=p->

p->

next=q->

intDelete（Linklist&

head,intiListData&

e）

//在头结点链表中删除第i个结点

Lnode*p,*q;

p=head;

while（p->

next!

i-1）

}//找第i-1个结点

if（p->

next==NULL||0>

=i）{

printf（“无效的删除位置!

q=p->

e=q->

data;

free（q）;

//取出被删结点数据并释放q

带表头结点的单链表

•表头结点位于表的最前端，本身不带数据，仅标志表头。

•设置表头结点的目的:

简化链表操作的实现。

q->

next=q;

deleteq;

单链表设置头结点的好处：

1。

其头指针是指向头结点的非空指针，无论链表

是否为空，头指针始终保持不变，因此头指针的处理

对空表和非空表的操作是一致的，这与不带头结点的

单链表为空时头指针为空不同

2。

开始结点的地址存放在头结点的指针域，故对该

结点的操作和其他结点一样，无需进行特殊处理。

建立单链表方法一

▪从一个空表开始，重复读入数据：

▪生成新结点

▪将读入数据存放到新结点的数据域中

▪将该新结点插入到链表的前端

▪直到插入要求个数的结点为止。

voidcreatelist（linklist&

h,intn）{

h=（Lnode*）malloc（sizeof（Lnode））;

h->

next=NULL;

for（i=1;

i<

=n;

i++）

{p=（Lnode*）malloc（sizeof（Lnode））;

scanf（&

p->

data）;

next=h->

next=p;

建立单链表方法二

▪每次将新结点加在链表的表尾；

▪尾指针r,总是指向表中最后一个结点，新结点插在它的后面；

计算单链表长度

intLength（Linklisthead）{

Lnode*p=head->

//指针p指示第一个结点

intcount=0;

=NULL）{//逐个结点检测

p=p->

count++;

}

returncount;

按值查找

Lnode*Find（Linklisthead,ListDatavalue）{

//在链表中从头搜索其数据值为value的结点

Lnode*p=head->

data!

=value）

returnp;

静态链表

用一维数组描述线性链表

▪定义

constintMaxSize=100;

//静态链表大小

typedefintListData;

typedefstructnode{//静态链表结点

intnext;

}SNode;

typedefstruct{//静态链表

SNodeNodes[MaxSize];

intnewptr;

//当前可分配空间首地址

}SLinklist;

链表空间初始化

voidInitList（SLinklistSL）{

SL.Nodes[0].next=1;

SL.newptr=1;

//当前可分配空间从1开始

//建立带表头结点的空链表

MaxSize-1;

i++）

SL.Nodes[i].next=i+1;

//构成空闲链接表

SL.Nodes[MaxSize-1].next=-1;

//链表收尾

循环链表（CircularList）

▪特点:

最后一个结点的next指针不为NULL，而是指向头结点。

只要已知表中某一结点的地址，就可搜寻所有结点的地址。

▪存储结构:

链式存储结构

带表头结点的循环链表

循环链表的插入

双向链表（DoublynextedList）

▪双向链表结点结构：

双向循环链表的定义

typedefstructdnode{

structdnode*prior,*next;

}DblNode;

typedefDblNode*DblList;

双向循环链表的插入（非空表）

q->

prior=p;

next->

prior=q;

双向循环链表的删除

prior=p->

prior;

prior->

顺序表与链表的比较

基于空间的比较

⏹存储分配的方式

◆顺序表的存储空间是静态分配的

◆链表的存储空间是动态分配的

⏹存储密度=结点数据本身所占的存储量/结点结构所占的存储总量

◆顺序表的存储密度=1

◆链表的存储密度<

1

基于时间的比较

⏹存取方式

◆顺序表可以随机存取，也可以顺序存取

◆链表是顺序存取的

⏹插入/删除时移动元素个数

◆顺序表平均需要移动近一半元素

◆链表不需要移动元素，只需要修改指针

v多项式及其相加

•在多项式的链表表示中每个结点增加了一个数据成员next，作为链接指针。

•优点是：

–多项式的项数可以动态地增长，不存在存储溢出问题。

–插入、删除方便，不移动元素。