C++ ——自己手写的一个简单的单向链表

#include
using namespace std;

template<class T>
class List; //提前声明配合友元类
template<class T>
class Node{
    friend class List<T>;//友元类，方便表头操作节点私有成员
  T data;       //数据域
  Node<T>*next; //指针域，下一个元素的地址
  public: 
  Node(T data){
      this->data = data;
      this->next = nullptr;
  }
  
};
template<class T>
class List{
    Node<T>*head;
    int length;
    
  public:
  List(){
      this->head = nullptr;
      this->length = 0;
  }
  //isEmpty()判断链表是否为空
  bool isEmpty(){
      if(this->head==nullptr)
      {
          return true;
      }
      else{
          return false;
      }
  }
  //append()尾插法    
  void append(T data){
      if(this->isEmpty())
      {
          this->head = new Node<T>(data);
      }
      else{
          Node<T>*p=this->head;
          while(p->next!=nullptr)
          {
              p=p->next;
          }
          p->next=new Node<T>(data);
      }
      this->length++;
  }  
  //show(）用于测试的展示代码
  void show(){
	  Node<T>*p=this->head;
      while(p!=nullptr){
          cout<<p->data<<' ';
          p=p->next;
      }
      cout<<endl;

    cout<<"长度为"<<this->length;
  }
  //重载[]运算符，返回数据
  T& operator[](int index){
      Node<T>*p=this->head;
      while(index--){
          p=p->next;
      }
    return p->data;
  }
  
  //insert 插入，参数: 插入的位置和数据
  void insert(const int pos,const T data){
      //插入函数，参数为下标和数据
      int index = pos;
      if(index>=this->length&&index!=0){
          cerr<<"超出链表范围"<<endl;
          return;
      }
      Node<T>*newNode = new Node<T>(data);
      this->length++;
      if(index==0){
          if(this->isEmpty())
          {
             //如果为空，则append一个节点
            this->head = newNode;
            return;
          }
          else{
              //如果不为空，就头插一个节点
              newNode->next=this->head;
              this->head=newNode;
              return;
          }
      }
      
      Node<T>*p=this->head;
      while(--index){
          p=p->next;
      }
      newNode->next=p->next;
      p->next=newNode;
  }
  //search查找，参数:数据，返回:第一个数据相同的节点的下标
  int search(const T data){
      Node<T>*p=this->head;
      for(int i = 0;i<this->length;i++){
        if(p->data==data){
            return i;
        }
        p=p->next;

    }
  }
  //locate定位，参数:下标，返回:下标对应的节点的地址
  Node<T>* locate(int pos){
      Node<T>*p=this->head;
      while(pos--){
          p=p->next;
      }
     return p;
  }
  //size大小,返回:链表长度
  int size(){
      int lenth = 0;
      Node<T>*p=this->head;
      while(p!=nullptr){
          p=p->next;
          lenth++;
      }
      return lenth;
  }
  //erase删除，参数：下标
  void erase(int pos){
      if(pos>=this->length){
          cerr<<"超出范围"<<endl;
          return;
      }
      else{
         this->length--;
      }
      if(pos == 0){
          Node<T>*p = this->head->next;
          delete this->head;
          this->head = p;
          return;
      }
      Node<T>*p1=locate(pos-1);
      Node<T>*p2=p1->next->next;
      delete p1->next;
      p1->next=p2;
  }
  void reverse(){
      for(int i = 0;i<length/2;i++){
          int temp = operator[](i);
          operator[](i)=operator[](length-1-i);
          operator[](length-1-i)=temp;
      }
  }
};
int main()
{
    cout<<"测试开始"<<endl;
    List<int>test2;
    test2.append(3);//尾插
    test2.append(2);
    test2.append(1);
    test2.append(0);
    test2.insert(0,4);//第0个位置插入为4,也是头插
    test2.reverse();//倒置
    test2.erase(1);//删除第一个位置 即删除了元素1
    //cout<
    test2.show();  //测试用的展示函数
    //cout<
    cout<<endl<<"测试结束"<<endl;





    return 0;
}