数据结构 C++ 实现双链表

link.h 

#ifndef LINK_H
#define LINK_H
#pragma once
#include <iostream>

template<class T>
class Node{
public:
  T *data;
  Node<T> *pre;
  Node<T> *next;
};

template<class T>
class Link{
private:
  Node<T> *pheader;
  Node<T> *pfooter;
  int length;
public:
  // 初始化链表
  Link();
  // 析构
  ~Link();
  // 拷贝构造
  Link(const Link<T> &pl);
  // 添加到指定位置
  bool link_insert(int pos,T *value);
  // 删除指定位置节点
  T * link_splice(int pos);
  // 获取指定为节点
  T * link_index(int pos);
  T * operator[](int pos);
  // 遍历链表
  void link_foreach(void(print)(T *));
  // 倒序遍历
  void link_reverse_foreach(void(print)(T *));
  // 头插
  bool link_unshift(T *value);
  // 头删
  T * link_shift();
  // 尾插
  bool link_push(T *value);
  // 尾删
  T * link_pop();
  // 查找节点
  T * link_find(bool(print)(T *));
  // 清空节点
  bool link_clear();
  // 销毁链表
  bool link_destory();
  // 获取链表长度
  int link_length();
  // 连接链表
  Link<T>& operator+(const Link<T> &plink);
  Link<T>& operator+=(const Link<T> &plink);
  // 比较大小
  bool operator>(const Link<T> &plink);
  bool operator<(const Link<T> &plink);
  bool operator==(const Link<T> &plink);
};

#endif //TEST1_LINK_H

link.cpp

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

// 创建双链表
template<typename T>
Link<T>::Link(){
  this->pheader=new Node<T>;
  this->pfooter=new Node<T>;
  this->pheader->next=this->pfooter;
  this->pheader->pre=this->pfooter;
  this->pfooter->next=this->pheader;
  this->pfooter->pre=this->pheader;
  this->length=0;
}

// 拷贝构造
template<typename T>
Link<T>::Link(const Link<T> &pl){
  this->pheader=new Node<T>;
  this->pfooter=new Node<T>;
  this->length=pl.length;

  this->pheader->next=this->pfooter;
  this->pheader->pre=this->pfooter;
  this->pfooter->next=this->pheader;
  this->pfooter->pre=this->pheader;

  Node<T> *tCur=pl.pheader->next;
  Node<T> *pCur=this->pheader;

  for(int i=0;i<this->length;++i){
    Node<T> *newNode=new Node<T>;
    newNode->data=tCur->data;

    newNode->next=pCur->next;
    newNode->pre=pCur;

    pCur->next=newNode;
    pCur=newNode;
    tCur=tCur->next;
  }
  pCur->next=this->pfooter;
  this->pfooter->pre=pCur;
}

// 连接链表
template<typename T> 
Link<T>& Link<T>::operator+(const Link<T> &plink){
  Node<T> *tCur=plink.pheader->next;
  for(int i=0;i<plink.length;++i){
    this->link_push(tCur->data);
    tCur=tCur->next;
  }
  return *this;
}
template<typename T> 
Link<T>& Link<T>::operator+=(const Link<T> &plink){
  Node<T> *tCur=plink.pheader->next;
  for(int i=0;i<plink.length;++i){
    this->link_push(tCur->data);
    tCur=tCur->next;
  }
  return *this;
}

// 比较大小
template<typename T>
bool Link<T>::operator>(const Link<T> &plink){
  return this->length>plink.length;
}

template<typename T>
bool Link<T>::operator<(const Link<T> &plink){
  return this->length<plink.length;
}

template<typename T>
bool Link<T>::operator==(const Link<T> &plink){
  return this->length==plink.length;
}

template<typename T>
int Link<T>::link_length(){
  if(this->pheader==NULL||this->pfooter==NULL)
    return 0;
  return this->length;
}

// 在指定位置插入节点
template<typename T>
bool Link<T>::link_insert(int pos,T *value){
  if(!value)
    return false;
  if(pos>this->length||pos<0)
    pos=this->length;
  Node<T> *pCur=this->pheader;
  for(int i=0;i<pos;++i){
    pCur=pCur->next;
  }
  Node<T> *newNode=new Node<T>;
  newNode->data=value;

  Node<T> *pNext=pCur->next;
  newNode->next=pCur->next;
  newNode->pre=pCur;
  pCur->next=newNode;
  pNext->pre=newNode;
  this->length++;
  return true;
}

