鏈表（list）——C++實現

C++內list採用雙向鏈表，從新實現本身的list

  1 /************************************************************************/
  2 /*對list的實現，採用的是雙向鏈表，C++標準庫中使用的也是雙向鏈表 */
  3 /************************************************************************/
  4 
  5 #ifndef LIST_H
  6 #define  LIST_H
  7 
  8 namespace stl
  9 {
 10     template <typename Object> 
 11     class List
 12     {
 13     //public members
 14     public:
 15         //構造函數
 16         List() : theSize(0)
 17         {
 18             init();
 19         }
 20 
 21         //拷貝構造函數
 22         List(const List & L)
 23         {
 24             //須要深層次的拷貝
 25             init();
 26             this->operator=(L);
 27         }
 28 
 29         //重載賦值運算符
 30         const List & operator = (const List & L)
 31         {
 32             if (this == &L)
 33             {
 34                 return *this;
 35             }
 36             //形參List是const類型的，所以只能調用const版本的函數
 37             //將元素一個個拷貝，不拷貝節點，節點在init函數中
 38             for (const_iterator from = L.begin(); from != L.cend(); ++from)
 39             {
 40                 push_back(*L);
 41             }
 42             return *this;
 43         }
 44 
 45         bool operator == (const List & L)
 46         {
 47             return head == L.head && tail == L.tail && theSize == L.theSize;
 48         }
 49 
 50         //析構函數
 51         ~List()
 52         {
 53             //刪除元素
 54             Node* temp = head->next;
 55             Node* tempNext = temp->next;
 56             while (temp != tail)
 57             {
 58                 delete temp;
 59                 temp = tempNext;
 60             }
 61             //刪除頭結點和尾節點
 62             delete head;
 63             delete tail;
 64         }
 65 
 66         void init()
 67         {
 68             head = new Node;
 69             tail = new Node;
 70             head->next = tail;
 71             tail->prev = head;
 72         }
 73 
 74     public:
 75         /************************************************************************/
 76         /* 說   明：迭代器類的定義
 77         /* 時   間：2016.10.27
 78         /************************************************************************/
 79         class const_iterator
 80         {
 81         public:
 82             //構造函數，帶默認值爲NULL
 83             const_iterator(Node* n = NULL)
 84                 :current(n){ }
 85 
 86             //重載取引用操做符，解引用操做符是無參的
 87             const Object& operator * () const
 88             {
 89                 retrieve();
 90             }
 91 
 92             //重載++，返回的仍是迭代器，current發生了改變，不能申明爲const
 93             //返回增長後的引用
 94             const_iterator & operator ++ ()
 95             {
 96                 current = current->next;
 97                 return *this;
 98             }
 99 
100             //後置，爲了與內部保持一致，返回以前的值
101             const_iterator & operator ++ (int)
102             {
103                 const_iterator ret = *this;
104                 ++*this;
105                 return ret;
106             }
107 
108             bool operator == (const const_iterator & iter) const
109             {
110                 return current == iter.current;
111             }
112 
113             bool operator != (const const_iterator & iter) const
114             {
115                 return ! (this->operator== (iter));
116             }
117         protected:
118             //定義一個Node*的變量來保存迭代器的位置，申明爲protected是爲了派生類能訪問到
119             Node* current;
120 
121             //返回迭代器所指節點數據對象的引用,不改變const_iterator的任何數據，定義爲const
122             //該函數只在內部使用，申明爲protected爲了派生類能使用
123             const Object & retrieve() const
124             {
125                 return current->data;
126             }
127             const_iterator( Node* p ) : current(p) { }
128 
129             //爲了能訪問List<Object>的成員變量，將其申明爲const_iterator的友元
130             friend class List<Object>;
131         };
132 
133 
134         //從const_iterator繼承過來
135         class iterator : public const_iterator
136         {
137         public:
138             iterator();
139             ~iterator();
140             //重載取引用操做符，解引用操做符是無參的
141             Object& operator * () const
142             {
143                 retrieve();
144             }
145 
146             iterator & operator ++ ()
147             {
148                 current = current->next;
149                 return *this;
150             }
151 
152             //後置，爲了與內部保持一致，返回以前的值
153             iterator & operator ++ (int)
154             {
155                 const_iterator ret = *this;
156                 ++*this;
157                 return ret;
158             }
159         protected:
160             iterator(Node* p) : const_iterator (p) { }
161         };
162 
163         /************************************************************************/
164         /* 函數名：begin end成員
165         /* 時   間：2016.10.27
166         /************************************************************************/
167         iterator begin()
168         {
169             return iterator(head->next);
170         }
171 
172         iterator end()
173         {
174             return iterator(tail);
175         }
176 
177         const_iterator cbegin() const
178         {
179             return const_iterator(head->next);
180         }
181 
182         const_iterator cend() const
183         {
184             return const_iterator(tail);
185         }
186 
187 
188         /************************************************************************/
189         /* 說   明：賦值和swap
190         /* 時   間：2016.10.27
191         /************************************************************************/
192 
193         /************************************************************************/
194         /* 說   明：容器大小操做
195         /* 時   間：2016.10.27
196         /************************************************************************/
197         //size函數
198         int Size() const
199         {
200             return theSize;
201         }
202 
203         bool Empty() const
204         {
205             return Size() == 0;
206         }
207 
208 
209 
210         /************************************************************************/
211         /* 說   明：向容器添加元素
212         /* 時   間：2016.10.27
213         /************************************************************************/
214         void push_back(const Object& obj)
215         {
216             insert(end(), obj);
217         }
218 
219 
220         void push_front(Object obj)
221         {
222             insert(begin(), obj);
223         }
224 
225         iterator insert(iterator it, const Object &  obj)
226         {
227             Node* p = it.current;
228             Node* node = new Node(obj, p->prev, p);
229             p->prev->next = node;
230             p->prev = node;
231             //大小加一
232             ++theSize;
233             return iterator(node);
234             //牛掰寫法：return iterator(p->prev = p->prev->next = new Node(obj, p->prev, p));
235         }
236 
237         /************************************************************************/
238         /* 說   明：訪問元素
239         /* 時   間：2016.10.27
240         /************************************************************************/
241         Object & front() const
242         {
243             return head->next->data;
244         }
245 
246         const Object & front() const
247         {
248             return head->next->data;
249         }
250 
251         Object & back() const
252         {
253             return tail->prev->data;
254         }
255 
256         const Object & back() const
257         {
258             return tail->prev->data;
259         }
260 
261         /************************************************************************/
262         /* 說   明：刪除元素
263         /* 時   間：2016.10.27
264         /************************************************************************/
265         void pop_front()
266         {
267             Node* temp = head->next;
268             temp->next->prev = head;
269             head->next = temp->next;
270             delete temp;
271             theSize--;
272         }
273 
274         void pop_back()
275         {
276             erase(--end());
277         }
278 
279         iterator erase(iterator itr)
280         {
281             Node* temp = itr.current;
282             iterator ret = ++itr;
283             temp->prev->next = temp->next;
284             temp->next->prev = temp->prev;
285             delete temp;
286             theSize--;
287             return ret;
288         }
289 
290         iterator erase(iterator itr1, iterator itr2)
291         {
292             iterator to  = ++itr2;
293             for (iterator i = itr1; i != to; )
294             {
295                 i = erase( i );
296             }
297             return i;
298         }
299 
300     private:
301         //定義節點
302         struct  Node
303         {
304             Object data;
305             Node* prev;
306             Node* next;
307             //結構體的構造函數
308             Node(Object obj = Object(), Node* p = NULL, Node* n = NULL)
309                 :data(obj), prev(p), next(n){ }
310         };
311         Node* head;   //頭結點
312         Node* tail;      //尾節點
313         int theSize;
314     };
315 }
316 #endif