链表定义(c++)

#include
#include
using namespace std;

template
class Node {
public:
Node *next; //指向后继结点的指针
T data; //数据域
Node (const T &data, Node *next = 0); //构造函数
void insertAfter(Node *p); //在本结点之后插入一个同类结点p
Node *deleteAfter(); //删除本结点的后继结点，并返回其地址
Node *nextNode(); //获取后继结点的地址
};

//类的实现部分
//构造函数，初始化数据和指针成员
template
Node::Node(const T& data, Node *next/* = 0 */) : data(data), next(next) { }

//返回后继结点的指针
template
Node *Node::nextNode() {
return next;
}

//在当前结点之后插入一个结点p
template
void Node::insertAfter(Node *p) {
p->next = next; //p结点指针域指向当前结点的后继结点
next = p; //当前结点的指针域指向p
}
//删除当前结点的后继结点，并返回其地址
template Node *Node::deleteAfter() {
Node *tempPtr = next; //将欲删除的结点地址存储到tempPtr中
if (next == 0) //如果当前结点没有后继结点，则返回空指针
return 0;
next = tempPtr->next; //使当前结点的指针域指向tempPtr的后继结点
return tempPtr; //返回被删除的结点的地址
}

template
class LinkedList {
private:
//数据成员：
Node *front, *rear;
Node *prevPtr, *currPtr;
int size;
int position;

Node *newNode(const T &item,Node *ptrNext=NULL);
void freeNode(Node *p);
void copy(const LinkedList& L);
public:
LinkedList();
LinkedList(const LinkedList &L);
~LinkedList();
LinkedList & operator = (const LinkedList &L);
int getSize() const;
bool isEmpty() const;
void reset();
void next();
bool endOfList() const;
int currentPosition() const;
void insertFront(const T &item);
void insertRear(const T &item);
void insertAt(const T &item);
void insertAfter(const T &item);
T deleteFront();
void deleteCurrent();
T& data();
// const T& data() const
void clear();
};
template
void LinkedList::freeNode(Node*p){
delete p;
}
template
Node * LinkedList::newNode(const T &item,Node *ptrNext){
Node * pt=new Node(item,ptrNext);
return pt;
}


template
LinkedList::LinkedList(){
front=currPtr=rear=0;
size=position=0;
}
template
int LinkedList::getSize() const{
return size;
}
template
bool LinkedList::isEmpty() const{
if(size==0)
return true;
else
return false;
}
template
void LinkedList::insertFront(const T &item){
Node * p=new Node(item);
if(size==0){
front=currPtr=rear=p;
// position=1;
// front->next=0;
}
else
{
p->next=front;
front=p;
}
size++;
position+=1;
}

template
int LinkedList::

currentPosition() const{
return position;
}
template
void LinkedList::insertRear(const T &item){

if(size==0)
insertFront(item);
else{
Node * p=new Node(item);
rear->next=p;
rear=p;
size++;
}
}
template
void LinkedList:: insertAt(const T &item){
if(front==currPtr)
insertFront(item);
Node* pa=front;
Node * p=new Node(item);
while(pa->next!=currPtr){
pa=pa->next;
}
pa->next=p;
p->next=currPtr;
currPtr=p;
size++;
}
template
void LinkedList:: insertAfter(const T &item){
if(currPtr==rear){
insertRear(item);
currPtr=rear;
}
else{
Node * p=new Node(item);
p->next=currPtr->next;
currPtr->next=p;
currPtr=p;
size++;
position++;
}
}
template
bool LinkedList::endOfList() const{
if(isEmpty())
exit(1); //assert(size!=0);
else if(currPtr->next==NULL)// currPtr==rear
return true;
else
return false;
}
template
T LinkedList:: deleteFront(){
if(size==0)
exit(1);
else if(size==1){
Node* pa=front;
front=rear=currPtr=0;
size=position=0;
return pa->data;
}
else
{
Node* pb=front;
front=front->next;
size--;
position-=1;
return pb->data;
}
}
template
void LinkedList:: deleteCurrent(){
if(front==currPtr) {
deleteFront();
}
else if(currPtr==rear){
Node* pa=front;
while(pa->next!=currPtr){
pa=pa->next;
}
pa->next=0;
rear=currPtr=pa;
size--;
position--;
}
else {
Node* pb=front;
while(pb->next!=currPtr){
pb=pb->next;
}
pb->next=currPtr->next;
currPtr=currPtr->next;
size--;
}
}
template
void LinkedList::next(){
if(currPtr==rear){
if(currPtr==NULL)
cout<<"This is an empty linkedlist"<else
cout<<"Here is end of linkedlist."<}
else
{
currPtr=currPtr->next;
position++;
}
}

template
void LinkedList:: reset(){
if(size==0)
cout<<"This is an empty linkedlist"<else{
position=1;
currPtr=front;
}
}
template
T& LinkedList:: data(){
if(currPtr==NULL)
exit(1);
return currPtr->data;
}
template
void LinkedList::clear(){
Node* pb=front;
while(pb!=0){
Node* pc=pb;
pb=pc->next;
freeNode(pc);
}
front=rear=currPtr=0;
size=position=0;
}
template
LinkedList:: ~LinkedList(){
clear();
}
template
void LinkedList::copy(const LinkedList &L)
{
Node* pb=L.front;
size=0;
for(int i=0;iinsertRear(pb->data);
if(i==L.position-1)
currPtr=rear;
pb=pb->next;
}
position=L.position;
}

template
LinkedList::LinkedList(const LinkedList&L){
copy(L);
}
template
LinkedList& LinkedList::operator =(const LinkedList&L){
clear();
copy(L);
return *this;
}
int main(){
LinkedList A;


/

* A.insertAt(4);
cout<{
if(A.endOfList())
cout<<"Yes"<else
cout<<"No"<}
cout<cout<
/*{A.insertAfter(8);
cout<cout<cout<}*/

/*{A.insertRear(10);
cout<cout<cout<}*/
/* {A.next();
cout<}*/
/*{A.reset();
cout<cout<}*/
cout<A.insertFront(28);
/*{cout<cout<cout<}*/
cout<cout<
A.insertFront(7);
cout<cout<cout<{
if(A.endOfList())
cout<<"Yes"<else
cout<<"No"<}
/* {A.deleteCurrent();
cout<cout<cout<}*/
{A.next();
cout<}
A.insertAt(4);
LinkedList B;
{B=A;
cout<cout<&L) & copy() & freeNode(Node*p)
cout<}
cout<{
if(A.endOfList())
cout<<"Yes"<else
cout<<"No"<}
cout<cout<
{A.insertAfter(8);
cout<cout<cout<

dl;
}
{A.insertRear(10);
cout<cout<cout<}


{A.deleteFront();
cout<cout<cout<}
{LinkedList C(A);
cout<cout<&L)
cout<}
{A.deleteCurrent();
cout<cout<cout<}
{A.next();
cout<cout<cout<}
{A.reset();
cout<cout<cout<}

{A.clear();
cout<cout<}


return 0;
}