线性表大作业任务书Word格式文档下载.docx
《线性表大作业任务书Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《线性表大作业任务书Word格式文档下载.docx（17页珍藏版）》请在冰豆网上搜索。
intlist[ML];
intsize;
intMAXSIZE;
}sqList;
sqList*Init_List（sqList*L,intms）;
voidDisp_List（sqList*L）;
intLocateElem_List（sqList*L,intx）;
intInsert_List（sqList*L,intx,intmark）;
intDelete_List1（sqList*L,intitem）;
intDelete_List2（sqList*L,intmark）;
sqList*Init_List（sqList*L,intms）{
L=（sqList*）malloc（ms*sizeof（sqList））;
if（!
L）{
printf（"
申¦
º
请?
内¨
²
存ä
?
空?
间?
出?
错ä
\n"
）;
exit（OVERFLOW）;
}
else
L->
size=0;
L->
MAXSIZE=ms;
returnL;
}
voidDisp_List（sqList*L）{
inti;
for（i=0;
i<
L->
size;
i++）
%d"
L->
list[i]）;
printf（"
intLocateElem_List（sqList*L,intx）{
inti=0;
=L->
if（L->
list[i]==x）
returni;
if（i>
size）
return-1;
intInsert_List（sqList*L,intx,intmark）{
inti=1;
if（L->
size>
MAXSIZE）
return-1;
if（mark>
0）{
for（i=L->
size+1;
i>
=mark;
i--）
L->
list[i+1]=L->
list[i];
list[i]=x;
elseif（mark<
0）
list[L->
size]=x;
size++;
returnFALSE;
intDelete_List1（sqList*L,intitem）{
inti,j;
if（item==L->
list[i]）
break;
if（i<
size）{
for（j=i+1;
j<
size-1;
j++）
list[j]=L->
list[j+1];
size--;
returni;
intDelete_List2（sqList*L,intmark）{
inti,item;
item=L->
list[mark];
for（i=mark+1;
list[i]=L->
list[i+1];
voidmain（）{
intp,n,x=0;
sqLista,*b;
b=Init_List（&
a,ML）;
listaddr=%d\tsize=%d\tMaxSize=%d"
b->
list,b->
size,b->
MAXSIZE）;
while
（1）{
\n请?
输º
入¨
值¦
Ì
，ê
0为a结¨
¢
束º
：
ê
o"
scanf（"
&
x）;
if（!
x）break;
插?
位?
置?
o\n"
p）;
Insert_List（b,x,p）;
\n线?
为a：
Disp_List（b）;
查¨
¦
找¨
°
0结¨
操¨
´
作Á
¡
Â
n=LocateElem_List（b,x）;
if（n<
0）printf（"
\n没?
到Ì
else
printf（"
\n又®
符¤
合?
条¬
件t的Ì
o%d\n"
n+1）;
删¦
除y值¦
n=Delete_List1（b,x）;
else{
\n删¦
除y成¨
功|，ê
线?
为a:
Disp_List（b）;
}
}
o结¨
:
p）break;
n=Delete_List2（b,p）;
if（p<
\n位?
越?
界?
Disp_List（b）;
2.实验运行图
3.算法分析：
（1）顺序表的初始化即是创造一个空表顺序表的初始化即构造一个空表，这对表是一个加工型的运算，因此，将L设为指针参数，首先动态分配存储空间，然后，将表中length指针置为0，表示表中没有数据元素。
算法如下：
StatusInitList_Sq（SqList*L）
L->
elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;
//分配存储空间
if（!
elem）exit（OVERFLOW）;
//存储分配失败
length=0;
//空表长度为0
listsize=LIST_INIT_SIZE;
//初始存储容量
returnOK;
} //InitList_Sq
此算法的时间复杂度为O
（1）。
（2）在顺序表中“查询”是否存在一个和给定值满足判定条件的元素的最简单的办法是，依次取出结构中的每个元素和给定值进行比较。
intLocateElem（SqListL,ElemTypee，void（*compare）（ElemType,ElemType））
{ //在顺序表L中查找第1个值与e满足判定条件compare（）的元素
//若找到，则返回其在L中的位序，否则返回0
i=1;
//i的初值为第1元素的位序
p=L.elem;
//p的初值为第1元素的存储位置
while（i<
=L.length&
&
!
（*compare）（*p++,e））
算法时间复杂度的分析：
算法中的基本操作是“判定”，它出现在while循环中，而函数compare（）的时间复杂度显然是个常量。
因此执行判定的次数取决于元素在线性表中的“位序”，至多和表长相同。
所以，此算法的时间复杂度为：
O（ListLength（L））。
（3）假设在线性表的第i个元素之前插入一个元素e，使得线性表
（a1，a2，...，ai-1，ai，ai+1，...，an）改变成为表长为n+1表:
（a1，a2，...，ai-1，e，ai，ai+1，...，an）。
即：
1、改变了表中元素之间的关系，使<
ai-1，ai>
改变为<
ai-1,e>
和<
e,ai>
2、表长增1
（4假设删除线性表中第i个元素，使得线性表：
（a1，a2，...，ai-1，ai，ai+1，...，an）；
改变成为表长为n-1的线性表：
（a1，a2，...，ai-1，ai+1，...，an）。
即：
ai，ai+1>
。
2、表长减1
实验二
1实验源程序
#include<
malloc.h>
#definenull0
typedefintElemType;
/*字Á
型¨
数º
y据Y*/
structLNode
ElemTypedata;
structLNode*next;
};
voidsetnull（structLNode**p）;
intlength（structLNode**p）;
ElemTypeget（structLNode**p,inti）;
voidinsert（structLNode**p,ElemTypex,inti）;
voiddele（structLNode**p,inti）;
voiddisplay（structLNode**p）;
intlocate（structLNode**p,ElemTypex）;
voidmain（）
structLNode*head,*q;
/*定¡
§
义°
静2态¬
变À
量¢
*/
intselect,x1,x2,x3,x4;
inti,n;
intm,g;
chare,y;
setnull（&
head）;
/*建¡
设¦
链¢
ä
并¡
é
为a空?
y据Y长¡
è
度¨
"
n）;
for（i=1;
=n;
{
将?
y据Y插?
单Ì
£
¤
中D:
scanf（"
y）;
insert（&
head,y,i）;
}/*插?
y据Y到Ì
display（&
/*显?
示º
所¨
有®
D数º
select1求¨
®
长¡
length（）\n"
select2取¨
结¨
点Ì
get（）\n"
select3求¨
locate（）\n"
select4删¦
除y结¨
delete（）\n"
select0退ª
inputyourselect:
select）;
while（select!
=0）
{switch（select）
case1:
{
x1=length（&
printf（"
的Ì
%d"
x1）;
display（&
}break;
case2:
要°
a取¨
得Ì
scanf（"
m）;
x2=get（&
head,m）;
x2）;
case3:
{
printf（"
a查¨
y据Y:
e）;
x3=locate（&
head,e）;
x3）;
case4:
a删¦
除y的Ì
g）;
dele（&
head,g）;
voidsetnull（structLNode**p）
*p=null;
intlength（structLNode**p）
intn=0;
structLNode*q=*p;
while（q!
=null）
n++;
q=q->
next;
return（n）;
ElemTypeget（structLNode**p,inti）
intj=1;
structLNode*q=*p;
while（j<
i&
q!
j++;
if（q!
return（q->
data）;
{printf（"
参?
y不?
正y确¨
!
return0;
intlocate（structLNode**p,ElemTypex）
while（q!
=null&
q->
data!
=x）
if（q==null）
return（-1）;
return（n+1）;
voidinsert（structLNode**p,ElemTypex,inti）
structLNode*s,*q;
s=（structLNode*）malloc（sizeof（structLNode））;
s->
data=x;
q=*p;
if（i==1）
s->
next=q;
*p=s;
while（j<
i-1&
next!
q=q->
j++;
}
if（j==i-1）
s->
next=q->
q->
next=s;
else
}
voiddele（structLNode**p,inti）
structLNode*q=*p,*t;
t=q;
*p=q->
if（q->
j==i-1）
t=q->
next=t->
if（t!
=null）
free（t）;
voiddisplay（structLNode**p）
{
structLNode*q;
显?
"
elseif（q->
next==null）
%d\n"
q->
while（q->
%d->
.
3.算法分析
（1）建立单链表
从一个空表开始，重复读入数据，生成新结点，将读入数据存放到新结点）的数据域中，然后将新结点插入到当前链表的表头上，直到读入结束标志为止。
即每次插入的结点都作为链表的第一个结点
（2）单链表的插入
插入运算是将值为e的新结点插入到表的第i个结点的位置上，即插入到ai-1与ai之间。
因此，必须首先找到ai-1所在的结点p，然后生成一个数据域为e的新结点q，q结点作为p的直接后继结点
水调歌头·
明月几时有
宋代：
苏轼
丙辰中秋，欢饮达旦，大醉，作此篇，兼怀子由。
明月几时有？
把酒问青天。
不知天上宫阙，今夕是何年。
我欲乘风归去，又恐琼楼玉宇，高处不胜寒。
起舞弄清影，何似在人间？
转朱阁，低绮户，照无眠。
不应有恨，何事长向别时圆？
人有悲欢离合，月有阴晴圆缺，此事古难全。
但愿人长久，千里共婵娟。
升级会员 