实验4 群体类和群体大数据 吕恩在.docx

实验4 群体类和群体大数据 吕恩在.docx

《实验4 群体类和群体大数据 吕恩在.docx》由会员分享，可在线阅读，更多相关《实验4 群体类和群体大数据 吕恩在.docx（28页珍藏版）》请在冰豆网上搜索。

实验4群体类和群体大数据吕恩在

学校代码：

学号：

《面向对象程序设计》实验报告

（

题目：

群体类和群体数据

学生姓名：

学院：

系别：

专业：

班级：

任课教师：

二〇一五年十二月

群体类和群体数据

一、实验目的

1.了解节点类的声明和实现，学习其使用方法

2.了解链表类的声明和实现，学习其使用方法

3.了解栈类的声明和实现，学习其使用方法

4.了解队列类的声明和实现，学习其使用方法

5.掌握对数组元素排序的方法

6.掌握对数组元素查找的方法

二、实验任务

1.编写程序Node.h实现例9-5的节点类，并编写测试程序lab9_1.cpp，实现链表的基本操作

2.编写程序link.h实现例9-6的链表类，在测试程序lab_2.cpp中声明两个整型链表A和B，分别插入5元素，然后把B中的元素加入A的尾部

3.编写程序queue.h，用链表实现队列（或栈），在测试程序lab9_3.cpp中声明一个整型队列（或栈）对象，插入5个整数，压入队列（或栈），再依次取出并显示出来。

4.（选做）声明course（课程）类，有属性：

课程名charname[21]、成绩shortscore；在实验七的student类中增加属性；所修课程course，为课程类对象的链表。

在测试程序中测试这个类，学生类与课程类关系如图

5.将直接插入排序、直接选择排序、冒泡排序、顺序查找函数封装到第九章的数组类中，作为成员函数，实现并测试这个类

三、实验内容：

1.//9-5.h

#ifndefNODE_CLASS

#defineNODE_CLASS

template

classNode

{

private:

Node*next;//指向后继节点的指针

public:

Tdata;//数据域

Node（constT&item,Node*ptrnext=NULL）;

voidInsertAfter（Node*p）;

Node*DeleteAfter（void）;

Node*NextNode（void）const;

};

template

Node:

:

Node（constT&item,Node*ptrnext）:

data（item）,next（ptrnext）

{}

template

Node*Node:

:

NextNode（void）const

{

returnnext;

}

template

voidNode:

:

InsertAfter（Node*p）

{

p->next=next;//p节点指针域指向当前节点的后继节点

next=p;//当前节点的指针域指向p

}

template

Node*Node:

:

DeleteAfter（void）

{

Node*tempPtr=next;//将欲删除的节点地址存储到tempPtr中

if（next==NULL）//如果当前节点没有后继节点，则返回NULL

returnNULL;

next=tempPtr->next;//使当前节点的指针域指向tempPtr的后继节点

returntempPtr;//返回被删除的节点的地址

}

#endif//NODE_CLASS

//Node.h

#ifndefNODE_LIBRARY

#defineNODE_LIBRARY

#include

#include

#include"9_5.h"

usingnamespacestd;

template

Node*GetNode（constT&item,Node*nextPtr=NULL）

{

Node*newNode;

newNode=newNode（item,nextPtr）;

if（newNode==NULL）//如果分配内存失败，程序中止

{

cerr<<"Memoryallocationfailure!

"<

exit

（1）;

}

returnnewNode;

}

enumAppendNewline{noNewline,addNewline};

template

voidPrintList（Node*head,AppendNewlineaddnl=noNewline）

{

Node*currPtr=head;

while（currPtr!

=NULL）

{

if（addnl==addNewline）

cout<data<

else

cout<data<<"";

currPtr=currPtr->NextNode（）;

}

}

template

intFind（Node*head,T&item,Node*&prevPtr）

