实验群体类和群体数据吕恩在.docx
《实验群体类和群体数据吕恩在.docx》由会员分享，可在线阅读，更多相关《实验群体类和群体数据吕恩在.docx（24页珍藏版）》请在冰豆网上搜索。
实验群体类和群体数据吕恩在
（
题目：
群体类和群体数据
学生姓名：
学院：
系别：
专业：
班级：
任课教师：
二〇一五年十二月
群体类和群体数据
一、实验目的
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;
}
currPtr=rear;
position=size;
size++;
}
template
voidLinkedList:
:
InsertAt（constT&item）
{
Node*newNode;
if（prevPtr==NULL）
{
newNode=GetNode（item,front）;
front=newNode;
}
else
{
newNode=GetNode（item）;
prevPtr->InsertAfter（newNode）;
}
if（prevPtr==rear）
{
rear=newNode;
position=size;
}
currPtr=newNode;
size++;
}
template
voidLinkedList:
:
InsertAfter（constT&item）
{
Node*p;
p=GetNode（item）;
if（front==NULL）//向空表中插入
{
front=currPtr=rear=p;
position=0;
}
else
{
if（currPtr==NULL）
currPtr=prevPtr;
currPtr->InsertAfter（p）;
if（currPtr==rear）
{
rear=p;
position=size;
}
else
position++;
prevPtr=currPtr;
currPtr=p;
}
size++;//使链表长度增值
}
template
TLinkedList:
:
DeleteFront（void）
{
Titem;
Reset（）;
if（front==NULL）
{
cerr<<"Invaliddeletion!
"<exit
（1）;
}
item=currPtr->data;
DeleteAt（）;
returnitem;
}
template
voidLinkedList:
:
DeleteAt（void）
{
Node*p;
if（currPtr==NULL）
{
cerr<<"Invaliddeletion!
"<exit
（1）;
}
if（prevPtr==NULL）
{
p=front;
front=front->NextNode（）;
}
else
p=prevPtr->DeleteAfter（）;
if（p==
升级会员 