C++----自己实现的链表

#pragma once
template<class T>
class Node
{
public :
T t;
Node<T>*pNext;
};

#include "StdAfx.h"
#include "Node.h"

#pragma once
#include"Node.h"
#include<iostream>
using namespace std;
template<class T>
class List
{
public:


List(void);
~List(void);
void add(T t);
void show();
Node<T> * find(T t);//查找
void change(Node<T> *p, T newt);//修改
void change(int pos, T newt);//修改
int getNum();
Node<T>* begin();
Node<T>*end();
bool deletet(T t);
void sort();
void deletesame();//删除相同的元素
bool clear();
void rev();


void insert(int pos, T newt);
void merge(List & list);
public:
Node<T>*pHead;
};

#include "StdAfx.h"
#include "List.h"


template<class T>
List<T>::List(void)
{
pHead=nullptr;
//pHead->pNext=nullptr;
}


template<class T>
List<T>::~List(void)
{
Node<T>* tmp = pHead; //用于操作的第三方指针
Node<T>* buf; //用于辅助delete操作
if (tmp != NULL)
{
while (tmp != NULL)
{
buf = tmp;
tmp = tmp->pNext;
delete buf;
}
}
/*if(pHead!=nullptr)
delete pHead;*/
}


template<class T>
void List<T>::add(T t){
Node<T>*p=new Node<T>;  
p->t=t;
p->pNext=nullptr;
if(pHead==nullptr){
  pHead=p;
}
else{
Node<T>*ptemp=pHead;
while(ptemp->pNext!=nullptr)
 {
ptemp=ptemp->pNext;
 }
  
  ptemp->pNext=p;
}




}
template<class T>
void List<T>::show(){
Node<T>*ptemp=pHead;
while(ptemp!=nullptr)
 {
 cout<<ptemp->t<<ends;
 ptemp=ptemp->pNext;
}




}
template<class T>
Node<T> *  List<T>::find(T t){
if(pHead!=nullptr){
Node<T>*ptemp=pHead;
while(ptemp!=nullptr)
 {
 if(ptemp->t==t){
 return ptemp;
 
 }
 ptemp=ptemp->pNext;
}
}
return nullptr;


}
template<class T>
void  List<T>::change(Node<T> *p, T newt){
p->t=newt;
}
template<class T>
Node<T>* List<T>::begin(){
   return pHead;


}
template<class T>
Node<T>* List<T>::end(){
Node<T>*ptemp=pHead;
while(ptemp->pNext!=nullptr){
 ptemp=ptemp->pNext;
}
return ptemp;
}
template<class T>
void List<T>::change(int pos, T newt){
if(pos<0|pos>=this->getNum()){
return;
}
else{
Node<T>*ptemp=pHead;
while(pos--){
ptemp=ptemp->pNext;
}
 ptemp->t=newt;
}


}
template<class T>
int List<T>::getNum(){
int count=0;
Node<T>*ptemp=pHead;
while(ptemp!=nullptr){
count++;
ptemp=ptemp->pNext;

}
return count;


}
template<class T>
bool List<T>::deletet(T t){
if(pHead==nullptr){
return false;
}
else{
Node<T>*ptemp=pHead;
if(pHead->t==t){
  delete pHead;
  pHead=nullptr;
  return true;
}
else{
while(ptemp->pNext!=nullptr){
if(ptemp->pNext->t==t){
Node<T>*p=ptemp->pNext;
    ptemp->pNext=p->pNext;
    delete p;
   return true;
   break;
}
ptemp=ptemp->pNext;
}

}


}
  return false;
}
template<class T>
void List<T>::sort(){
for(Node<T>*i=pHead;i!=nullptr;i=i->pNext)
for(Node<T>*j=i->pNext;j!=nullptr;j=j->pNext){
if(j->t<i->t)
{
 T temp;
 temp=i->t;
 i->t=j->t;
 j->t=temp;
}

}


}
template<class T>
void List<T>::deletesame(){
if(pHead!=nullptr)
{
this->sort();
Node<T>*ptemp=pHead;
while(ptemp->pNext!=nullptr){
if(ptemp->t==ptemp->pNext->t){

   Node<T>*p=ptemp->pNext;
    ptemp->pNext=p->pNext;
    delete p;
}
 ptemp=ptemp->pNext;
}
}
}
template<class T>
bool List<T>::clear(){
if(pHead!=nullptr){
Node<T>*p;
while(pHead!=nullptr)
{
 p=pHead;
 pHead=pHead->pNext;
 delete p;
 p=nullptr;
}
return true;
}
return false;
}
template<class T>
void List<T>::rev(){

if(pHead==nullptr||pHead->pNext==nullptr){

return ;
}
else{

Node<T>*ptemp=pHead->pNext;
Node<T> *p=pHead;
Node<T>*p1;
pHead->pNext=nullptr;
while(ptemp!=nullptr){

  p1=ptemp->pNext;
  ptemp->pNext=p;
  p=ptemp;
  ptemp=p1;
}
  pHead=p;
}
}
template<class T>
void List<T>::insert(int pos, T newt){
if(pos<0||pos>this->getNum())
{
 return;
}
else{
Node<T>*p=new Node<T>;
p->t=newt;
if(pos==0){
p->pNext=pHead;
pHead=p;
}
else if(pos==this->getNum())
{
 Node<T>*p1=pHead;
 while(p1->pNext!=nullptr){
 p1=p1->pNext;
 }
 p->pNext=nullptr;
 p1->pNext=p;
}
else{
Node<T>*p2=pHead;
while(--pos){
p2=p2->pNext;
}
  Node<T>*y=p2->pNext;
  p2->pNext=p;
  p->pNext=y;
}


}


}
template<class T>
void List<T>::merge(List& list){
if(pHead==nullptr){

pHead=list.pHead;
}
else{ Node<T>*p1=pHead;
Node<T>*p2;
while(p1!=nullptr){
   p2=p1;
  p1=p1->pNext;
}
p2->pNext=list.pHead;
}


}

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


int main(){
List<double> list;

list.add(3.5);
list.add(33.4);
list.add(23.1);
list.add(23.1);
list.add(1.453);
// list.merge(list1);
// list.insert(2,550);
// list.rev();
list.deletet(23.1);
list.show();
cout<<endl;
// list.sort();
// list.deletet(353);
 //list.deletesame();
//  list.show();
//  cout<<endl;
//  list.clear();
// cout<<list.getNum()<<endl;
//cout<<list.find(33)->t<<endl;
//list.change(1,330);
//list.show();
// cout<<endl;
//cout<<list.getNum()<<endl;


return 0;




}