实验八 泛型程序设计Word文档格式.docx

实验八 泛型程序设计Word文档格式.docx

《实验八 泛型程序设计Word文档格式.docx》由会员分享，可在线阅读，更多相关《实验八 泛型程序设计Word文档格式.docx（34页珍藏版）》请在冰豆网上搜索。

LinkedList<

int>

A,B;

for（inti=0;

i<

5;

i++）

{

A.InsertRear（2*i+1）;

B.InsertRear（2*i+2）;

}

A.Reset（）;

cout<

<

"

链表A的元素为：

"

;

while（!

A.EndOfList（））

cout<

A.Data（）<

;

A.Next（）;

endl;

B.Reset（）;

链表B的元素为：

B.EndOfList（））

B.Data（）<

B.Next（）;

把B中的元素插入A中..."

<

A.InsertRear（B.Data（））;

此时，链表A的元素为：

}

#ifndefLINKEDLIST_CLASS

#defineLINKEDLIST_CLASS

#include<

iostream>

cstdlib>

usingnamespacestd;

#ifndefNULL

constintNULL=0;

#endif//NULL

9-3.h

template<

classT>

classLinkedList

private:

Node<

T>

*front,*rear;

*prevPtr,*currPtr;

intsize;

intposition;

*GetNode（constT&

item,Node<

*ptrNext=NULL）;

voidFreeNode（Node<

*p）;

voidCopyList（constLinkedList<

&

L）;

public:

LinkedList（void）;

LinkedList（constLinkedList<

~LinkedList（void）;

operator=（constLinkedList<

intListSize（void）const;

intListEmpty（void）const;

voidReset（intpos=0）;

voidNext（void）;

intEndOfList（void）const;

intCurrentPosition（void）const;

voidInsertFront（constT&

item）;

voidInsertRear（constT&

voidInsertAt（constT&

voidInsertAfter（constT&

TDeleteFront（void）;

voidDeleteAt（void）;

T&

Data（void）;

voidClearList（void）;

};

Node<

*LinkedList<

:

GetNode（constT&

item,

*ptrNext）

*p;

p=newNode<

（item,ptrNext）;

if（p==NULL）

Memoryallocationfailure!

\n"

exit

（1）;

returnp;

voidLinkedList<

FreeNode（Node<

*p）

deletep;

CopyList（constLinkedList<

L）

*p=L.front;

intpos;

while（p!

=NULL）

InsertRear（p->

data）;

p=p->

NextNode（）;

if（position==-1）

return;

prevPtr=NULL;

currPtr=front;

for（pos=0;

pos!

=position;

pos++）

prevPtr=currPtr;

currPtr=currPtr->

LinkedList<

LinkedList（void）:

front（NULL）,rear（NULL）,

prevPtr（NULL）,currPtr（NULL）,size（0）,position（-1）

{}

LinkedList（constLinkedList<

front=rear=NULL;

prevPtr=currPtr=NULL;

size=0;

position=-1;

CopyList（L）;

ClearList（void）

*currPosition,*nextPosition;

currPosition=front;

while（currPosition!

nextPosition=currPosition->

FreeNode（currPosition）;

currPosition=nextPosition;

~LinkedList（void）

ClearList（）;

operator=（constLinkedList<

if（this==&

L）

return*this;

ClearList（）;

intLinkedList<

ListSize（void）const

returnsize;

ListEmpty（void）const

returnsize==0;

Next（void）

if（currPtr!

position++;

EndOfList（void）const

returncurrPtr==NULL;

CurrentPosition（void）const

returnposition;

Reset（intpos）

intstartPos;

if（front==NULL）

if（pos<

0||pos>

size-1）

cerr<

Reset:

Invalidlistposition:

pos<

if（pos==0）

position=0;

else

currPtr=front->

prevPtr=front;

startPos=1;

for（position=startPos;

position!

=pos;

position++）

T&

Data（void）

if（size==0||currPtr==NULL）

Data:

invalidreference!

returncurrPtr->

data;

InsertFront（constT&

item）

if（front!

Reset（）;

InsertAt（item）;

InsertRear（constT&

*newNode;

prevPtr=rear;

newNode=GetNode（item）;

if（rear==NULL）

front=rear=newNode;

rear->

InsertAfter（newNode）;

rear=newNode;

currPtr=rear;

position=size;

size++;

InsertAt（constT&

if（prevPtr==NULL）

newNode=GetNode（item,front）;

front=newNode;

prevPtr->

if（prevPtr==rear）

currPtr=newNode;

InsertAfter（constT&

p=GetNode（item）;

front=currPtr=rear=p;

if（currPtr==NULL）

currPtr=prevPtr;

currPtr->

InsertAfter（p）;

if（currPtr==rear）

rear=p;

currPtr=p;

TLinkedList<

DeleteFront（void）

Titem;

Invaliddeletion!

item=currPtr->

DeleteAt（）;

returnitem;

DeleteAt（void）

p=front;

front=front->

p=prevPtr->

DeleteAfter（）;

if（p==rear）

rear=prevPtr;

position--;

currPtr=p->

FreeNode（p）;

size--;

#endif

2、

#ifndefQUEUE_CLASS

#defineQUEUE_CLASS

classQueue

queueList;

Queue（void）;

voidQInsert（constT&

elt）;

TQDelete（void）;

TQFront（void）;

intQLength（void）const;

intQEmpty（void）const;

voidQClear（void）;

Queue<

Queue（void）

intQueue<

QLength（void）const

returnqueueList.ListSize（）;

QEmpty（void）const

returnqueueList.ListEmpty（）;

voidQueue<

QClear（void）

queueList.ClearList（）;

QInsert（constT&

elt）

queueList.InsertRear（elt）;

TQueue<

QDelete（void）

if（queueList.ListEmpty（））

CallingQDeleteforanemptyqueue!

returnqueueList.DeleteFront（）;

QFront（void）

CallingQFrontforanemptyqueue!

queueList.Reset（）;

returnqueueList.Data（）;

9-3.h"

voidInsertAfter（constT&

item,Node<