{

Node*currPtr=head;//从第一个结点开始遍历

prevPtr=NULL;

while（currPtr!

=NULL）

{

if（currPtr->data==item）

return1;

prevPtr=currPtr;//记录下当前结点的地址

currPtr=currPtr->NextNode（）;

}

return0;//找不到时

}

template

voidInsertFront（Node*&head,Titem）

{

head=GetNode（item,head）;

}

template

voidInsertRear（Node*&head,constT&item）

{

Node*newNode,*currPtr=head;

if（currPtr==NULL）

InsertFront（head,item）;

else

{

while（currPtr->NextNode（）!

=NULL）

currPtr=currPtr->NextNode（）;

newNode=GetNode（item）;

currPtr->InsertAfter（newNode）;

}

}

template

voidDeleteFront（Node*&head）

{

Node*p=head;//取得将被删除的结点的地址

if（head!

=NULL）//确认链表不空

{

head=head->NextNode（）;//将表头指针head移向第二个结点

deletep;//删除原第一个结点

}

}

template

voidDelete（Node*&head,Tkey）

{

Node*currPtr=head,*prevPtr=NULL;

if（currPtr==NULL）

return;

while（currPtr!

=NULL&&currPtr->data!

=key）

{

//currPtr前行，prevPtr跟随其后

prevPtr=currPtr;

currPtr=currPtr->NextNode（）;

}

if（currPtr!

=NULL）

{

if（prevPtr==NULL）//找到的是链表第一个结点

head=head->NextNode（）;

else

prevPtr->DeleteAfter（）;

deletecurrPtr;//释放被删除的结点所占的内存空间

}

}

template

voidInsertOrder（Node*&head,Titem）

{

Node*currPtr,*prevPtr,*newNode;

prevPtr=NULL;

currPtr=head;

while（currPtr!

=NULL）

{

if（itemdata）

break;

//currPtr前行，prevPtr跟随其后

prevPtr=currPtr;

currPtr=currPtr->NextNode（）;

}

if（prevPtr==NULL）//如果插入点在表头

InsertFront（head,item）;

else

{

newNode=GetNode（item）;

prevPtr->InsertAfter（newNode）;

}

}

template

voidClearList（Node*&head）

{

Node*currPtr,*nextPtr;

currPtr=head;

while（currPtr!

=NULL）

{

nextPtr=currPtr->NextNode（）;

deletecurrPtr;

currPtr=nextPtr;//使指针currPtr指向下一个结点

}

head=NULL;//将头结点置为NULL，标志着链表为空

}

#endif//NODE_LIBRARY

//lab9_1.cpp

#include

#include"9_5.h"

#include"node.h"

usingnamespacestd;

intmain（）

{

Node*head=NULL,*prevPtr,*delPtr;

inti,key,item;

for（i=0;i<10;i++）

{

cout<<"pleaseinput"<

"<

cin>>item;

InsertFront（head,item）;

}

cout<<"List:

";

PrintList（head,noNewline）;

cout<

cout<<"请输入一个需要删除的整数:

";

cin>>key;

prevPtr=head;

while（Find（head,key,prevPtr）!

=NULL）

{

if（prevPtr==NULL）//找到的是链表第一个结点

head=head->NextNode（）;

else

delPtr=prevPtr->DeleteAfter（）;

deletedelPtr;

}

cout<<"List:

";

PrintList（head,noNewline）;

cout<

ClearList（head）;

}

运行结果：

pleaseinput1numberToinsertaheader:

1

pleaseinput2numberToinsertaheader:

2

pleaseinput3numberToinsertaheader:

3

pleaseinput4numberToinsertaheader:

4

pleaseinput5numberToinsertaheader:

5

pleaseinput6numberToinsertaheader:

6

pleaseinput7numberToinsertaheader:

7

pleaseinput8numberToinsertaheader:

8

pleaseinput9numberToinsertaheader:

9

pleaseinput10numberToinsertaheader:

10

List:

10987654321

