• node.h

  1 #pragma once
  2 //創建模板
  3 template <class T>
  4 class Node
  5 {
  6 public:
  7     T t;//數據
  8     Node *pNext;//指針域
  9 };

• list.h

   1 #pragma once
   2 #include "Node.h"
   3 #include <iostream>
   4 using namespace std;
   5 
   6 template <class T>
   7 class List
   8 {
   9 public:
  10     Node<T> *pHead;
   
  11 
  12 public:
  13     List();
  14     void add(T t);//尾部插入
  15     void show();//顯示
  16     Node<T> * find(T t);//查找
  17     void change(Node<T> *p, T newt);//修改
  18     int getnum();//獲取個數
  19     bool deletet(T t);
  20     void sort();
  21     void deletesame();//刪除相同的元素
  22     bool clear();
  23     void rev();
   
  24 
  25     void insert(T oldt, T newt);
  26     void merge(List & list);
  27 
  28     ~List();
  29 };

• list.cpp

    1 #include "List.h"
    2 
    3 
    4 template <class T>
    5 List<T>::List()
    6 {
    7     this->pHead = nullptr;//設置空節點 
    8     cout << "鏈表創建" << endl;
    9 
   10
   
   }
   11 
   12 
   13 template <class T>
   14 List<T>::~List()
   15 {
   16     cout << "鏈表銷毀" << endl;
   17 
   18 }
   19 template <class T>
   20 void List<T>::add(T t)
   21 {
   22     Node<T> *pnew = new Node<T>;//分配節點
   23     pnew->t = t;//賦值
   24     pnew->pNext = nullptr;
   25 
   26 
   27     if (pHead==nullptr)
   28     {
   29         
   30         this->pHead = pnew;//頭結點
   31 
   32     } 
   33     else
   34     {
   35         Node<T> *p = pHead;//獲取頭結點位置
   36         while (p->pNext!=nullptr)//循環到尾部
   37         {
   38             p = p->pNext;
   39 
   40         }
   41         p->pNext = pnew;
   42 
   43     }
   44 
   45 }
   46 
   47 
   48 template <class T>
   49 void List<T>::show()
   50 {
   51 
   52     Node<T> *p = pHead;//獲取頭結點位置
   53     while (p!= nullptr)//循環到尾部
   54     {
   55 
   56         cout << p->t << "  ";
   57         p = p->pNext;
   58 
   59     }
   60     cout << endl;
   61 
   62 }
   63 
   64 template <class T>
   65 Node<T> * List<T>::find(T t)
   66 {
   67     Node<T> *p = pHead;//獲取頭結點位置
   68     while (p != nullptr)//循環到尾部
   69     {
   70         if (p->t==t)
   71         {
   72             return p;
   73         }
   74     
   75         p = p->pNext;
   76 
   77     }
   78     return nullptr;
   79 
   80 
   81 }
   82 
   83 template <class T>
   84 void List<T>::change(Node<T> *p, T newt)
   85 {
   86     if (p==nullptr)
   87     {
   88         return;
   89     }
   90 
   91     p->t = newt;
   92 }
   93 
   94 template <class T>
   95 int  List<T>::getnum()
   96 {
   97     int i = 0;
   98     Node<T> *p = pHead;//獲取頭結點位置
   99     while (p != nullptr)//循環到尾部
  100     {
  101 
  102         i++;
  103         p = p->pNext;
  104 
  105     }
  106 
  107     return i;
  108 
  109 
  110 }
  111 template <class T>
  112 bool List<T>::deletet(T t)
  113 {
  114 
  115     Node<T> *p = this->find(t);
  116     if (p==nullptr)
  117     {
  118         return  false;
  119     }
  120     else
  121     {
  122         
  123         if (p==pHead)//頭結點
  124         {
  125             pHead = p->pNext;
  126             delete p;
  127         }
  128         else
  129         {
  130             Node<T> *p1, *p2;
  131             p1 = pHead;
  132             p2 = p1->pNext;
  133             while (p2!=p)//刪除一個節點，獲取前一個節點
  134             {
  135                 p1 = p2;
  136                 p2 = p2->pNext;
  137                 
  138             }
  139 
  140             p1->pNext = p2->pNext;//跳過p2
  141             delete p2;
  142 
  143 
  144 
  145         }
  146         return true;
  147     }
  148 }
  149 
  150 
  151 template <class T>
  152 void List<T>::sort()
  153 {
  154     for (Node<T> *p1 = pHead; p1 != NULL;p1=p1->pNext)
  155     {
  156         for (Node<T> *p2 = pHead; p2!= NULL; p2 = p2->pNext)
  157         {
  158             if (p1->t < p2->t)
  159             {
  160                 T temp;
  161                 temp = p1->t;
  162                 p1->t = p2->t;
  163                 p2 -> t = temp;
  164 
  165             }
  166         }
  167     }
  168 }
  169 
  170 template<class T>
  171 void List<T>::deletesame()//重新生成
  172 {
  173 
  174         Node<T> *p1, *p2;
  175         p1 = pHead->pNext;
  176         p2 = pHead;
  177         while (p1!=nullptr)
  178         {
  179             if (p1->t==p2->t)
  180             {
  181                 //cout << "=";
  182                 p2->pNext = p1->pNext;
  183                 delete p1;
  184                 p1 = p2->pNext;
  185             }
  186             else
  187             {
  188                 p2 =p1;
  189                 p1 = p1->pNext;
  190 
  191             }
  192         }
  193 }
  194 
  195 template<class T>
  196 bool List<T>::clear()
  197 {
  198     if (pHead ==nullptr)
  199     {
  200         return false;
  201     }
  202 
  203 
  204     Node<T> *p1, *p2;
  205     p1 = pHead->pNext;
  206     while (p1!=nullptr)
  207     {
  208         p2 = p1->pNext;
  209         delete p1;
  210         p1 = p2;
  211     }
  212     delete pHead;
  213     pHead = nullptr;
  214 
  215     return true;
  216 
  217 
  218 }
  219 template<class T>
  220 //遞歸
  221 void  List<T>::rev()
  222 {
  223     if (pHead==nullptr || pHead->pNext==nullptr)
  224     {
  225         return;
  226     } 
  227     else
  228     {
  229         Node<T> *p1, *p2, *p3;
  230         p1 = pHead;
  231         p2 = p1->pNext;
  232 
  233 
  234         while (p2!=nullptr)
  235         {
  236             p3 = p2->pNext;
  237             p2->pNext = p1;
  238 
  239             p1 = p2;
  240             p2 = p3;
  241 
  242         }
  243         pHead->pNext= nullptr;
  244         pHead = p1;
  245 
  246 
  247     }
  248 
  249 
  250 }
  251 template<class T>
  252 void  List<T>::insert(T oldt, T newt)
  253 {
  254 
  255     Node<T> *p = find(oldt);
  256     if (p!=nullptr)
  257     {
  258 
  259         Node<T> *p1, *p2;
  260         p1 = pHead;
  261         p2 = p1->pNext;
  262         while (p2 != p)
  263         {
  264             p1 = p2;
  265             p2 = p2->pNext;
  266 
  267         }
  268         Node<T> *pnew = new Node<T>;
  269         pnew->t = newt;
  270         pnew->pNext = p2;
  271         p1->pNext = pnew;
  272     }
  273 }
  274 
  275 template<class T>
  276 void  List<T>::merge(List & list)
  277 {
  278     Node<T> *p = pHead;//獲取頭結點位置
  279     while (p->pNext != nullptr)//循環到尾部
  280     {
  281 
  282         p = p->pNext;
  283 
  284     }
  285     p->pNext = list.pHead;
  286 }

