第二章线性表概述Word下载.docx

第二章线性表概述Word下载.docx

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

pre_e）求前驱：

若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱,否则操作失败,pre_e无定义。

9）.NextElem（L,cur_e,&

next_e）求后继若cur_e是L的数据元素,且不是最后一个,则用next_e返回它的后继,否则操作失败,next_e无定义。

10）.ListInsert（&

L,i,e）插入在L中第i个位置之前插入新的数据元素e,L的长度加1。

1=<

i<

=Listlength（L）+1

11）.ListDelete（&

L,i,&

e）删除删除L的第i个数据元素,并用e返回其值,L的长度减1。

12）.ListTraverse（L,visit（））遍历对给定的线性表L，依次输出L的每一个数据元素。

遍历时不许重复

13）.Copy（L,C）复制将给定的线性表L复制到线性表C中。

14）.Merge（A,B,C）合并将给定的线性表A和B合并为线性表C。

5．简述数组与顺序存储结构线性表的区别和联系。

顺序存储结构的线性表，它是用一个结构体变量来描述一个线性表，该变量包含三个分量，一个是一维数组来存储线性表中的元素，一个是线性表的元素个数length，一个是线性表最大长度。

对于线性表中的数组，每个元素必须是连续存放，若是对线性表插入或删除，对应位置需要靠右移或左移来重新保持紧密连接关系。

而且插入或删除只能在合理位置（插入在1~length+1的位置，且不能越界，删除在1~length的位置上，）。

而数组要灵活很多，数组里的元素不必连续存放，插入删除也不必重新保持元素紧密相联，可以在任意位置插入删除元素，只要不越界即可。

6．顺序表和链表在进行插入操作时，有什么不同？

顺序表插入时，先找到插入位置，然后从表尾部到插入位置的所有结点顺次后移一个元素，再把要插入的元素放在预定位置，插入需要大量移动元素，效率低。

而链式存储插入时只需找到要插入元素应在位置的前驱元素的指针，然后开辟新结点，将新元素放入新结点，再用两条语句就把新结点插入链表适当位置了，不需大量移动元素，效率高.

7．画出下列数据结构的图示：

①顺序表②单链表③双链表④循环链表

顺序存储

单链表

双向链表

循环链表

8．试给出求顺序表长度的算法。

•ilengthtlistlelengthgth（Seqlist*L）

•{

•returlength（L->

lelength）;

•}

9．若顺序表A中的数据元素按升序排列，要求将x插入到顺序表中的合适位置，以保证表的有序性，试给出其算法。

答：

　设原表Ｌ　

（1）顺序存储

VoidInsert（sqllist*L,elemtypex）

