第二章線性表

一、選擇題

1、與線性表的順序存儲不相符的特性是（A

A.插入和刪除操作靈活B.需要連續(xù)存儲空間C.便于隨機訪問D.存儲密度大

2、順序存儲結(jié)構(gòu)的特點是（B工

A.只能實現(xiàn)順序存取元素的操作

B.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上也一定相鄰

C.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上一定不相鄰

D.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上不一定相鄰

3、設(shè)單鏈表中指針p指向結(jié)點A,要刪除A之后的結(jié)點（若存在），則修改指針的操作為（A）。

A.p->next=p->next->nextB.p=p->next

C.p=p->next->nextD.p->next=p

4、在一個單鏈表中，已知q所指向的結(jié)點是p所指向結(jié)點的前驅(qū)結(jié)點，若在q和p之間插

入s所指向的結(jié)點，則執(zhí)行（C）。

A.s->next=p->next;p->next=s;B.p->next=s->next;s->next=p;

C.q->next=s;s->next=p;D.p->next=s;s->next=q;

5、若某鏈表中最常用的操作是在最后??個元素之后插入?個元素和刪除最后一個元素，則

采用（D）最節(jié)省時間。

A.單鏈表B.雙鏈表C.帶頭結(jié)點的雙循環(huán)鏈表D.單循環(huán)鏈表

6、與線性表的鏈接存儲不相符合的特性是（C）。

A.便于插入、刪除運算B,存儲空間動態(tài)分配

C.需要連續(xù)的存儲空間D.只能順序查找

7、循環(huán)鏈表h的尾結(jié)點P的特點是（D）。

A.p==h->nextB.p->next==h->nextC.p==hD.p->next==h

8、鏈表不具有的特點是（B

A.插入、刪除不需要移動元素B.可隨機訪問任一元素

C.不必事先估計存儲空間I）.所需空間與線性長度成正比

9、設(shè)一個有序的單鏈表中有n個結(jié)點，現(xiàn)要求插入一個新結(jié)點后使得單鏈表仍然保持有序,

則該操作的時間復(fù)雜度為（D）。

2

A.O（log2n）B.0（1）C.0（n）D.0（n）

10、若長度為n的線性表采用順序存儲結(jié)構(gòu)，在其第i個位置插入一個新元素，算法的時間

復(fù)雜度為（C）。

2

A.0（log2n）B.0（1）C.0（n）D.0（n）

11、對于一個線性表，若要求既能夠進行較快地插入和刪除，又能夠反映出數(shù)據(jù)元素之間的

關(guān)系，則應(yīng)該（A）o

A.以鏈接方式存儲B.以順序方式存儲

C.以散列方式存儲D.以索引方式存儲

12、設(shè)順序存儲的線性表共有123個元素，按分塊查找的要求等分成3塊。若對索引表采

用順序查找來確定塊，并在確定的塊中進行順序查找，則在查找概率相等的情況下，分塊

查找成功時的平均查找長度為（B）。這題是查找那一章節(jié)的

A.41B.23C.21D.62

13、在n個結(jié)點的順序表中，算法的時間復(fù)雜度是0（1）的操作是（C）。

A.在第i個結(jié)點后插入一個新結(jié)點（iWiWn）

B.刪除第i個結(jié)點（IWiWn）

C.訪問第i個結(jié)點（IWi—）和求第i個結(jié)點的直接前驅(qū)（2WiWn）

D.將n個結(jié)點從小到大排序

14、設(shè)指針變量front表示鏈式隊列的隊頭指針，指針變量rear表示鏈式隊列的隊尾指針,

指針變量s指向?qū)⒁腙犃械慕Y(jié)點X,則入隊列的操作序列為（C

A.front->next=s；front=s；B.s->next=rear；rear=s；

C.rear->next=s；rear=s；D.s->next=front；front=s；

15、在一個單鏈表中，已知q所指向的結(jié)點是p所指向結(jié)點的前驅(qū)結(jié)點，若在q和p之間

插入s所指向的結(jié)點，則執(zhí)行（C）o

A.s->next=p->next;p->next=s;B.p->next=s->next;s->next=p;

C.q->next=s;s->next=p;D.p->next=s;s->next=q;

16、對于只在表的首、尾兩端進行插入操作的線性表，宜采用的存儲結(jié)構(gòu)為（C）。

