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()
d73d
;
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;

}