数据结构之线性表.docx

数据结构之线性表.docx

《数据结构之线性表.docx》由会员分享，可在线阅读，更多相关《数据结构之线性表.docx（20页珍藏版）》请在冰豆网上搜索。

数据结构之线性表

例2-1线性表La,Lb的合并.La=La∪Lb.（算法2.1）

voidunion（List&La,ListLb）{

La_len=ListLength（La）;

Lb_len=ListLength（Lb）;

for（i=1;i<=Lb_len;i++）{

GetElem（Lb,i,e）;

If（!

LocateElem（La,e,equal））

ListInsert（La,++La_len,e）;

}

}//union

非递减线性表La,Lb的合并的C程序

（一）

InitList（&Lc）;i=j=1;k=0;

La_len=ListLength（La）;

Lb_len=ListLength（Lb）;

While（（i<=La_len）&&（j<=Lb_len））{

GetElem（La,i,ai）;GetElem（Lb,j,bj）;

If（ai<=bj）{ListInsert（Lc,++k,ai）;++i;}

else{ListInsert（Lc,++k,bj）;++j;}

}

非递减线性表La,Lb的合并的C程序

（二）

while（i<=La_len）{

GetElem（La,i++,ai）;ListInsert（Lc,++k,ai）;

}

while（j<=Lb_len）{

GetElem（Lb,j++,bj）;ListInsert（Lc,++k,bj）;

}

构造一个空的线性表

typedefstruct{

ElemType*elem;

intlength;

intlistsize;

}SqList;

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

=x）

i++;

if（i

elsereturn-1;

}

按值查找：

判断x是否在表中

intIsIn（SqList&L,ElemTypex）

{inti=0,found=0;

while（i

found）

if（L.elem[i]!

=x）i++;

elsefound=1;

returnfound;

}

求表的长度

intLength（SqList&L）{

returnL.length;

}

提取函数：

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

ElemTypeGetData（SqList&L,inti）{

if（i>=0&&i

returnL.elem[i];

elseprintf（“参数i不合理！

\n”）;

}

▪按值查找：

寻找x的后继

intNext（SqList&L,ElemTypex）{

inti=Find（x）;

if（i>=0&&i

elsereturn-1;

}

▪寻找x的前驱

intNext（SqList&L,ElemTypex）{

inti=Find（x）;

if（i>0&&i

elsereturn-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&L,ElemTypex）{

//在表中删除已有元素x

inti=Find（L,x）;//在表中查找x

if（i>=0）{

L.length--;

for（intj=i;j

L.elem[j]=L.elem[j+1];

return1;//成功删除

}

return0;//表中没有x

}

顺序表的应用:

集合的“并”运算

voidUnion（SqList&A,SqList&B）{

intn=Length（A）;

intm=Length（B）;

for（inti=0;i

intx=GetData（B,i）;//在B中取一元素

intk=Find（A,x）;//在A中查找它

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

{Insert（A,x,n）;n++;}

}

}

集合的“交”运算

voidIntersection（SeqList&A,SeqList&B）{

intn=Length（A）;

intm=Length（B）;

inti=0;

while（i

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&&j

{p=p->next;j++;}//找第i-1个结点

if（p==NULL||j>i-1）{

printf（“无效的插入位置!

\n”）;//终止插入

return0;

}

ListNode*s=//创建新结点

（ListNode*）malloc（sizeof（ListNode））;

s->data=x;

if（i==1）{//插入空表或非空表第一个结点之前

s->next=L;//新结点成为第一个结点

L=s;

}

else{//插在表中间或末尾

s->next=p->next;

p->next=s;

}

return1;

}

在单链表中删除ai结点

q=p->next;

p->next=q->next;

StatusListDelete（LinkList&L,inti,ElemType&e）{

//在链表中删除第i个元素，并由e返回其值

ListNode*p,*q;

if（i==1）//删除表中第1个结点

{q=L;L=L->next;}

else{

p=L;intj=0;

while（p!

=NULL&&j

{p=p->next;j++;}//找第i-1个结点

if（p->next==NULL||j>i-1）{//找不到第i-1个结点

printf（“无效的删除位置!

\n”）;

return0;

}

else{//删除中间结点或尾结点元素

q=p->next;

p->link=q->next;

}

e=q->data;free（q）;//取出被删结点数据并释放q

}

}

带表头结点的单链表

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

•设置表头结点的目的:

简化链表操作的实现。

插入

q->next=p->next;

p->next=q;