{

Inti=0;

While（i<

L->

length&

&

L->

elem[i]<

X）

i++;

If（I==L->

length）

{L->

elem[i]=X;

length++;

}

Else

{

For（j=L->

length–1;

j==i;

j--）

elem[j+1]=L->

elem[j];

elem[j]=X;

;

length++;

}

（2）链式存储

Intinsert（slnodetype*h,ElemtypeX）

slnodetype*p,*s;

p=h;

q=h->

next;

while（p->

next!

=NULL&

q->

data<

X））{p=q;

q=q->

/}

if（p->

next==NULL）{

s=（slnode*）malloc（sizeof（slnode））;

s->

data=X;

p->

next=s;

s->

next=NULL;

returntrue;

else

{（s=（slnodetype*）malloc（sizeof（slnodetype））==NULL）

returnFALSE;

s->

data=x;

next=p->

p->

next=s;

returnTRUE;

10.将一个线性表从第i个位置起拆开，变成两个线性表

voidseperate（linkL,inti,linkA,linkB）

{

intj=1;

linkp=L;

while（j<

=i-1&

p!

=NULL）{j++;

P=P->

if（p==NULL）

printf（"

theiisoverflow"

）;

exit（）;

q=p->

LA=L;

LB->

next=q;

11把一个值为Ｘ的结点插到表中值为Ｙ的结点之前的算法．

typedefstructLnode{

Elemtypedata;

structLnode*next;

}Lnode,*LinkList,slnodetype*link;

Voidinsert（linkL,elemx,elemy）//采用链式存储的方式

Linkp=L;

//Ｐ放的q的前驱

Linkq=L;

While（q!

=NULL&

data!

=x）//Ｐ找到Ｘ的前驱

P=q;

　q=q->

}

S=（link）malloc（sizeof（slnode））;

S->

data=y;

next=q;

p->

12.将线性表（顺序存储），偶数下标的元素都变成0，奇数下标的元素都置为1；

typedefstruct{

ElemType*elem;

intlength;

intlistsize;

//当前分配的存储容量（以sizeof（ElemType）为单位）

}SqList;

Change_list（SqList&

L）

{inti=0;

for（i=0;

i<

length;

i++）

if（i%2==0）

element[i]=0;

else

element[i]=1;

13，将线性表中偶数下标的元素都删除，只留下奇数下标的元素构成一个新的线性表；

假设用链式存储

typedefstructLnode{

Linkinsert（linkL,）//设线性表的第一个元素下标是1

{linkL_even;

L_even=（link））malloc（sizeof（Lnod））;

//L_even是新奇数链表的头指针

r=L_even;

//r是新的奇数链表的尾部指针

i=1;

Linkp=L->

next;

//r放新链表的最后一个结点的指针

While（p!

=NULL）//Ｐ是q的前驱

　　If（i%2==1）

r->

next=p;

r=p;

}

P=p->

14．试将一个无序的线性表A=（11,16,8,5,14,10,38,23）转换成一个按升序排列的有序线性表（用链表实现）。

11已知L为单链表指针,数据结点递增有序,编写表中值从大于MIN开始到小于MAX值为止所有结点完全倒置的算法.

Voidconverse（linkL,elemx,elemy）

Linktemp;

=min）//Ｐ是q的前驱

q=q->

If（q==NULL）

Printf（“theministoobig”）;

Protect=q;

temp->

next=null;

//protect是指向min结点指针，temp->

next存放倒置过的最后一个结点．

While（q->

max）

N=q->

　　　　　　　　//Ｎ为下一个要处理的结点

next=temp->

Temp->

q=N;

P->

Protect->

15.递增有序线性表Ａ，Ｂ，（同表中元素各不同，另构建一个新表Ｃ，值为Ａ，Ｂ交集且递增有序．

答

（1）顺序存储

voidmerge（ElemtypeLa[],ElemtypeLb[],snode*Lc）

{inti,j,k;

intLa_length,Lb_length;

i=j=0;

k=0;

La_length=Length（La）;

Lb_length=Length（Lb）;

/*取表La,Lb的长度*/

Initiate（Lc）;

/*初始化表Lc*/

While（I<

La_length&

j<

Lb_length）

{a=get（La,i）;

b=get（Lb,j）;

if（a<

b）

++i;

elseif（a>

b）

++j;

Else

Insert（LC->

elelm[],k++,a）;

j++;

}//while

LC->

length=k;

}

（2）链式存储

Void（linka,linkb,linkc）

Linkpa=a->

next,pb=b-next,pc=c;

While（pa!

pb!

=NULL）

If（pa->

pb->

data）

Pa=pa->

Elseif（pa->

data>

Pb=pb->

Else//若相等，插入到Ｃ表中

{c->

next=pa;

C=pa;

Pa=pa->

Pb=pb->

}

16删除线性表a中第i个元素起的k个元素

顺序存储

Delete_k（SqList&

{intj;

if（i<

1||k<

0||i+k-1>

a.length）returnerror;

For（j=i;

j+k<

=L->

j++）

Elem[j]=elem[j+k];

17把x插入递增有序表L中（顺序，链式都要）

StatusInsert_SqList（SqList&

L,intx）//把x插入递增有序表L中

if（L.length+1>

L.listsize）returnERROR;

L.length++;

for（i=L.length-1;

L.elem[i]>

x&

i>

=0;

i--）

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

L.elem[i+1]=x;

returnOK;

}//Insert_SqList

18在无头结点链表L的第i个元素之前插入元素b

StatusInsert（LinkList&

L,inti,intb）//在无头结点链表L的第i个元素之前插入元素b

p=L;

q=（LinkList*）malloc（sizeof（LNode））;

q.data=b;

if（i==1）

q.next=p;

L=q;

//插入在链表头部

else

while（--i>

1）p=p->

p->

next=q;

//插入在第i个元素的位置

}//Insert

19链表的就地逆置;

为简化算法,假设表长大于2

•

20把链表A和B合并为C,A和B的元素间隔排列,且使用原存储空间

voidmerge1（LinkList&

A,LinkList&

B,LinkList&

C）/{

p=A->

q=B->

C=A;

while（p&

q）

s=p->

//将B的元素插入

if（s）

t=q->

q->

//如A非空,将A的元素插入

p=s;

q=t;

}//while

}//merge1

21删除元素递增排列的链表L中值大于mink且小于maxk的所有元素

StatusDelete_Between（Linklist&

L,intmink,intmaxk）//{

while（p->

next->

data<

=mink）p=p->

//p是最后一个不大于mink的元素

if（p->

next） 

//如果还有比mink更大的元素

q=p->

while（q->

maxk）q=q->

//q是第一个不小于maxk的元素

}//Delete_Between

22求元素递增排列的线性表A和B的元素的交集并存入C中（顺序，链式都做）

voidmerge（Linklist&

La,Linklist&

Lb,Linklist&

Lc）

Lb_length（Lb）=Length（Lb）;

While（i<

=La_length&

=Lb_length）

b）{insert（Lc,++k,a）;

++i;

else{insert（Lc,++k,b）;

}/*将La和Lb的元素插入到Lc中*/

while（i<

=La_length）{a=get（La,i）;

insert（Lc,++k,a）;

while（j<

=lb_length）{b=get（La,i）;

insert（Lc,++k,b）;

}}

24删除单循环链表中结点s的直接前驱

•intDelet（slnodetype*h,slnodetype*s）

•{slnodetype*p,*s;

•p=h;

q=h;

//q是当前判断的结点的前驱，当前节点的后继==s时，删除当前结点

•while（p->

next!

=s&

=NULL）

•{

•q=p;

•p=p->

•}

•If（p->

next==NULL）

•{printf（“Error!

”）;

/*删除位置错误!

*/

•returnFALSE;

•x=q->

next

•q->

/*删除第i个结点*/

•free（x）;

/*释放被删除结点空间*/

•returnTRUE;