A.順序表B.用頭指針表示的單循環(huán)鏈表

C.用尾指針表示的單循環(huán)鏈表D.單鏈表

17、順序存儲結(jié)構(gòu)的特點是（B）o

A.只能實現(xiàn)順序存取元素的操作

B.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上也一定相鄰

C.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上一定不相鄰

D.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上不一定相鄰

18、在n個結(jié)點的順序表中，算法的時間復(fù)雜度是0（1）的操作是（C）。

A.在第i個結(jié)點后插入一個新結(jié)點（lWiWn）

B.刪除第i個結(jié)點（JLWlWn）

C.訪問第i個結(jié)點（lWiWn）和求第i個結(jié)點的直接前驅(qū)（2WiWn）

D.將n個結(jié)點從小到大排序

19、對于只在表的首、尾兩端進行插入操作的線性表，宜采用的存儲結(jié)構(gòu)為（C）。

A.順序表

B.用頭指針表示的單循環(huán)鏈表

C.用尾指針表示的單循環(huán)鏈表

D.單鏈表

20、循環(huán)鏈表h的尾結(jié)點p的特點是（D

A.p==h->nextB.p->next==h->nextC.p==hD.p->next==h

21、順序存儲結(jié)構(gòu)的特點是（B）o

A.只能實現(xiàn)順序存取元素的操作

B.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上也一定相鄰

C.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上一定不相鄰

D.邏輯上相鄰的數(shù)據(jù)元素在存儲地址上不一定相鄰

22、設(shè)?個有序的單鏈表中有n個結(jié)點，現(xiàn)要求插入一個新結(jié)點后使得單鏈表仍然保持有序,

則該操作的時間復(fù)雜度為（D）。

2

A.O（log2n）B.0（1）C.0（n）D,0（n）

23、與線性表的順序存儲不相符的特性是(B

A.需要連續(xù)存儲空間B.插入和刪除操作靈活

C.便于隨機訪問D.存儲密度大

24、若某鏈表中最常用的操作是在最后一個元素之后插入一個元素和刪除最后一個元素，則

采用(D)最節(jié)省時間。

A.單鏈表B.雙鏈表

C.單循環(huán)鏈表D.帶頭結(jié)點的雙循環(huán)鏈表

25、設(shè)一個有序的單鏈表中有n個結(jié)點，現(xiàn)要求插入一個新結(jié)點后使得單鏈表仍然保持有序,

則該操作的時間復(fù)雜度為(A

2

A.0(n)B.0(1)C.0(n)D.O(log2n)

26、與線性表的鏈接存儲不相符合的特性是(D)。

A.便于插入、刪除運算

B.存儲空間動態(tài)分配

C.只能順序查找

D.需要連續(xù)的存儲空間

27、若長度為n的線性表采用順序存儲結(jié)構(gòu)，在其第i個位置插入一個新元素，算法的時間

復(fù)雜度為(B)。

2

A.O(log2n)B.0(n)C.0(1)D.0(n)

28、在一個單鏈表中，已知q所指向的結(jié)點是p所指向結(jié)點的前驅(qū)結(jié)點，若在q和p之間

插入s所指向的結(jié)點，則執(zhí)行(D)。

A.s->next=p->next;p->next=s;

B.q->next=s;s->next=p;

C.p->next=s->next;s->next=p;

D.p->next=s;s->next=q;

二、判斷題

1、線性表采用鏈表存儲時，結(jié)點之間的存儲空間可以是不連續(xù)的。J

2、對于任何數(shù)據(jù)結(jié)構(gòu)，鏈式存儲結(jié)構(gòu)一定優(yōu)于順序存儲結(jié)構(gòu)。X

3、順序存儲結(jié)構(gòu)的主要倏點是不利于插入或刪除操作。J

4、線性表的特點是每一個元素都有一個前驅(qū)和一個后繼。X

5、數(shù)據(jù)的物理結(jié)構(gòu)是指數(shù)據(jù)在計算機內(nèi)的實際存儲形式。J

6、順序存儲方式插入和刪除效率太低，因此它不如鏈式存儲方式好。X

7、循環(huán)鏈表不是線性表。X

8、線性表只能用順序存儲結(jié)構(gòu)來實現(xiàn)。X

9、順序表不必事先估計存儲空間。X

10、為了很方便的插入和刪除數(shù)據(jù)，可以使用雙向鏈表存放數(shù)據(jù)。V

11>線性表的順序存儲比漣式存儲效率高。X

12、順序存儲結(jié)構(gòu)的主要優(yōu)點是有利于插入或刪除操作。X

13、順序存儲方式的優(yōu)點是存儲密度大，插入、刪除的效率高。X

14、鏈式存儲方式比順序存儲方式在插入、刪除操作時口勺效率高。V

15、順序存儲方式插入和刪除效率太低，因此它不如鏈式存儲方式好。X

16、順序存儲方式的優(yōu)點是存儲密度大，插入、刪除的效率高。X

17、鏈式存儲方式比順序存儲方式在插入、刪除操作時的效率高。V

18、對于仟何數(shù)據(jù)結(jié)構(gòu),璉式存儲結(jié)構(gòu)一定優(yōu)干順序存儲結(jié)構(gòu)。X

19、線性表采用鏈表存儲忖，結(jié)點之間的存儲空間可以是不連續(xù)的。J

20、順序存儲結(jié)構(gòu)的主要玦點是不利于插入或刪除操作。V

21、順序存儲方式插入和刪除效率太低，因此它不如鏈式存儲方式好。X

22、對于任何數(shù)據(jù)結(jié)構(gòu)，迸式存儲結(jié)構(gòu)一定優(yōu)于順序存儲結(jié)構(gòu)。X

23、鏈式存儲方式比順序存儲方式在插入、刪除操作時的效率高。J

三、應(yīng)用題

四、程序填空題

1、己知線性表的存儲結(jié)構(gòu)為順序表，數(shù)據(jù)元素為整型。以下算法的功能是刪除線性表中所

有值為負數(shù)的元素，請?zhí)羁铡?/p>

typedefintElemType;

typedefstruct

{ElemType*data;/*存儲空間基地址*/

intlength;/*順序表長度(即已存入的元素個數(shù))*/

intlistsize;/*當前存儲空間容量(即能存入的元素個數(shù))*/

}sqlist;

voidfun(sqlist*L)

{inti,j;

for(i=j=0;①;i++)

if(L->data[i]>=0)

{if(i!=j)②；

③___________；

)

L->length=j;

)

②L->data[j]=L->data[i]

③j++

2、以下是在順序表L中的第i個位序上插入一個值為x的數(shù)據(jù)元素的操作，請?zhí)羁铡?/p>

