实验报告4：群体类和群体数据(4)

{

queueList.InsertRear(elt); }

template

T Queue::QDelete(void) {

if (queueList.ListEmpty()) {

cerr << \ exit(1); }

return queueList.DeleteFront(); }

template

T Queue::QFront(void) {

if (queueList.ListEmpty()) {

cerr << \ exit(1); }

queueList.Reset();

return queueList.Data(); }

#endif

#ifndef LINKEDLIST_CLASS #define LINKEDLIST_CLASS #include #include using namespace std; #ifndef NULL

const int NULL = 0; #endif

#include \template class LinkedList {

private:

Node *front, *rear;

Node *prevPtr, *currPtr; int size; int position;

Node *GetNode(const T& item,Node *ptrNext=NULL); void FreeNode(Node *p);

16

void CopyList(const LinkedList& L); public:

LinkedList(void);

LinkedList(const LinkedList& L); ~LinkedList(void);

LinkedList& operator= (const LinkedList& L); int ListSize(void) const; int ListEmpty(void) const; void Reset(int pos = 0); void Next(void);

int EndOfList(void) const;

int CurrentPosition(void) const; void InsertFront(const T& item); void InsertRear(const T& item); void InsertAt(const T& item); void InsertAfter(const T& item); T DeleteFront(void); void DeleteAt(void); T& Data(void);

void ClearList(void); };

template

Node *LinkedList::GetNode(const T& item, Node* ptrNext) {

Node *p;

p = new Node(item,ptrNext); if (p == NULL) {

cout << \ exit(1); }

return p; }

template

void LinkedList::FreeNode(Node *p) {

delete p; }

template

void LinkedList::CopyList(const LinkedList& L) {

Node *p = L.front; int pos;

while (p != NULL)

17

{

InsertRear(p->data); p = p->NextNode(); }

if (position == -1) return;

prevPtr = NULL; currPtr = front;

for (pos = 0; pos != position; pos++) {

prevPtr = currPtr;

currPtr = currPtr->NextNode(); } }

template

LinkedList::LinkedList(void): front(NULL), rear(NULL), prevPtr(NULL),currPtr(NULL), size(0), position(-1) {}

template

LinkedList::LinkedList(const LinkedList& L) {

front = rear = NULL;

prevPtr = currPtr = NULL; size = 0;

position = -1; CopyList(L); }

template

void LinkedList::ClearList(void) {

Node *currPosition, *nextPosition; currPosition = front;

while(currPosition != NULL) {

nextPosition = currPosition->NextNode(); FreeNode(currPosition);

currPosition = nextPosition; }

front = rear = NULL;

prevPtr = currPtr = NULL; size = 0;

position = -1; }

template

18

LinkedList::~LinkedList(void) {

ClearList(); }

template

LinkedList& LinkedList::operator= (const LinkedList& L) {

if (this == &L) return *this; ClearList(); CopyList(L); return *this; }

template

int LinkedList::ListSize(void) const {

return size; }

template

int LinkedList::ListEmpty(void) const {

return size == 0; }

template

void LinkedList::Next(void) {

if (currPtr != NULL) {

prevPtr = currPtr;

currPtr = currPtr->NextNode(); position++; } }

template

int LinkedList::EndOfList(void) const {

return currPtr == NULL; }

template

int LinkedList::CurrentPosition(void) const {

return position; }

19

template

void LinkedList::Reset(int pos) {

int startPos;

if (front == NULL) return;

if (pos < 0 || pos > size-1) {

cerr << \ return; }

if(pos == 0) {

prevPtr = NULL; currPtr = front; position = 0; } else {

currPtr = front->NextNode(); prevPtr = front; startPos = 1;

for(position=startPos; position != pos; position++) {

prevPtr = currPtr;

currPtr = currPtr->NextNode(); } } }

template

T& LinkedList::Data(void) {

if (size == 0 || currPtr == NULL) {

cerr << \ exit(1); }

return currPtr->data; }

template

void LinkedList::InsertFront(const T& item) {

if (front != NULL) Reset();

20

百度搜索“77cn”或“免费范文网”即可找到本站免费阅读全部范文。收藏本站方便下次阅读，免费范文网，提供经典小说综合文库实验报告4：群体类和群体数据(4)在线全文阅读。