• main.cpp

    1 #include "List.h"
    2 
    3 
    4 template <class T>
    5 List<T>::List()
    6 {
    7     this->pHead = nullptr;//設置空節點 
    8     cout << "鏈表創建" << endl;
    9 
   10 }
   11 
   12 
   13 template <class T>
   14 List<T>::~List()
   15 {
   16     cout << "鏈表銷毀" << endl;
   17 
   18 }
   19 template <class T>
   20 void List<T>::add(T t)
   21 {
   22     Node<T> *pnew = new Node<T>;//分配節點
   23     pnew->t = t;//賦值
   24     pnew->pNext = nullptr;
   25 
   26 
   27     if (pHead==nullptr)
   28     {
   29         
   30         this->pHead = pnew;//頭結點
   31 
   32     } 
   33     else
   34     {
   35         Node<T> *p = pHead;//獲取頭結點位置
   36         while (p->pNext!=nullptr)//循環到尾部
   37         {
   38             p = p->pNext;
   39 
   40         }
   41         p->pNext = pnew;
   42 
   43     }
   44 
   45 }
   46 
   47 
   48 template <class T>
   49 void List<T>::show()
   50 {
   51 
   52     Node<T> *p = pHead;//獲取頭結點位置
   53     while (p!= nullptr)//循環到尾部
   54     {
   55 
   56         cout << p->t << "  ";
   57         p = p->pNext;
   58 
   59     }
   60     cout << endl;
   61 
   62 }
   63 
   64 template <class T>
   65 Node<T> * List<T>::find(T t)
   66 {
   67     Node<T> *p = pHead;//獲取頭結點位置
   68     while (p != nullptr)//循環到尾部
   69     {
   70         if (p->t==t)
   71         {
   72             return p;
   73         }
   74     
   75         p = p->pNext;
   76 
   77     }
   78     return nullptr;
   79 
   80 
   81 }
   82 
   83 template <class T>
   84 void List<T>::change(Node<T> *p, T newt)
   85 {
   86     if (p==nullptr)
   87     {
   88         return;
   89     }
   90 
   91     p->t = newt;
   92 }
   93 
   94 template <class T>
   95 int  List<T>::getnum()
   96 {
   97     int i = 0;
   98     Node<T> *p = pHead;//獲取頭結點位置
   99     while (p != nullptr)//循環到尾部
  100     {
  101 
  102         i++;
  103         p = p->pNext;
  104 
  105     }
  106 
  107     return i;
  108 
  109 
  110 }
  111 template <class T>
  112 bool List<T>::deletet(T t)
  113 {
  114 
  115     Node<T> *p = this->find(t);
  116     if (p==nullptr)
  117     {
  118         return  false;
  119     }
  120     else
  121     {
  122         
  123         if (p==pHead)//頭結點
  124         {
  125             pHead = p->pNext;
  126             delete p;
  127         }
  128         else
  129         {
  130             Node<T> *p1, *p2;
  131             p1 = pHead;
  132             p2 = p1->pNext;
  133             while (p2!=p)//刪除一個節點，獲取前一個節點
  134             {
  135                 p1 = p2;
  136                 p2 = p2->pNext;
  137                 
  138             }
  139 
  140             p1->pNext = p2->pNext;//跳過p2
  141             delete p2;
  142 
  143 
  144 
  145         }
  146         return true;
  147     }
  148 }
  149 
  150 
  151 template <class T>
  152 void List<T>::sort()
  153 {
  154     for (Node<T> *p1 = pHead; p1 != NULL;p1=p1->pNext)
  155     {
  156         for (Node<T> *p2 = pHead; p2!= NULL; p2 = p2->pNext)
  157         {
  158             if (p1->t < p2->t)
  159             {
  160                 T temp;
  161                 temp = p1->t;
  162                 p1->t = p2->t;
  163                 p2 -> t = temp;
  164 
  165             }
  166         }
  167     }
  168 }
  169 
  170 template<class T>
  171 void List<T>::deletesame()//重新生成
  172 {
  173 
  174         Node<T> *p1, *p2;
  175         p1 = pHead->pNext;
  176         p2 = pHead;
  177         while (p1!=nullptr)
  178         {
  179             if (p1->t==p2->t)
  180             {
  181                 //cout << "=";
  182                 p2->pNext = p1->pNext;
  183                 delete p1;
  184                 p1 = p2->pNext;
  185             }
  186             else
  187             {
  188                 p2 =p1;
  189                 p1 = p1->pNext;
  190 
  191             }
  192         }
  193 }
  194 
  195 template<class T>
  196 bool List<T>::clear()
  197 {
  198     if (pHead ==nullptr)
  199     {
  200         return false;
  201     }
  202 
  203 
  204     Node<T> *p1, *p2;
  205     p1 = pHead->pNext;
  206     while (p1!=nullptr)
  207     {
  208         p2 = p1->pNext;
  209         delete p1;
  210         p1 = p2;
  211     }
  212     delete pHead;
  213     pHead = nullptr;
  214 
  215     return true;
  216 
  217 
  218 }
  219 template<class T>
  220 //遞歸
  221 void  List<T>::rev()
  222 {
  223     if (pHead==nullptr || pHead->pNext==nullptr)
  224     {
  225         return;
  226     } 
  227     else
  228     {
  229         Node<T> *p1, *p2, *p3;
  230         p1 = pHead;
  231         p2 = p1->pNext;
  232 
  233 
  234         while (p2!=nullptr)
  235         {
  236             p3 = p2->pNext;
  237             p2->pNext = p1;
  238 
  239             p1 = p2;
  240             p2 = p3;
  241 
  242         }
  243         pHead->pNext= nullptr;
  244         pHead = p1;
  245 
  246 
  247     }
  248 
  249 
  250 }
  251 template<class T>
  252 void  List<T>::insert(T oldt, T newt)
  253 {
  254 
  255     Node<T> *p = find(oldt);
  256     if (p!=nullptr)
  257     {
  258 
  259         Node<T> *p1, *p2;
  260         p1 = pHead;
  261         p2 = p1->pNext;
  262         while (p2 != p)
  263         {
  264             p1 = p2;
  265             p2 = p2->pNext;
  266 
  267         }
  268         Node<T> *pnew = new Node<T>;
  269         pnew->t = newt;
  270         pnew->pNext = p2;
  271         p1->pNext = pnew;
  272     }
  273 }
  274 
  275 template<class T>
  276 void  List<T>::merge(List & list)
  277 {
  278     Node<T> *p = pHead;//獲取頭結點位置
  279     while (p->pNext != nullptr)//循環到尾部
  280     {
  281 
  282         p = p->pNext;
  283 
  284     }
  285     p->pNext = list.pHead;
  286 }

36.創建模板mylist