typcdcfintElemType;/*在實際問題中，根據(jù)需要定義所需的數(shù)據(jù)類型*/

typedefstruct

{ElemType*data;/*存儲空間基地址*/

intlength;/*順序表長度(即已存入的元素個數(shù))*/

intlistsize;/*當前存儲空間容量(即能存入的元素個數(shù))*/

}sqlist;

intinsert(sqlist*L,inti,ElemTypex)

{intj；

ift(D)retum0;

if(L->length==L->listsize)

(

L->data=(ElemType*)realloc(L->data,

(L->listsize+1)*sizeof(ElemType));

L->listsize++;

for(j=L->length-l;j>=i-1;j-)

________②：

L->datafi-l]=x;

③；

return1;

)

①i<l||i>L->length+l

@L->data[j+l]=L->data[j]

@L->length++

3、下面程序是將帶頭結(jié)點的單向循環(huán)鏈表逆置的算法，請?zhí)羁铡?/p>

typedefintElemType;

typedefstructnode

{ElemTypedata；

structnode*next：

}slink；

voidturn(siink

{slink*p,*q;

p=L->next;

L->next=L;

while(?)

{q=P；

p=p->next;

q->next=②;

L->next=;

)

)

①p!=L

@L->next

③q

4、下列函數(shù)的功能是實現(xiàn)帶頭結(jié)點的單鏈表逆置，靖填空。

typedefintElemType;

typedefstructnode

{ElemTypedata;/*數(shù)據(jù)域*/

structnode*next;/*指針域*/

}slink;

voidturn(?L)

{slink*p,*q;

p=L->next;

L->next=NULL;

while(?)

{q=p;

p=p->next;

q->ncxt=L->ncxt;

L->next=@;

)

}

①slink*

②p或p!=NULL

③q

5、己知線性表的存儲結(jié)構(gòu)為順序表，數(shù)據(jù)元素為整型。以下算法的功能是刪除線性表中所

有值為負數(shù)的元素，請?zhí)羁铡?/p>

