c++学习笔记--链表类应用

#include<iostream>
using namespace std;
template<class T>
class LinkedList;
template<class T>
class Node{
public:
T data;


Node(const T &data,Node<T>*next=0);
void insertAfter(Node<T>*p);
Node<T>* deleteAfter();
Node<T>*nextNode();
const Node<T>* nextNode()const;
friend LinkedList<T>;
private:
Node<T>*next;
};
template<class T>
Node<T>::Node(const T &data,Node<T>*next):data(data),next(next){}
template<class T>
void Node<T>::insertAfter(Node<T>*p)
{
p->next = next;
next = p;
}
template<class T>
Node<T>* Node<T>::deleteAfter(){
Node<T>*tempPtr = next;
if(next == 0)
return 0;
next = tempPtr->next;
return tempPtr;
}
template<class T>
Node<T>* Node<T>::nextNode(){
return next;
}
template<class T>
const Node<T>* Node<T>::nextNode()const{
return next;
}
template<class T>
class LinkedList{


private:
Node<T>*front,*rear;
Node<T>*prevPtr,*currPtr;
int size;
int position;


Node<T>* nextNode(const T &item,Node<T>*ptrNext=NULL);
void freeNode(Node<T>*p);
void copy(const LinkedList<T>& L);
public:
void print();
LinkedList();
LinkedList<T>(const LinkedList<T>&L);
~LinkedList();
LinkedList<T>& operator=(const LinkedList<T>&L);


int getSize()const;
bool isEmpty()const;


void reset(int pos=0);
void next();
bool endOfList()const;
int currentPosition(void);


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<class T>
Node<T>* LinkedList<T>::nextNode(const T&item,Node<T>*ptrNext)
{
Node<T>*tempPtr = new Node<T>(item,ptrNext);
return tempPtr;


}
template<class T>
void LinkedList<T>::freeNode(Node<T>*p)
{
delete p;
}


template<class T>
void LinkedList<T>::print()
{
reset();
while(!endOflist())
{
cout<<data()<<"";
next();
}
cout<<endl;
cout<<"size="<<getSize()<<endl;


}
template<class T>
LinkedList<T>::LinkedList()
{
size = 0;
rear = new Node<T>(0);
front = rear;
prevPtr = front;
currPtr = prevPtr;
}
template<class T>
int LinkedList<T>::currentPosition(void)
{
Node<T>* tempPtr = front->nextNode();
position = 0;
while(tempPtr!=currPtr)
{
tempPtr = tempPtr -> nextNode();
position++;
}
return position;
}
template<class T>
int LinkedList<T>::getSize()const
{
return size;
}
template<class T>
T& LinkedList<T>::data()
{
return currPtr->data;
}
template<class T>
const T& LinkedList<T>::data()const
{
return currPtr->data;
}
template<class T>
void LinkedList<T>::next()
{
prevPtr = currPtr;
currPtr = currPtr -> nextNode();
}
template<class T>
bool LinkedList<T>::endOfList()const
{
if(currPtr == NULL)
return true;
else 
return false;
}
template<class T>
bool LinkedList<T>::isEmpty()const
{
if(front == rear)
return true;
else
return false;
}
template<class T>
void LinkedList<T>::reset(int pos)
{
prevPtr = front;
currPtr = front->nextNode();
position = pos;
for(int i=0;i<position;i++)
{
prevPtr = currPtr;
currPtr = currPtr -> nextNode();
}
}
template<class T>
void LinkedList<T>::insertFront(const T &item)
{
prevPtr = currPtr;
currPtr = nextNode(item,front->nextNode());
front->next = currPtr;
if(rear == front)
{
rear = currPtr;
}
size++;
}
template<class T>
void LinkedList<T>::insertRear(const T &item)
{
prevPtr = currPtr;
currPtr = nextNode(item,rear->nextNode());
rear -> next = currPtr;
rear = currPtr;
size++;
}
template<class T>
void LinkedList<T>::insertAt(const T &item)
{
currPtr = nextNode(item,prevPtr->nextNode());
prevPtr -> next = currPtr;
size++;
}
template<class T>
T LinkedList<T>::deleteFront()
{
currPtr = front->nextNode();
delete front;
front = currPtr;
size--;
return front->data;
}
template<class T>
void LinkedList<T>::deleteCurrent()
{
Node<T>* tempPtr = currPtr;
prevPtr ->deleteAfter();
delete currPtr;
currPtr = prevPtr;
size--;
}
template<class T>
void LinkedList<T>::clear()
{
Node<T>*tempPtr = front->nextNode();
while(tempPtr!=NULL)
{
Node<T>*tempQ = tempPtr;
tempPtr = tempPtr -> nextNode();
delete tempQ;
size--;
}
rear = front;
currPtr = prevPtr = front;
}
template<class T>
LinkedList<T>::~LinkedList()
{
clear();
delete front;
}
template<class T>
void LinkedList<T>::copy(const LinkedList<T>& L)
{
L.reset();
for(int i = 0;i<size;i++)
{
insertRear(L.data());
L.next();
}
}
template<class T>
LinkedList<T>& LinkedList<T>::operator=(const LinkedList<T>&L)
{
clear();
front->next = NULL;
copy(L);
cout<<"重载="<<endl;
return *this;
}
template<class T>
LinkedList<T>::LinkedList<T>(const LinkedList<T>&L)
{
size = 0;
rear = new Node<T>(0);
front = rear;
prevPtr = front;
currPtr = prevPtr;
cout<<"复制构造函数"<<endl;
}
int main()
{
LinkedList<int>list1;
cout<<"Please input the link a"<<endl;
LinkedList<int>list2;
for(int i=0;i<5;i++)
{
int item;
cin>>item;
list1.insertRear(item);
}
cout<<"a:";
list1.reset();
while(!list1.endOfList())
{
cout<<list1.data()<<" ";
list1.next();
}
cout<<endl;
cout<<"Please input the link b"<<endl;
for(int j = 0;j<5;j++)
{
int item;
cin>>item;
list2.insertRear(item);
list1.insertRear(item);
}
cout<<"b: ";
list2.reset();
while(!list2.endOfList())
{
cout<<list2.data()<<" ";
list2.next();
}
cout<<endl;
cout<<"在a中插入b后面 链表为：";
cout<<endl;
cout<<"a:";
list1.reset();
while(!list1.endOfList())
{
cout<<list1.data()<<" ";
list1.next();
}
cout<<endl;
return 0;
}