// 删除指定为节点
template<typename T> 
T * Link<T>::link_splice(int pos){
  if(pos<0||pos>this->length)
    return NULL;
  Node<T> *pCur=this->pheader;
  for(int i=0;i<pos;++i){
    pCur=pCur->next;
  }
  Node<T> *deleteNode=pCur->next;
  T*data=deleteNode->data;
  deleteNode->next->pre=pCur;
  pCur->next=deleteNode->next;
  delete deleteNode;
  this->length--;
  return data;
}

// 获取指定位置节点
template<typename T>
T * Link<T>::link_index(int pos){
  if(pos<0||pos>=this->length)
    return NULL;
  if(this->pheader==NULL||this->pfooter==NULL)
    return NULL;
  Node<T> *pCur=this->pheader->next;
  for(int i=0;i<pos;++i){
    pCur=pCur->next;
  }
  return pCur->data;
}

template<typename T>
T * Link<T>::operator[](int pos){
  if(pos<0||pos>=this->length)
    return NULL;
  if(this->pheader==NULL||this->pfooter==NULL)
    return NULL;
  Node<T> *pCur=this->pheader->next;
  for(int i=0;i<pos;++i){
    pCur=pCur->next;
  }
  return pCur->data;
}

// 正序遍历
template<typename T>
void Link<T>::link_foreach(void(print)(T *)){
  if(!this->length||!this->pheader)
    return ;
  Node<T> *pCur=this->pheader->next;
  for(int i=0;i<this->length;++i){
    print(pCur->data);
    pCur=pCur->next;
  }
}

// 倒序遍历
template<typename T>
void Link<T>::link_reverse_foreach(void(print)(T *)){
  if(!this->length||!this->pheader)
    return ;
  Node<T> *pCur=this->pfooter->pre;
  for(int i=0;i<this->length;++i){
    print(pCur->data);
    pCur=pCur->pre;
  }
}

// 头插
template<typename T>
bool Link<T>::link_unshift(T *value){
  if(this->pheader==NULL||this->pfooter==NULL||!value)
    return false;
  Node<T> *pCur=this->pheader->next;
  Node<T> *newNode=new Node<T>;
  newNode->data=value;

  newNode->next=this->pheader->next;
  newNode->pre=this->pheader;
  this->pheader->next=newNode;
  pCur->pre=newNode;
  this->length++;
  return true;
}

// 头删
template<typename T>
T *Link<T>::link_shift(){
  if(this->pheader==NULL||this->pheader==NULL||!this->length)
    return NULL;
  Node<T> *deleteNode=this->pheader->next;
  T *data=deleteNode->data;
  this->pheader->next=deleteNode->next;
  deleteNode->next->pre=this->pheader;
  this->length--;
  delete deleteNode;
  return data;
}

// 尾插
template<typename T>
bool Link<T>::link_push(T *value){
  if(this->pheader==NULL||this->pfooter==NULL||!value)
    return false;
  Node<T> *pCur=this->pfooter->pre;
  Node<T> *newNode=new Node<T>;
  newNode->data=value;

  newNode->pre=this->pfooter->pre;
  newNode->next=this->pfooter;
  this->pfooter->pre=newNode;
  pCur->next=newNode;
  this->length++;
  return true;
}

// 尾删
template<typename T>
T * Link<T>::link_pop(){
  if(this->pheader==NULL||this->pheader==NULL||!this->length)
    return NULL;
  Node<T> *pCur=this->pfooter;
  Node<T> *deleteNode=this->pfooter->pre;
  T *data=deleteNode->data;
  pCur->pre=deleteNode->pre;
  deleteNode->pre->next=pCur;
  delete deleteNode;
  this->length--;
  return data;
}