请输入一个需要删除的整数:

2

List:

1098765431

2.//link.h

#ifndefLINKEDLIST_CLASS

#defineLINKEDLIST_CLASS

#include

#include

usingnamespacestd;

#ifndefNULL

constintNULL=0;

#endif//NULL

#include"9_5.h"

template

classLinkedList

{

private:

Node*front,*rear;

Node*prevPtr,*currPtr;

intsize;

intposition;

Node*GetNode（constT&item,Node*ptrNext=NULL）;

voidFreeNode（Node*p）;

voidCopyList（constLinkedList&L）;

public:

LinkedList（void）;

LinkedList（constLinkedList&L）;//拷贝构造函数

~LinkedList（void）;

LinkedList&operator=（constLinkedList&L）;

intListSize（void）const;//返回链表中元素个数（size）

intListEmpty（void）const;//size等于0时返回TRUE,否则返回FALSE

voidReset（intpos=0）;

voidNext（void）;//使prevPtr和currPtr移动到下一个节点

intEndOfList（void）const;

intCurrentPosition（void）const;//返回数据成员position

voidInsertFront（constT&item）;//在表头插入

voidInsertRear（constT&item）;//在表尾添加

voidInsertAt（constT&item）;//在当前节点之前插入

voidInsertAfter（constT&item）;//在当前节点之后插入

TDeleteFront（void）;//删除头节点

voidDeleteAt（void）;//删除当前节点

T&Data（void）;

voidClearList（void）;

};

template

Node*LinkedList:

:

GetNode（constT&item,

Node*ptrNext）

{

Node*p;

p=newNode（item,ptrNext）;

if（p==NULL）

{

cout<<"Memoryallocationfailure!

\n";

exit

（1）;

}

returnp;

}

template

voidLinkedList:

:

FreeNode（Node*p）

{

deletep;

}

template

voidLinkedList:

:

CopyList（constLinkedList&L）

{

Node*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->NextNode（）;

}

}

template

LinkedList:

:

LinkedList（void）:

front（NULL）,rear（NULL）,

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

{}

template

LinkedList:

:

LinkedList（constLinkedList&L）

{

front=rear=NULL;

prevPtr=currPtr=NULL;

size=0;

position=-1;

CopyList（L）;

}

template

voidLinkedList:

:

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

LinkedList:

:

~LinkedList（void）

{

ClearList（）;

}

template

LinkedList&LinkedList:

:

operator=

（constLinkedList&L）

{

if（this==&L）//不能将链表赋值给它自身

return*this;

ClearList（）;

CopyList（L）;

return*this;

}

template

intLinkedList:

:

ListSize（void）const

{

returnsize;

}

template

intLinkedList:

:

ListEmpty（void）const

{

returnsize==0;

}

template

voidLinkedList:

:

Next（void）

{

if（currPtr!

=NULL）

{

prevPtr=currPtr;

currPtr=currPtr->NextNode（）;

position++;

}

}

template

intLinkedList:

:

EndOfList（void）const

{

returncurrPtr==NULL;

}

template

intLinkedList:

:

CurrentPosition（void）const

{

returnposition;

}

template

voidLinkedList:

:

Reset（intpos）

{

intstartPos;

if（front==NULL）

return;

if（pos<0||pos>size-1）

{

cerr<<"Reset:

Invalidlistposition:

"<

<

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<<"Data:

invalidreference!

"<

exit

（1）;

}

returncurrPtr->data;

}

template

voidLinkedList:

:

InsertFront（constT&item）

{

if（front!

=NULL）

Reset（）;

InsertAt（item）;//在表头插入

}

template

voidLinkedList:

:

InsertRear（constT&item）

{

Node*newNode;

prevPtr=rear;

newNode=GetNode（item）;//创建新结点

if（rear==NULL）//如果表空则插入在表头

front=rear=newNode;

else

{

rear->InsertAfter（newNode）;

rear=newNode;