实验报告群体类和群体数据模板.doc

学校代码: 10128
学 号: 20905060

《面向对象程序设计》试验汇报

（

题 目: 群体类和群体数据
学生姓名: 燕飞
学 院: 理学院
系 别: 数学系
专 业: 信息与计算科学
班 级: 信计12-2
任课老师: 侯睿

二 〇 一 五 年 十 一 月

一、 试验目
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（课程）类, 有属性: 课程名char name[21]、 成绩short score; 在试验七student类中增加属性; 所修课程course, 为课程类对象链表。在测试程序中测试这个类, 学生类与课程类关系如图

5、 将直接插入排序、 直接选择排序、 冒泡排序、 次序查找函数封装到第九章数组类中, 作为组员函数, 实现并测试这个类。
三、 试验程序
1、
#ifndef NODE_CLASS
#define NODE_CLASS
template
class Node
{
private:
Node *next;
public:
T data;
Node (const T& item, Node* ptrnext = NULL);
void InsertAfter(Node *p);
Node *DeleteAfter(void);
Node *NextNode(void) const;
};
template
Node::Node(const T& item, Node>* ptrnext) :
data(item), next(ptrnext)
{}
template
Node *Node::NextNode(void) const
{
return next;
}
template
void Node::InsertAfter(Node *p)
{
p->next = next;
next = p;
}
template
Node *Node::DeleteAfter(void)
{
Node tempPtr = next;
if (next == NULL)
return NULL;
next = tempPtr->next;
return tempPtr;
}
#endif
#ifndef NODE_LIBRARY
#define NODE_LIBRARY
#include
#include
#include "9_5.h"
using namespace std;
template
Node *GetNode(const T& item, Node *nextPtr = NULL)
{
Node *newNode;
newNode = new Node(item, nextPtr);
if (newNode == NULL)
{
cerr << "Memory allocation failure!" << endl;
exit(1);
}
return newNode;
}
enum AppendNewline {noNewline,addNewline};
template ss T>
void PrintList(Node *head, AppendNewline addnl = noNewline)
{
Node *currPtr = head;
while(currPtr != NULL)
{
if(addnl == addNewline)
cout << currPtr->data << endl;
else
cout << currPtr->data << " ";
currPtr = currPtr->NextNode();
}
}
template
int Find(Node *head, T& item, Node* &prevPtr)
{
Node *currPtr = head;
prevPtr = NULL;
while(currPtr != NULL)
{
if (currPtr->data == item)
return 1;
prevPtr = currPtr;
currPtr currPtr->NextNode();
}
return 0;
}
template
void InsertFront(Node* & head, T item)
{
head = GetNode(item,head);
}
template
void InsertRear(Node* & head, const T& 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
void DeleteFront(Node* & head)
{
Node *p = head;
if (head != NULL)
{
head = head->NextNode();
delete p;
}
}
template
void Delete (Node* & head, T key)
{
Node *currPtr = head, *prevPtr = NULL;
if (currPtr == NULL)
return;
while (currPtr != NULL && currPtr->data != key)
{
prevPtr = currPtr;
currPtr = currPtr->NextNode();
}
if (currPtr != NULL)
{
if(prevPtr == NULL)
head = head->NextNode();
else
prevPtr->DeleteAfter();
delete currPtr;
}
}
template
void InsertOrder(Node* & head, T item)
{
Node *currPtr, *prevPtr, *newNode;
prevPtr = NULL;
currPtr = head;
while (currPtr != NULL)
{
if (item < currPtr->data)
break;
prevPtr = currPtr;
currPtr = currPtr->NextNode();
}
if (prevPtr NULL)
InsertFront(head,item);
else
{
newNode = GetNode(item);
prevPtr->InsertAfter(newNode);
}
}
template
void ClearList(Node * &head)
{
Node *currPtr, *nextPtr;
currPtr = head;
while(currPtr != NULL)
{
nextPtr = currPtr->NextNode();
delete currPtr;
currPtr = nextPtr;
}
head = NULL;
}
#endif
#include
#include "9_5.h"
#include "node.h"
using namespace std;
int main()
{
Node *head = NULL, *prevPtr, *delPtr;
int i, key, item;
for (i=0;i < 10;i++)
{
cin>>item;
InsertFront(head, item);
}
cout << "List: ";
PrintList(head,noNewline);
cout << endl;
cout << "请输入一个需要删除整数: ";
cin >> key;
prevPtr = head;
while (Find(head,key,prevPtr) != NULL)
{
if(prevPtr == NULL)
head = head->NextNode();
else
delPtr=prevPtr->DeleteAfter();
delete delPtr;
}
cout << "List: ";
PrintList(head,noNewline);
cout << endl;
ClearList(head);
}
2、
#include "link.h"
int main()
{
LinkedList A, B;
for(int i=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();
}
cout << endl;
B.Reset();
cout << "链表B元素为: " ;
while(!B.EndOfList())
{
cout << B.Data() << " ";
B.Next();
}
cout << endl;
cout << "把B中元素插入A中..." << endl;
B.Reset();
while(!B.EndOfList())
{
A.InsertRear(B.Data());
B.Next();
}
A.Reset();
cout << "此时, 链表A元素为: " ;
while(!A.EndOfList())
{
cout << A.Data() << " ";
A.Next();
}
cout << endl;
}
#ifndef LINKEDLIST_CLASS
#define LINKEDLIST_CLASS
#include
#include
using namespace std;
#ifndef NULL
const int NULL = 0;
#endif // NULL
#include "9-3.h
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);
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<T>* ptrNext)
{
Node *p;
p = new Node(item,ptrNext);
if (p == NULL)
{
cout << "Memory allocation failure!\n";
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)
{
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
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;
}
template
void LinkedList::Reset(int pos)
{
int startPos;
if (front == NULL)
return;
if (pos < 0 || pos > size-1)
{
cerr << "Reset: Invalid list position: " << pos << endl;
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: invalid reference!" << endl;
exit(1);
}
return currPtr->data;
}
template
void LinkedList::InsertFront(const T& item)
{
if (front != NULL)
Reset();
InsertAt(item);
}
template
void LinkedList::InsertRear(const T& 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
void LinkedList::InsertAt(const T& 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
void LinkedList::InsertAfter(const T& 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
T LinkedList::DeleteFront(void)
{
T item;
Reset();
if (front == NULL)
{
cerr << "Invalid deletion!" << endl;
exit(1);

}
item = currPtr->data;
DeleteAt();
return item;
}
template
void LinkedList::DeleteAt(void)
{
Node *p;
if (currPtr == NULL)
{
cerr << "Invalid deletion!" << endl;
exit(1);
}
if (prevPtr == NULL)
{
p = front;
front = front->NextNode();
}
else
p = prevPtr->DeleteAfter();
if (p == rear)
{
rear = prevPtr;
position--;
}
currPtr = p->NextNode();
FreeNode(p);
size--;
}
#endif
3、
#ifndef QUEUE_CLASS
#define QUEUE_CLASS
#include
#include
using namespace std;
#include "link.h"
template
class Queue
{
private:
LinkedList queueList;
public:
Queue(void);
void QInsert(const T& elt);
T QDelete(void);
T QFront(void);
int QLength(void) const;
int QEmpty(void) const;
void QClear(void);
};
template
Queue::Queue(void)
{}
template
int Queue::QLength(void) const
{
return queueList.ListSize();
}
template
int Queue::QEmpty(void) const
{
return queueList.ListEmpty();
}
template
void Queue::QClear(void)
{
queueList.ClearList();
}
template
void Queue::QInsert(const T& elt)
{
queueList.InsertRear(elt);
}
template
T Queue::QDelete(void)
{
if (queueList.ListEmpty())
{
cerr << "Calling QDelete for an empty queue!" << endl;
exit(1);
}
return queueList.DeleteFront();
}
template
T Queue::QFront(void)
{
if (queueList.ListEmpty())
{
cerr << "Calling QFront for an empty queue!" << endl;
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 "9-3.h"
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);
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 << "Memory allocation failure!\n";
exit(1);
}
return p;
}
template
void LinkedList::FreeNode(Node *p)
{
delete p;
}
template
void Li