typedefintElemType;

typedefstruct

{ElemType*data;/*存儲空間基地址*/

intlength;/*順序表長度(即己存入的元素個數(shù))*/

intlistsize;/*當前存儲空間容量(即能存入的元素個數(shù))*/

}sqlist;

voidfun(sqlist*L)

{inti,j;

for(i=j=0;①;i++)

if(L->data[i]>=0)

{if(i!=j)②；

③___________；

}L->length=j;

)

①i<L->lenglh

②L->data[j]=L->data[i]

③j++

6、線性表的存儲結(jié)構(gòu)為順序表，數(shù)據(jù)元素為整型。以下算法的功能是刪除線性表中所有值

為負數(shù)的元素，請?zhí)羁铡?/p>

typedefintElemType;

typedefstruct

{ElemType-data;/*存儲空間基地址*/

intlength;/*順序表長度(即己存入的元素個數(shù))*/

intlistsize;/*當前存儲空間容量(即能存入的元素個數(shù))*/

}sqlist;

voidfun(sqlist*L)

{inti,j;

for(i=j=0;i<L->length;i++)

if(ffl)

{if(②)L->data[j]=L->data[i];

)

L->length=j;

)

?L->data[i]>=0

②i!=j

③j++

7、以下是在順序表L中的第i個位序上插入一個值為x的數(shù)據(jù)元素的操作，請?zhí)羁铡?/p>

typcdcfintElcmTypc;/*在實際問題中，根據(jù)需要定義所需的數(shù)據(jù)類型*/

#defineINITSIZE100/*順序表存儲空間的初始分配量*/

typcdcfstruct

{ElemType*data;/*存儲空間基地址*/

intlength;/*順序表長度(即已存入的元素個數(shù))列

intlistsize;/*當前存儲空間容量(即能存入的元素個數(shù))*/

}sqlist;

/*插入操作(在順序表L中的第i個位序上插入一個值為x的數(shù)據(jù)元素)刃

intinserl(sqlist*L,inti,ElemTypex)

{intj；

if(i<lIIi>L->lengzh+l)return0;

if(CD?

(

L->data=(ElemType*)rcalloc(L->data,

(L->listsize+1)*sizeof(ElemType));

L->listsize++;

}

fbr(@;j>=i-l;j-)

L->data[j+l]=L->data[j];

③；

L->length++;

return1;

?L->length==L->listsize

(2)j=L->length-l

(3)L->data[i-l]=x

8、下面程序是將帶頭結(jié)點的單向循環(huán)鏈表逆置的算法，請?zhí)羁铡?/p>

typedefintElemType;

typedefstructnode

{ElemTypedata；

structnode*next：

}slink；

voidturn(slink*L)

{slink?;

p=L->next;

L->ncxt=L;

while(p!=L)

(q=P；

D=②；

q->next=L->next;

L->next=(3)；

)

)

①*p,*q

@p->next

③q

五、程序設(shè)計題

1、先寫出單鏈表的類型定義，然后編寫算法實現(xiàn)帶頭結(jié)點單鏈表L的逆置。

參考答案如下：

〃類型定義

typedefintElemType;

typedefstructnode

{ElemTypedata；

structnode*next：

}slink；

voidturn(slink*L)

{slink*p,*q;

p=L>next;

L->next=NULL;

while(p)

{q=P；

p=p->next;

q->next=L->next;

L->next=q;

}

)

2、先寫出單鏈表的類型定義，然后編寫算法在帶頭結(jié)點單鏈表第i個結(jié)點的后面插入元素

x,插入成功返回1,插入失敗返回0。

參考答案如下：

〃類型定義

typedefintElemType;

typedefstructnode

{ElemTypedata;

structnode*next;

}slink;

intinsert(slink*L,inti,ElemTypex)

{slink*p,*s;

intj;

p=L->next;j=l;

/*找到第i個數(shù)據(jù)元素的存儲位置，使指針p指向它*/

while(p!=NULL&&j<i)

{p=p->next;j++;}

if(p==NULL)return0;/*i值不合法*/

/*為x申請一個新的結(jié)點并由q指向它*/

