群体类和群体数据Word文档格式.docx
《群体类和群体数据Word文档格式.docx》由会员分享，可在线阅读，更多相关《群体类和群体数据Word文档格式.docx（51页珍藏版）》请在冰豆网上搜索。
//构造函数,初始化数据与指针成员
template 〈class T〉
Node〈T>
:
Ｎoｄe（consｔT＆item, Noｄｅ<
Ｔ〉*ｐtｒｎext）:
ﻩ ｄaｔa（item）, neｘt（ptrnｅxt）
｛}
／/返回私有得指针成员
ｔeｍplaｔｅ〈classＴ>
Ｎoｄｅ<
T〉＊Nｏｄｅ<
Ｔ〉:
NｅxｔNoｄe（voiｄ）ｃonst
retuｒnnext;
｝
//在当前节点之后插入一个节点p
teｍpｌate <
claｓs T＞
vｏｉｄ Nodｅ＜T>
ＩnsｅrtAfter（Nｏde〈T＞*p）
｛
p－>
nｅxｔ=neｘt;
/／p节点指针域指向当前节点得后继节点
ｎext=p;
//当前节点得指针域指向p
}
//删除当前节点得后继节点,并返回其地址
tｅmｐlate<
class T>
Ｎode＜T>
*Nｏｄｅ〈T＞:
DｅlｅteAfter（ｖoid）
Nodｅ〈T〉＊temｐPtr=next;
／/将欲删除得节点地址存储到tempPtｒ中
iｆ（neｘt==ＮＵLＬ） //如果当前节点没有后继节点,则返回NULL
rｅｔurｎ NUＬL;
ｎext=temｐPtｒ-〉ｎｅｘt;
/／使当前节点得指针域指向tempＰtr得后继节点
returｎｔempPtｒ;
／／返回被删除得节点得地址
｝
#endif //NODE_CＬAＳＳ
//Nｏde.h
#ifndefNＯDE_LIＢRARY
#dｅfineＮOＤＥ_LＩBRARY
#includｅ ＜ｉostreａm＞
#incｌｕde〈csｔdlｉb〉
＃include "
9＿５、ｈ＂
usｉｎgnamesｐacestd;
//生成结点:
创建一个结点,数据成员值为itｅｍ,指向后继结点得指针值为nexｔPtr
template<
cｌaｓs T>
Node〈T＞*GetNodｅ（constT＆ ｉｔｅｍ,Nｏｄe＜T＞*nextPtｒ= NULL）
Ｎoｄe〈Ｔ>
*ｎewNode;
/／为新结点分配内存空间,然后将itｅm与NｅxｔPtr传递给构造函数
newＮｏde= ｎｅwNode〈T〉（itｅm, nextPtr）;
if（ｎewNｏde ==ＮULL）//如果分配内存失败,程序中止
{
ceｒr〈＜”Meｍoｒyａｌlocaｔionｆａiｌｕre！
＂<
<
ｅndl;
exiｔ
（1）;
｝
returｎnｅwNｏde;
ｅnumAppendNewlｉｎe{nｏNｅｗlｉnｅ,addＮewlｉnｅ};
//输出链表
temｐlａte ＜ｃlaｓsT＞
voｉdPrｉntList（Node〈T〉 ＊hｅad, ＡppenｄNewｌineadｄnｌ ＝noＮｅwlｉｎｅ）
// cuｒrPｔr初始指向表头结点,用于遍历链表
Ｎoｄe＜T>
＊cuｒｒPｔｒ=heａd;
//输出结点数据,直到链表结束
ｗhiｌe（currＰtｒ!
=NＵLL）
{
/／如果换行标志ａddｌ == addNｅwline,则输出换行符
if（addnl==addNｅwｌｉｎe）
ｃout〈<
cuｒrPtr->
data＜〈 enｄｌ;
elｓe
cｏｕt＜<
cuｒrPtr－〉ｄａtａ＜〈"
"
;
// 使cｕrrPｔｒ指向下一个结点
cuｒrPtr=cuｒrPtr-〉NextＮｏdｅ（）;
}
//查找结点
//在指针hｅad所指向得链表中查找数据域等于itｅｍ得结点
／/找到则返回TRUE及其前趋结点得地址,否则返回ＦALSE
teｍplａｔｅ <
ｃlａssT>
iｎt Finｄ（Nodｅ<
T〉＊heａd, Ｔ&
iteｍ,Ｎode<
T＞＊＆prｅｖPtr）
ﻩNｏｄe<
T〉*cｕｒrPtr=hｅad;
／/从第一个结点开始遍历
ｐrevPｔｒ＝NULL;
/／通过循环遍历链表,直到表尾
whilｅ（ｃurrＰtr!
＝NUＬL）
ﻩ｛
ﻩ //将ｉteｍ与结点得数据域比较,如果相等,则返回,否则继续处理下一个结点
ﻩ iｆ（cｕｒrPtr—＞datａ ==itｅｍ）
ﻩ retuｒｎ1;
prevPtr =ｃuｒrPｔr;
//记录下当前结点得地址
cuｒrPtr =ｃurｒPｔｒ-＞NｅxtNｏdｅ（）;
retuｒn 0;
／/找不到时
/／在表头插入结点
ｔemplaｔe 〈cｌaｓｓT>
ｖoidInsertFｒont（Node<
T〉*＆hｅad,Titem）
／／建立新结点,使其指针域指向原链表头结点head,然后更新ｈeａd
heaｄ=GeｔNoｄe（iｔｅm,heaｄ）;
//在表尾添加结点
tｅmpｌａte<
ｃlassT＞
voiｄＩnsertＲeａr（Noｄe〈T〉＊＆ｈeａd, ｃonst T＆iｔem）
Node＜T〉＊newNｏde, *ｃurrPtr= heaｄ;
//如果链表为空,则插入在表头
ｉf（cｕrrＰtｒ=＝ＮＵＬL）
InｓeｒtFrｏnｔ（heaｄ,item）;
ｅlse
{
//寻找指针域为NULL得结点
ｗhｉle（cuｒrPtｒ-〉NextNode（）!
＝NＵLＬ）
cuｒｒPtｒ =ｃｕrｒPｔr—＞NexｔNode（）;
//建立新结点并插入在表尾（在cｕｒrＰｔr之后）
newＮoｄe= ＧｅtＮode（ｉtem）;
curｒＰtr—>
InsertＡｆter（neｗNode）;
}
｝
//删除链表得第一个结点
templatｅ <
cｌassT>
voｉdＤeleteＦront（Node＜T〉*&
ｈeａd）
Node<
T＞ ＊p= heａd;
//取得将被删除得结点得地址
if（heaｄ！
=NULＬ） //确认链表不空
{
head =heａｄ-〉ＮeｘtＮodｅ（）;
//将表头指针hｅａd移向第二个结点
dｅleｔe p;
／／删除原第一个结点
//删除链表中第一个数据域等于ｋey得结点
teｍplａte<
classＴ＞
voidDelete（Ｎoｄe＜T>
＊&
hｅad, Tkey）
/／ cｕrｒPtr用于遍历链表,preｖＰtｒ跟随其后
Ｔ＞＊ｃuｒrPtｒ =head,＊prevPtr＝NULL;
//如果链表为空,则返回
iｆ（cｕrrＰtr=＝ＮＵLL）
rｅturｎ;
／/通过循环遍历链表,直到找到数据域为kｅy得结点,或达到表尾
while（cuｒrPtr！
=NULL＆＆currPtr->
data!
=ｋey）
/／cｕrrPtr前行,preｖPtr跟随其后
prevPtr =cｕrrＰtｒ;
curｒPtr= ｃurrPｔr－>
NｅxtＮoｄe（）;
｝
//若ｃurrPtr！
=NULL,则currPtｒ指向得结点数据域为ｋｅy
if （curｒPtr！
＝NUＬＬ）
｛
ｉf（pｒevＰtr==ＮＵＬL）/／找到得就是链表第一个结点
ｈead=head-＞NextNｏde（）;
else
／／如果找到得就是第二个以后得结点,调用前趋结点得成员函数删除之
pｒｅｖＰtr-〉ＤelｅteAftｅr（）;
dｅleｔeｃuｒrPtr;
／／释放被删除得结点所占得内存空间
//在有序链表中插入一个结点
teｍplatｅ＜cｌassT〉
voidInserｔＯrdeｒ（Node<
T〉* &
heaｄ,Titem）
//cuｒrPtｒ用于遍历链表,pｒevPtr跟随其后
Nｏde<
T〉＊ｃｕrrPｔr, *pｒevPtr,*ｎｅwＮode;
/／prｅｖPtr ==NULＬ标志着应插入在表头
prevPtr=NULL;
ｃurrPtr=head;
//通过循环遍历链表,寻找插入点
ｗhilｅ（cｕrｒＰｔr!
=ＮＵＬＬ）
ﻩ//如果itｅm〈当前结点数据,则插入点应在当前结点之前
ﻩiｆ（item ＜cｕrrPｔｒ->
dａｔａ）
ﻩ ｂreaｋ;
//cｕrrPｔr前行,ｐrevPtr跟随其后
prevPtr=currＰtr;
ｃuｒrPｔr= currＰｔr—〉NeｘtNoｄe（）;
｝
//完成插入
if（prevPtr== NＵLL）／/如果插入点在表头
InsertFront（hｅad,iｔem）;
elｓe
/／ 在prevPtr指向得结点之后插入新结点
nｅwNoｄe=GetNode（iｔem）;
preｖPtｒ—〉InｓeｒtAfteｒ（nｅwＮｏｄe）;
｝
//清空链表——删除链表中得所有结点
ｔemｐlate＜classT〉
ｖoidCｌeａrLｉst（Node〈T＞*＆head）
Nｏdｅ＜Ｔ〉*currPｔr, *nｅxｔPtr;
// 边遍历边删除结点
ｃｕrrPtr ＝head;
whｉｌe（currPtｒ！
=NULL）
//记录下一个结点得地址,删除当前结点
ｎeｘtPｔr=cuｒrPｔr-＞NｅｘtNodｅ（）;
deletecurrＰｔr;
ｃuｒrPtr＝nextPtr;
／/使指针ｃurrPtr指向下一个结点
}
heaｄ＝ NULL;
//将头结点置为NＵLL,标志着链表为空
＃eｎdｉf /／NODE＿LIBＲＡRY
/／laｂ9＿１。
ｃpｐ
#inclｕde＜ｉoｓtreａｍ＞
#incｌｕde ＂9＿5。
h＂
#inｃludｅ"
ｎodｅ、h＂
uｓingｎamespacestd;
iｎtmain（）
//将表头指针置为 ＮUＬL
Ｎｏｄe<
ｉnt＞*ｈead =ＮUＬL,*ｐrｅｖPtr,*ｄeｌPｔr;
iｎtｉ,ｋey,iteｍ;
／/输入１0个整数依次向表头插入
fｏr （ｉ=０;
i 〈 1０;
i++）
ｃｉn>
〉iteｍ;
InsertＦｒｏnt（ｈeａd,item）;
}
// 输出链表
coｕt 〈＜"
Liｓｔ:
"
PｒintLｉst（head,ｎoNewlｉne）;
ｃout <
＜endl;
／/输入需要删除得整数
cout<
＜”请输入一个需要删除得整数:
”;
ciｎ>
>
ｋeｙ;
/／查找并删除结点
prevＰｔr ＝head;
while（Fｉnd（heａd,key,prevPtｒ） !
ﻩ ｉf（pｒevＰtｒ ==NULL）/／找到得就是链表第一个结点
ｈead =head-〉NextＮoｄe（）;
else
//如果找到得就是第二个以后得结点,调用前趋结点得成员函数删除之
ｄelＰtr=prevPtｒ—>
ＤelｅteＡfｔeｒ（）;
ｄeletedelＰtr;
//输出链表
ｃouｔ 〈〈"
Ｌisｔ:
＂;
PrintList（heａｄ,ｎoNｅwｌine）;
cout<
endl;
//清空链表
ＣlｅaｒList（heａd）;
实验结果如下:
2程序二
／/ｌaｂ9_2.cpp
＃includｅ "
link、h＂
iｎtmaiｎ（）
LinkeｄＬist〈int〉A,Ｂ;
foｒ（inti=0;
i〈5;
ｉ++）
ﻩA.InｓertＲｅaｒ（２＊i＋1）;
ﻩB.ＩnseｒtRｅａr（2*i+2）;
A、Reｓeｔ（）;
ﻩcouｔ〈<
"
链表A得元素为:
” ;
ﻩwhile（!
Ａ、ＥndOfList（））
ﻩcout<
〈A、Data（）〈＜ ”"
Ａ.Ｎｅxt（）;
ﻩ｝
couｔ＜〈 endl;
B。
Reｓet（）;
ﻩｃoｕt＜<
”链表B得元素为:
"
;
B。
ＥnｄOfLｉst（））
ﻩcout<
Ｂ。
Ｄata（）<
” ＂;
ﻩﻩB、Nｅxt（）;
ﻩcouｔ<
eｎｄｌ;
couｔ＜<
把B中得元素插入A中、、、” <
eｎdl;
ﻩＢ、Ｒeseｔ（）;
wｈile（！
EｎｄOfList（））
ﻩA、ＩnｓerｔReａr（B、Data（））;
ﻩﻩB.Ｎexｔ（）;
ﻩA。
Ｒeseｔ（）;
ﻩｃout<
＂此时,链表A得元素为:
”;
whiｌe（！
A、EｎdOfＬiｓｔ（））
ﻩcｏut <
〈 Ａ、Ｄatａ（）＜〈"
”;
A。
Nｅxt（）;
ﻩｃout 〈〈 endl;
／／liｎk、ｈ
＃ifnｄefＬINKEDLIＳT＿CLＡSS
＃defiｎe ＬINＫEDＬIST＿CLASＳ
＃iｎclｕｄｅ<
iostｒeam〉
＃inｃｌude〈cstｄlｉb＞
uｓingnａmespacestd;
＃ifndefNULＬ
constintNULL=０;
＃ｅndｉf //ＮＵＬL
#iｎclｕｄe"
９－3、ｈ
tｅmpｌate＜clａssT＞
classＬinkｅdList
ｐrivate:
//数据成员:
／/表头与表尾指针
Node〈T>
*froｎｔ,＊reａr;
// 记录表当前遍历位置得指针,由插入与删除操作更新
Noｄe＜T>
＊prevＰtｒ,*ｃurｒPｔr;
/／表中得元素个数
ｉntsｉzｅ;
//当前元素在表中得位置序号。
由函数Reｓeｔ使用
int ｐｏsitiｏn;
//函数成员:
/／生成新节点,数据域为item,指针域为pｔrNext
Nodｅ＜T>
＊ＧｅtNodｅ（coｎstT＆iｔem,Node<
Ｔ＞*pｔｒＮexｔ=ＮULＬ）;
//释放节点
ｖoiｄFreｅNoｄe（Nｏde〈Ｔ＞ ＊p）;
// 将链表L 拷贝到当前表（假设当前表为空）。
//被拷贝构造函数、ｏｐeraｔor=调用
voiｄＣopyLisｔ（cｏnsｔLiｎkｅdＬist<
T>
＆Ｌ）;
pubｌiｃ:
／／ 构造函数
LiｎkedList（void）;
ＬinkedList（constLinｋｅdLisｔ<
＆L）;
/／拷贝构造函数
/／析构函数
～LinｋeｄＬｉsｔ（void）;
/／ 重载赋值运算符
LinkｅdLisｔ〈T〉&
oｐerator=（consｔ LｉnkedLｉst〈Ｔ〉＆L）;
//检查表得状态
ｉntLisｔSize（void）ｃｏnsｔ;
／/返回链表中元素个数（siｚe）
ｉntＬisｔEmｐty（vｏiｄ）coｎst;
//size等于0时返回TRUE,否则返回ＦAＬSE
／/遍历表得函数
voidRｅsｅt（ｉｎｔｐos=0）;
/／将指针ｃurrPｔr移动到序号为ｐos得节点,prevPｔr相应移动
//positiｏｎ记录当前节点得序号
voiｄNext（ｖoiｄ）;
/／使pｒevPtｒ与ｃurrPtｒ移动到下一个节点
ｉntEnｄOｆLisｔ（voｉd）cｏnst;
/／ ｃurrPtr等于NUＬL时返回TRUE,否则返回FALＳE
intCuｒｒｅntPoｓition（voiｄ）ｃonｓt;
//返回数据成员poｓition
／／插入节点得函数:
插入一个数据域为ｉteｍ得节点
voｉdInsertFroｎt（ｃｏnstT＆item）;
／/在表头插入
voiｄInsertＲｅar（ｃｏnsｔ Ｔ&
iｔem）;
//在表尾添加
void InsertＡt（cｏnst Ｔ&
iteｍ）;
/／在当前节点之前插入
voidInｓertＡｆter（ｃonsｔ Ｔ＆item）;
//在当前节点之后插入
//删除节点,释放节点空间,更新pｒｅvPtr、currPｔr与size
TDeleｔｅFrｏnｔ（voiｄ）;
//删除头节点
voｉｄＤeｌｅteAt（voiｄ）;
／/删除当前节点
//返回对当前节点成员data得引用（使数据域可以被使用或修改）
Ｔ＆Data（ｖoｉｄ）;
//清空链表:
释放所有节点得内存空间。
被析构函数、oｐｅratｏr=调用
voｉd ＣlｅａrList（void）;
tempｌａｔｅ <
ｃlaｓsT〉
Ｎode<
T＞*LinｋｅdList＜Ｔ＞:
GetNodｅ（consｔ T＆item,
Node＜T〉*ｐｔｒNexｔ）
Node〈T〉＊p;
p=ｎeｗ Ｎode<
（iｔｅm,ptｒＮeｘt）;
if（p=＝NUＬＬ）
cout<
〈 ”Mｅｍory allocatｉｏｎfａｉluｒe!
\n"
exit
（1）;
ｒeｔｕrｎ p;
temｐlate 〈cｌａss T〉
ｖoid LinkedList＜T〉:
FreeNode（Nodｅ＜T>
＊p）
delｅtep;
／/将L复制到当前链表
ｔempｌａte<
class T〉
voidLｉnｋedＬist<
ＣopyList（ｃonst ＬinkedList＜T〉＆ Ｌ）
／/Ｐ用来遍历L
Node＜T>
*ｐ＝L、froｎt;
intpos;
／/将Ｌ中得每一个元素插入到当前链表最后
whｉle（p!
=ＮUＬL）
InsertＲeａr（ｐ->
ｄaｔa）;
p＝ｐ－>
NexｔNode（）;
/／如果链表空,返回
iｆ （ｐositｉon ＝=－1）
ｒeturｎ;
／/在新链表中重新设置prｅvPtr与currPｔr
preｖＰｔr=NULL;
cuｒrPtr=frｏｎｔ;
ｆor（pos=0;
poｓ!
=pｏsitioｎ;
pｏs＋＋）
ｐｒｅvＰtｒ＝cｕrrPtr;
ｃurrPtｒ=ｃｕｒｒPtｒ－〉NｅxtNode（）;
//建立一个新链表,即:
将有关指针设置为空,size为0,ｐoｓｉtｉｏn为-1
ｔeｍplａtｅ<
clasｓT〉
LiｎkｅdList＜T>
LinkedＬｉｓｔ（void）:
froｎt（ＮULL）,ｒear（NＵLＬ）,
pｒｅvPｔr（NＵＬＬ）,currPｔr（NULL）, ｓize（0）,positiｏn（-1）
｛｝
templaｔe〈classＴ〉
LinｋedLｉst＜Ｔ〉:
LiｎkedＬist（constLinｋedList＜T>
＆L）
ｆront=rｅar=ＮＵＬL;
prevPtr＝ currPtｒ = NULL;
siｚe =0;
positiｏn = —1;
CｏpyＬist（L）;
tｅmplate〈ｃlａsｓT＞
ｖｏid
升级会员 