// 查找节点
template<typename T>
T * Link<T>::link_find(bool(print)(T *)){
  if(this->pheader==NULL||this->pheader==NULL||!this->length)
    return NULL;
  Node<T> *pCur=this->pheader->next;
  for(int i=0;i<this->length;++i){
    if(print(pCur->data)){
      return pCur->data;
    }
    pCur=pCur->next;
  }
  return NULL;
}

// 清空节点
template<typename T>
bool Link<T>::link_clear(){
  if(this->length==0||this->pheader==NULL||this->pfooter==NULL)
    return true;
  Node<T> *pCur=this->pheader->next;
  for(int i=0;i<this->length;++i){
    Node<T> *t=pCur->next;
    delete pCur;
    pCur=t;
  }
  this->length=0;
  return true;
}

// 销毁链表
template<typename T>
bool Link<T>::link_destory(){
  this->link_clear();
  if(this->pheader==NULL||this->pfooter==NULL)
    return true;
  delete this->pheader;
  delete this->pfooter;
  this->pheader=NULL;
  this->pfooter=NULL;
  return true;
}

// 析构
template<typename T>
Link<T>::~Link(){
  this->link_destory();
}

test.cpp

#include "link/link.cpp"
#include <iostream>
using namespace std;

class person{
private:
  int id;
  string name;
  int age;
public:
  person(int id,string name,int age):id(id),name(name),age(age){}
  void info(){
    cout<<"id:"<<this->id<<" name:"<<this->name<<" age:"<<this->age<<endl;
  }
  bool operator==(const person &tp){
    if(this->name==tp.name&&this->id==tp.id&&this->age==tp.age){
      return true;
    }else{
      return false;
    }
  }
};

template<typename T>
void myPrint(T *value){
  class person *p=(class person *)value;
  p->info();
}

template<typename T>
bool findValue(T *value){
  class person *p=(class person *)value;
  class person *p0=new person(4,"Tom",21);
  return *p0==*p;
}

void test(){
  class person *p1=new person(1,"Andy",21);
  class person *p2=new person(2,"Sam",21);
  class person *p3=new person(3,"Tim",21);
  class person *p4=new person(4,"Tom",21);
  class person *p5=new person(5,"John",21);
  class person *p6=new person(6,"Jack",21);
  class Link<person> *k1=new Link<person>();
  k1->link_insert(0,p1);
  k1->link_insert(1,p2);
  k1->link_insert(2,p3);
  k1->link_insert(3,p4);
  k1->link_splice(2);
  k1->link_splice(2);
  k1->link_splice(0);
  class person *p=(class person *)k1->link_splice(0);
  // p->info();
  k1->link_insert(0,p1);
  k1->link_insert(1,p2);
  k1->link_insert(2,p3);
  k1->link_insert(3,p4);
  k1->link_unshift(p5);
  class Link<person> *k2=new Link<person>(*k1);
  cout<<"k1==k2:"<<(*k1==*k2)<<endl;
  *k1=*k1+*k2;
  *k1+=*k2;
  k1->link_foreach(myPrint);
 
  cout<<"k1 length:"<<k1->link_length()<<endl;
  cout<<"k2 length:"<<k2->link_length()<<endl;
  cout<<"k1>k2:"<<(*k1>*k2)<<endl;
  p=(class person *)k1->link_index(14);
  if(p)
  p->info();
  p=(class person *)k1->link_find(findValue);
  if(p)
  p->info();
  // p=(class person *)(*k1)[0];
  p=(class person *)k1[0][0];
  p->info();
  k1->link_clear();
  k1->link_destory();
  k2->link_destory();
}

int main(){
  test();
  system("pause");
  return EXIT_SUCCESS;
}

运行结果

k1==k2:1
id:5 name:John age:21
id:1 name:Andy age:21
id:2 name:Sam age:21
id:3 name:Tim age:21
id:4 name:Tom age:21
id:5 name:John age:21
id:1 name:Andy age:21
id:2 name:Sam age:21
id:3 name:Tim age:21
id:4 name:Tom age:21
id:5 name:John age:21
id:1 name:Andy age:21
id:2 name:Sam age:21
id:3 name:Tim age:21
id:4 name:Tom age:21
k1 length:15
k2 length:5
k1>k2:1
id:4 name:Tom age:21
id:4 name:Tom age:21
id:5 name:John age:21
请按任意键继续. . .