定義一個節點：

1. #include <iostream>
2. usingnamespace std;  
3. typedefint T;  
4. struct Node{  
5.     T data;  
6.     Node* next;  
7.     Node(const T& d):data(d), next(NULL){}  
8.     operator T(){  
9.         return data;  
10.     }  
11. };  
12. int main(){  
13.     Node a(10), b(20);  
14.     cout << "a=" << a << ", b=" << b << endl;  
15.     return 0;  
16. }  

輸出一段簡單的連結串列

1. #include <iostream>
2. usingnamespace std;  
3. typedefint T;  
4. struct Node{  
5.     T data;  
6.     Node* next;  
7.     Node(const T& d):data(d), next(NULL){}  
8.     operator T(){  
9.         return data;  
10.     }     
11. };  
12. int main(){  
13.     Node a(10), b(20), c(30), d(40), e(50);  
14.     a.next = &b;   
15.     b.next = &c;   
16.     c.next = &d;   
17.     Node *p = &a;   
18.     while(p != NULL){  
19.         cout << *p << ' ';  
20.         p = p->next;  
21.     }  
22.     cout << endl;  
23.     return 0;  
24. }  

1. #include <iostream>
2. usingnamespace std;  
3. typedefint T;  
4. struct Node{  
5.     T data;  
6.     Node* next;  
7.     Node(const T& d):data(d), next(NULL){}  
8.     operator T(){  
9.         return data;  
10.     }  
11. };  
12. //輸出連結串列
13. void showlist(Node* p){  
14.     while(p != NULL){  
15.         cout << *p << ' ';  
16.         p = p->next;  
17.     }  
18.     cout << endl;  
19. }  
20. int main(){  
21.     Node a(10), b(20), c(30), d(40), e(50);  
22.     a.next = &b;  
23.     b.next = &c;  
24.     c.next = &d;  
25.     showlist(&a);  
26.     //新增一個節點
27.     Node* & p = b.next;//取b.next指標的別名
28.     e.next = p;  
29.     p = &e;  
30.     showlist(&a);  
31.     //再新增一個節點
32.     Node* k = new Node(70);  
33.     Node*& r = c.next;  
34.     k->next = r;  
35.     r = k;  
36.     return 0;  
37. }  

一個C++實現的連結串列如下：

1. #include <iostream>
2. usingnamespace std;  
3. typedefint T;  
4. class List{  
5.     struct Node{  
6.         T data;  
7.         Node * next;  
8.         //T()零初始化
9.         Node(const T& d=T()):data(d), next(0){}  
10.     };  
11.     Node * head; //頭指標
12.     int len;  
13. public:  
14.     List():head(NULL),len(0){ }  
15.     //插入到任何位置
16.     //1、在連結串列裡找到指向那個位置的指標pn
17.     //2、讓新節點的next成員和pn指向同一個地方
18.     //3、再讓pn指向新節點
19.     void insert(const T&d, int pos){  
20.         Node*& pn = getptr(pos);  
21.         Node* p = new Node(d);  
22.         p->next = pn;  
23.         pn = p;  
24.         len++;    
25.     }  
26.     //返回連結串列長度
27.     int size()const{  
28.         return len;  
29.     }  
30.     //尾插
31.     void push_back(const T& d){  
32.         insert(d, size());  
33.     }  
34.     //找連結串列中指向指定位置的指標
35.     Node*& getptr(int pos){  
36.         if(pos<0 || pos>size()) pos = 0;  
37.         if(pos==0) return head;  
38.         Node* p = head;  
39.         for(int i=1; i<pos; i++)  
40.             p = p->next;  
41.         return p->next;  
42.     }  
43.     //前插
44.     void push_front(const T& d){  
45.         insert(d, 0);  
46.     }  
47.     //遍歷
48.     void travel()const{  
49.         Node* p = head;  
50.         while(p!=NULL){  
51.             cout << p->data << ' ';  
52.             p = p->next;  
53.         }  
54.         cout << endl;  
55.     }  
56.     //清空
57.     void clear(){  
58.         while(head!=NULL){  
59.             Node * p = head->next;  
60.             delete head;  
61.             head = p;  
62.         }  
63.         len = 0;  
64.     }  
65.     ~List(){  
66.         clear();  
67.     }  
68.     //按照位置刪除
69.     //1、找到連結串列中指向那個位置的指標
70.     //2、把那個指標另存一份
71.     //3、讓那個指標指向下一個節點
72.     //4、釋放那個指標的動態記憶體
73.     void erase(int pos){  
74.         if(pos<0 || pos>=size()) return;  
75.         Node *& pn = getptr(pos);  
76.         Node * p = pn;  
77.         pn = pn->next;  
78.         delete p;  
79.         --len;  
80.     }  
81.     //根據元素查詢位置
82.     int find(const T& d)const{  
83.         int pos = 0;  
84.         Node* p = head;  
85.         while(p){  
86.             if(p->data==d) return pos;  
87.             p = p->next;  
88.             ++pos;  
89.         }  
90.         return -1;  
91.     }  
92.     //根據元素刪除
93.     void remove(const T& d){  
94.         int pos;  
95.         while((pos = find(d)) != -1)  
96.             erase(pos);  
97.     }  
98. };  
99. int main(){  
100.     List l;  
101.     l.push_front(5);  
102.     l.push_front(8);  
103.     l.push_front(20);  
104.     //在第2個位置插入9
105.     l.insert(9, 2);  
106.     l.travel();  
107.     return 0;  
108. }  

通過上圖可以看出來，如果我們要插入一個節點，就需要找到指向該位置的指標（或者前一個結點），比如上圖的p->next指標就是我們需要找到的。刪除一個節點也一樣，需要找到指向該節點的指標。

原文轉自：http://www.tuicool.com/articles/nA7VjmU

原作者為 dawanganban. 請尊重原作者版權