q=(slink*)malloc(sizcof(siink));

q->data=x;

/*修改指針，完成插入操作*/q->next=p->next;

p->next=q;

return1;/*插入成功，返回1*/

)

3.對于給定的帶頭結(jié)點的單鏈表L,編寫刪除L中值為x的結(jié)點的直接前趨結(jié)點的算法。(要

求學(xué)生自己寫出單鏈表的類型定義)

參考答案如下：

typedefintElemType;

typedefstructNode{

ElemTypedata;

structNode*next;

}link;

intDel(link*L,intx)

{//L為單鏈表頭指針,返回值1表示操作成功，0表示失敗

link*p,*q,*r;

if(!L->next||L->next->data==x)

return0;

p=L->next->next;

q=L;//q是p的前驅(qū)的前驅(qū)

while(p&&p->data!=>){

q=q->next;

p=p->next;

)

if(!p)return0;

else

(

r=q->next;

q->next=p;

free(r);

return1;

)

)

4、先定義一個單鏈表，然后編寫算法實現(xiàn)：在帶頭結(jié)點的單鏈表L中，在值為x的結(jié)點的

前面插入一個值為y的結(jié)點，插入成功返回1,插入失敗返回0。

參考答案如下：

typedefintElemType;

typedefstructnode

{ElemTypedata；

structnode*next；

}slink；

intinsert(slink*L,ElemT/pex,ElemTypey)

{slink*p,*q;

P=L;

while(p->next!=NULL&&p->next->data!=x)

p=p->next;

if(p->next==NULL)return0;

q=(slink*)malloc(sizeof(slink));

q->data=y;

q->next=p->next;

p->next=q;

return1;

)

5、設(shè)A和B是兩個非遞減的順序表，先寫出順序表的類型定義，然后編寫算法，把A和B

中都存在的元素組成新的由大到小排列的順序表C。

參考答案如下：

typedefintElemType

typedefstruct

(

ElemType*data;/*存儲空間基地址/

intlength;/*順序表長度(即已存入的元素個數(shù))*/

intlistsize;/*當前存儲空間容量(即能存入的元素個數(shù))*/

}sqlist;

voidA_B(sqlist*A,sqlist*B,sqlist*C)

(

intiJ,k=O;

i=A->length-l;

j=B->length-l;

while(i>=0)

(

if(A->data[i]>B->data[j])i--;

if(A->data[i]==B->data[j])

(

C->data[k++]=A->data[i];

i-；

}

if(A->data[i]<B->data[j])j-;

)

C->length=k;

return;

)

或者

voidA_B_C(sqlist*AZsqlist*B,sqlist*C)

(

inti=Oj,k=O;

i=A->length-l;

while(i>=0)

(

for(j=B->length-l;j>=0;j-)

(

if(A->data[i]==B->data[j])

(

C->data[k++]=A->data[i];

break;

)

)

i-；

)

C->length=k;

return;

)

6、先寫出單鏈表的類型定義，然后編寫算法：將兩個帶頭結(jié)點的非遞減有序單鏈表la和

1b,歸并成一個非遞減有序單鏈表。(要求：不另開辟存儲空間)

參考答案：

typcdofintElemType;

typedefstructnode

{ElcmTypedata;/*數(shù)據(jù)域*/

structnode*next;/*指針域*/

)slink;

voidmergelist(slink*la,slink*lb)

{/*按值排序的單鏈表la,lb,歸并為la后也按值排序*/

slink*pa,*pb,*pc;

pa=la->next;pb=lb->next;

la->next=NULL;/*la作結(jié)果表,先置空*/

pc=la；/*初始化*/

while(pa&&pb)/*將pa、pb結(jié)點按大小依次插入pc后*/

{if(pa->data<=pb->data)

{pc->next=pa;pc=pa;pa=pa->next;}

else{pc->next=pb;pc=pb;pb=pb->next}

)

pc->next=pa?pa:pb;/*插入剩余段*/

free(lb);/*釋放lb的頭結(jié)點*/

}/*mergelist*/

7、先定義一個單鏈表，然后編寫算法'實現(xiàn)：在帶頭結(jié)點的單鏈表L中，在值為x的結(jié)點的

前面插入一個值為y的結(jié)點，插入成功返回1,插入失敗返回0。

參考答案如下：

