用C++ 实现链表：

首先功能分析： 构造，清理，增删改查，求大小 判断空 ，取头取尾

 

 
  
  1. #include <iostream> 
  2. using namespace std; 
  3.  
  4. typedef int T; 
  5. //链表类 
  6. class LinkedList 
  7. { 
  8.     struct Node 
  9.     { 
  10.         T data; 
  11.         Node* next; 
  12.         Node(const T& t):data(t),next(NULL) 
  13.         { 
  14.         } 
  15.     }; 
  16. public: 
  17.     //构造  析构  清空 
  18.     LinkedList():head(NULL) 
  19.     { 
  20.     } 
  21.      
  22.     ~LinedList() 
  23.     { 
  24.         clear(); 
  25.     } 
  26.  
  27.     void clear() 
  28.     { 
  29.      
  30.     } 
  31.     //增(insertBack insertFront)删改查(find) 
  32.     void insertFront(const T& t) 
  33.     { 
  34.     } 
  35.     void insertBack(const T& t) 
  36.     { 
  37.     } 
  38.     void erase(const T& t) 
  39.     { 
  40.     } 
  41.     void update(const T& t,const T& target) 
  42.     { 
  43.     } 
  44.     unsigned int  find(const T& t) 
  45.     { 
  46.         unsigned int position=0; 
  47.         return position; 
  48.     } 
  49.     //判断empty 求size  遍历(travel) 
  50.     bool empty() 
  51.     { 
  52.     } 
  53.     unsigned int size() 
  54.     { 
  55.         int size=0; 
  56.         return size; 
  57.     } 
  58.      
  59.     void travel() 
  60.     { 
  61.     } 
  62.     //取头 取尾   
  63.     T getHead() 
  64.     { 
  65.     } 
  66.     T getTail() 
  67.     { 
  68.  
  69.     } 
  70.     //去指定位置取指针  辅助作用 
  71.     Node* getPointer(int position) 
  72.     { 
  73.         return NULL; 
  74.     } 
  75. private: 
  76.     //头指针 最重要的部分 
  77.     Node* head;  
  78. }; 
  79.  
  80. int main() 
  81. { 
  82. } 
 
  
功能添加：
 
  
 
 
  
 
  
  1. #include <iostream> 
  2. using namespace std; 
  3.  
  4. typedef int T; 
  5. //链表类 
  6. class LinkedList 
  7. { 
  8.     struct Node 
  9.     { 
  10.         T data; 
  11.         Node* next; 
  12.         //初始化data next 阻止垃圾数据 
  13.         Node(const T& t=T()):data(t),next(NULL) 
  14.         { 
  15.         } 
  16.     }; 
  17. public: 
  18.     //构造  析构  清空 
  19.     LinkedList():head(NULL) 
  20.     { 
  21.     } 
  22.     ~LinkedList() 
  23.     { 
  24.         clear(); 
  25.     } 
  26.  
  27.     void clear() 
  28.     { 
  29.         Node *p=head; 
  30.         while (p!=NULL) 
  31.         { 
  32.             Node *q = p->next; 
  33.             delete p;//释放p所在空间 
  34.             p=q; 
  35.         } 
  36.     } 
  37.     //判断empty 求size  遍历(travel) 
  38.     bool empty() 
  39.     { 
  40.         //判断头指针是否为空 为空表示链表不存在 
  41.         return head==NULL ? true : false; 
  42.     } 
  43.     unsigned int size() 
  44.     { 
  45.         unsigned int size=0; 
  46.         Node* p =head; 
  47.         while (p!=NULL) 
  48.         { 
  49.             size++; 
  50.             pp=p->next; 
  51.         } 
  52.         return size; 
  53.     } 
  54.  
  55.     void travel() 
  56.     { 
  57.         //利用while循环一次次的输出来，直到指针为NULL结束 
  58.         Node* p = head; 
  59.         while (p!=NULL) 
  60.         { 
  61.             cout<<p->data<<endl; 
  62.             pp=p->next; 
  63.         } 
  64.     } 
  65.     //增(insertAfter insertFront)删改查(find) 
  66.     void insertFront(const T& t) 
  67.     { 
  68.         Node* p = new Node(t); 
  69.         p->next=head;  //讲头指针所指向的地址给p的next 
  70.         head = p;       //让*p作为头 
  71.     } 
  72.     void insertAfter(const T& t) 
  73.     { 
  74.         Node *p = new Node(t); 
  75.         Node *tail = getPointer(size()-1); 
  76.         tail->next = p; 
  77.     } 
  78.     void erase(const T& t) 
  79.     { 
  80.         unsigned int position = find(t); 
  81.         Node* cur = getPointer(position); 
  82.         if (position!=0) 
  83.         { 
  84.             Node* pre = getPointer(find(t)-1); 
  85.             pre->next = cur->next; 
  86.         }else{ 
  87.             head = cur->next; 
  88.         } 
  89.         delete cur; 
  90.     } 
  91.     void update(const T& t,const T& target) 
  92.     { 
  93.         Node *p=getPointer(find(target)); 
  94.         p->data=t; 
  95.     } 
  96.     unsigned int  find(const T& t) 
  97.     { 
  98.         unsigned int position=0; 
  99.         Node* p = head; 
  100.         while(p!=NULL) 
  101.         { 
  102.             if (p->data==t) 
  103.             { 
  104.                 return position; 
  105.             } 
  106.             pp=p->next; 
  107.             position++; 
  108.         } 
  109.         return position; 
  110.     } 
  111.      
  112.     //取头 取尾   
  113.     T getHead() 
  114.     { 
  115.         return head->data; 
  116.     } 
  117.     T getTail() 
  118.     { 
  119.         Node *p=getPointer(this->size()-1); 
  120.         return p->data; 
  121.     } 
  122.     //去指定位置取指针  辅助作用 
  123.     Node* getPointer(int position) 
  124.     { 
  125.         Node* p =head; 
  126.         for(int i = 0;i<position;i++) 
  127.         { 
  128.             pp=p->next; 
  129.         } 
  130.         return p; 
  131.     } 
  132. private: 
  133.     //头指针 最重要的部分 
  134.     Node* head;  
  135. }; 
  136.  
  137. int main() 
  138. { 
  139. }