intInsertList_L（LinkList&L,ElemTypex,inti）{

//将新元素x插入在链表中第i号结点位置

ListNode*p=Locate（L,i-1）;

if（p==NULL）return0;//参数i值不合理返回0

ListNode*s=//创建新结点

（ListNode*）malloc（sizeof（ListNode））;

s->data=x;

s->next=p->next;//链入

p->next=s;

return1;

}

intDeleteList_L（LinkList&L,inti）{

//将链表第i号元素删去

ListNode*p,*q

p=Locate（L,i-1）;//寻找第i-1个结点

if（p==NULL||p->next==NULL）

return0;//i值不合理或空表

q=p->next;

p->next=q->next;//删除结点

free（q）;//释放

return1;

}

前插法建立单链表

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

生成新结点

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

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

直到读入结束符为止。

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;//建立新结点

q->next=head->next;//插入到表前端

L->next=q;

}

}

后插法建立单链表

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

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

VoidcreateListR_L（LinkList&L）{

charch;

L=//建立表头结点

（LinkList）malloc（sizeof（ListNode））;

ListNode*q,*r=L;

while（（ch=getchar（））!

=‘\n’）{

q=（listNode*）malloc（sizeof（ListNode））;

q->data=ch;//建立新结点

r->next=q;r=q;//插入到表末端

}

r->next=NULL;

}

单链表清空

VoidEmptyList_L（LinkListL）{

//删去链表中除表头结点外的所有其它结点

ListNode*q;

while（L->next!

=NULL）{//当链不空时，循环逐个删去所有结点

q=L->next;L->next=q->next;

free（q）;//释放

}

}

计算单链表长度

intLength_L（LinkListL）{

ListNode*p=L->next;//指针p指示第一个结点

intcount=0;

while（p!

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

count++;p=p->next;

}

returncount;

}

按值查找

ListNode*Find（LinkListL,ElemTypevalue）{

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

ListNode*p=L->next;

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

while（p!

=NULL&&p->data!

=value）

p=p->next;

returnp;

}

按序号查找（定位）

ListNode*Locate（LinkListL,inti）{

//返回表中第i个元素的地址

if（i<0）returnNULL;

ListNode*p=L;intk=0;

while（p!

=NULL&&k

{p=p->next;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;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）{

if（i<0）return-1;//参数不合理

intj=0,p=SL.Nodes[0].link;

while（p!

=-1&&j

p=SL.Nodes[p].link;

j++;

}

if（i==0）return0;

returnp;

}

在静态链表第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;//插入

return1;

}

在静态链表中释放第i个结点

intRemove（SLinkListSL,inti）{

intp=Locate（SL,i-1）;

if（p==-1）return0;//找不到结点

intq=SL.Nodes[p].link;//第i号结点

SL.Nodes[p].link=SL.Nodes[q].link;

SL.Nodes[q].link=SL.newptr;//释放

SL.newptr=q;

return1;

}

循环链表（CircularList）

循环链表的插入

约瑟夫问题的解法

#include

TypedefstructCircleNode{

intindex;

structCircleNode*next;

}CircleNode,*CircList;

CircleListclist=NULL;

voidJosephus（intn,intm）{

for（inti=0;i

for（intj=1;jnext;

printf（“Deleteperson:

%d”,clist->next->data）;//数m-1个人

q=clist->next;

clist->next=clist->next->next;//删去

free（q）;

clist=clist->next;

}

}

voidmain（）{

intn,m;

printf（“EntertheNumberofContestants?

”）;

scanf（“%d,%d”,&n,&m）;

CircleListr=NULL;

for（inti=1;i<=n;i++）//形成约瑟夫环

{CircleLists=（CircleNode*）

malloc（sizeof（CircleNode））;

s->data=i;

if（r==NULL）{clist=s;s->next=s;r=s;}

else{r->next=s;s->next=clist;r=s;}

}

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;

ListIteratorAiter（ah.poly）;

ListIteratorBiter（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;pa=Aiter.Next（）;

deletep;

}

else{

pc→link=pa;pc=pa;

pa=Aiter.Next（）;

}

break;

case'<':

pc→next=pb;pc=pb;

pb=Biter.Next（）;break;

case'>':

pc→next=pa;pc=pa;

pa=Aiter.Next（）;

}

if（Aiter.NotNull（））pc→next=pa;

elsepc→next=pb;

}

双向链表（DoublyLinkedList）

双向循环链表的定义

typedefintListData;

typedefstructdnode{