单链表逆序

实现一：

#include "stdafx.h"
#include <iostream>
using namespace std;

template <typename T>
struct MyNode
{
T id;
MyNode * next;
MyNode(T _id)
{
id = _id;
next = NULL;
}
};

template <typename T>
class MyList
{
MyNode<T> * head;
MyNode<T> * current;
public:
MyList() : head(NULL) {}
void add(T value)
{
MyNode<T>* node = new MyNode<T>(value);
if(head == NULL)
{
head = node;
current = head;
}
else
{
current->next = node;
current = node;
}
}
void showAll()
{
MyNode<T> *go = head;
while(go != NULL)
{
cout<<go->id<<endl;
go = go->next;
}

}
void reverse()
{
MyNode<T> *preNode = NULL;
MyNode<T> *currentNode = head;
MyNode<T> *nextNode = head->next;
while(true)
{
nextNode = currentNode->next;
currentNode->next = preNode;
preNode = currentNode;
currentNode = nextNode;
if(currentNode->next == NULL)
{
head = currentNode;
head->next = preNode;
break;
}
}
}
};


int main(int argc, char * argv[])
{
MyList<int> *list = new MyList<int>();
list->add(123);
list->add(456);
list->add(789);
list->showAll();
list->reverse();
cout<<"after reverse:"<<endl;
list->showAll();
system("pause");
return 0;
}

实现二：

#include<iostream>
#include<conio.h>
#include<list>
using namespace std;

template<class T>
struct Node{
T value;
struct Node<T>* next;
Node(const T& v):value(v),next(NULL){}
~Node(){
delete next;
next=NULL;
cout<<"~Node()"<<endl;
}
};

template<class T,class N>
class Iterator{
public:
Iterator(T v=NULL):t(v){}
T& operator++()const{
t=t->next;
return t;
}
const N& operator*()const{
return t->value;
}
N&operator*(){
return t->value;
}
const T& getT()const{
return t;
}
Iterator& operator=(Iterator& other){
t=other.getT();
return *this;
}
const Iterator& operator=(Iterator& other)const{
t=other.getT();
return *this;
}
private:
mutable T t;
};

template<class T,class N>
bool operator!=(Iterator<T,N> i1,Iterator<T,N> i2){
return i1.getT()!=i2.getT();
}

template<class T>
class NList{
public:
typedef Iterator<Node<T>*,T> iterator;
typedef const Iterator<Node<T>*,T> const_iterator;
NList(const T& value){
head=tail=new Node<T>(value);
}
void addNode(const T& value){
tail->next=new Node<T>(value);
tail=tail->next;
}
iterator begin(){
return iterator(head);
}

iterator end(){
return iterator(tail->next);
}
void reverse(){
if(head==tail)
return ;
Node<T>* end=head,*begin=tail;
Node<T>* p1=head,*p2,*p3;
p2=p1->next;
p1->next=NULL;
while(p2!=tail){
p3=p2->next;
p2->next=p1;
p1=p2;
p2=p3;
}
p2->next=p1;
head=begin,tail=end;
}
~NList(){
delete head;
head=NULL;
tail=NULL;
cout<<"~NList()"<<endl;
}
private:
Node<T>* head;
Node<T>* tail;
};

int main(){
NList<int> nlist(1);
nlist.addNode(2);
nlist.addNode(3);
NList<int>::const_iterator p=nlist.begin(),end=nlist.end();
for(p=nlist.begin();p!=end;++p)
cout<<*p<<endl;
nlist.reverse();
end=nlist.end();
for(p=nlist.begin();p!=end;++p)
cout<<*p<<endl;
getch();
return 0;
}