typedefintElemType;

typedefstructnode

{ElemTypedata；

structnode*next；

}slink：

intinsert(slink*L,ElemT/pex,ElemTypey)

{slink*p,*q;

P=L；

while(p->next!=NULL&&p->next->data!=x)

p=p->next;

if(p->next==NULL)return0;

q=(slink*)malloc(sizeof(slink));

q->data=y;

q->next=p->next;

p->next=q;

return1;

)

8、先寫出單鏈表的類型定義，然后編寫算法：將兩個帶頭結(jié)點的非遞減有序單鏈表la和

1b,歸并成一個非遞減有序單鏈表。(要求：不另開辟存儲空間)

參考答案：

typedefintElemType;

typedefstructnode

{ElemTypedata;/*數(shù)據(jù)域*/

structnode*next;/*指針域*/

}siink;

voidmergelist(slink*la,slink*lb)

{/*按值排序的單鏈表la,lb,歸并為la后也按值排序*/

slink*paz*pb,*pc;

pa=la->next;pb=lb->next;

la->next=NULL;/*la作結(jié)果表，先置空*/

pc=la；/*初始化*/

while(pa&&pb)/*將pa、pb結(jié)點按大小依次插入pc后*/

{if(pa->data<=pb->data)

{pc->next=pa;pc=pa;pa=pa->next;}

else{pc->next=pb;pc=pb;pb=pb->next}

)

pc->next=pa?pa:pb;/*插入剩余段*/

free(lb);/*釋放lb的頭結(jié)點*/

}/*mergelist*/

9、先寫出單鏈表的類型定義，然后編寫算法在帶頭結(jié)點單鏈表第i個結(jié)點的后面插入元素

x,插入成功返回1,插入失敗返回0。

參考答案如下：

〃類型定義

typedefintElemType;

typedefstructnode

{ElemTypedata;

structnode*next;

Jslink;

intinsert(slink*L,inti,ElemTypex)

{slink*p,*s;

intj;

p=L->next;j=l;

/*找到第i個數(shù)據(jù)元素的存儲位置，使指針p指向它*/

while(p!=NL-LL&&j<i)

{p=p->next;j++;}

if(p==NULL)return0;/*i值不合法*/

/*為x申請一個新的結(jié)點并由q指向它*/

q=(slink*)malloc(sizeof(siink));

q->data=x;

/*修改指針，完成插入操作*/q->next=p->next;

p->next=q;

return1;/*插入成功，返回1*/

}

10、設(shè)A和B是兩個非遞減的順序表，先寫出順序表的類型定義，然后編寫算法，把A和B

中都存在的元素組成新的由大到小排列的順序表Co

參考答案如下：

typedefintElemType

typedefstruct

(

ElemType*data;/*存儲空間基地址/

intlength;/*順序表長度(即已存入的元素個數(shù))*/

intlistsize;/*當前存儲空間容量(卬能存入的元素個數(shù))*/

}sqlist;

voidA_B(sqlist*A,sqlist*B,sqlist*C)

(

inti,j,k=O;

i=A->length-l;

j=B->length-l;

while(i>=0)

(

if(A->data[i)>B->data[j])i-;

if(A->data[i]==B->data[j])

C->data[k++]A->data[i];

)

if(A->data[i]<B->data[j])j--;

)

C->length=k;

return;

)

或者

voidA_B_C(sqlist*A,sqlist*BZsqlist*C)

(

inti=OJ/k=O;

i=A->length-l;

while(i>=0)

(

for(j=B->length-l;j>=0;j—)

(

if(A->data[i]==B->data[j])

(

C->data[k++]=A->data[i];

break;

)

)

i-；

)

C->length=k;

return;

}

11、先寫出單鏈表的類型定義，然后編寫算法在帶頭結(jié)點單鏈表第i個結(jié)點的后面插入元素

x,插入成功返回1,插入失敗返回0。

參考答案如下：

〃類型定義

typedefintElemType;

typedefstructnode

{ElemTypedata;

structnode*next;

}slink;

intinsert(slink*L,inti,ElemTypex)

{slink*p,*s;

intj;

p=L->next;j=l;

/*找到第i個數(shù)據(jù)元素的存儲位置，使指針p指向它*/

while(p!=Nl-LL&&j<i)

{p=p->next;j++;}