1 #ifndef _LIST_H_
2 #define _LIST_H_
3 //虚基类
4 template<class ElemType>
5 class List
6 {
7 public:
8 List() {};
9 virtual ~List() {};
10 virtual void Clear() = 0;//清空数据结构
11 virtual void Insert(const int& i, const ElemType& X) = 0;//插入元素
12 virtual void ReMove(const int &i) = 0;//移除指定位置的元素
13 virtual void Erase(const ElemType& X) = 0;//删除表中所有X元素
14 virtual int Search(const ElemType& X) const = 0;//搜索某个元素
15 virtual void Traverse() const = 0;//遍历数据结构
16 virtual ElemType Visit(const int& i)const = 0;//访问某个元素
17 };
18 #endif // !_LIST_H_
1 #ifndef __SCYCLISTLIST_H__
2 #define __SCYCLISTLIST_H__
3 #include "List.h"
4 template<class ElemType>
5 class sCycleList :public List<ElemType>
6 {
7 private:
8 struct Node
9 {
10 ElemType data;
11 Node* next;
12 Node(const ElemType& x, Node* n = nullptr) :data(x), next(n) {}
13 Node() :next(nullptr) {}
14 };
15 Node* Head;
16 int CurrentLength;
17 Node* Move(int i) const;
18 public:
19 sCycleList() :Head(nullptr), CurrentLength(0){};
20 ~sCycleList() { Clear(); };
21 virtual void Clear() override;//清空数据结构
22 virtual void Insert(const int& i, const ElemType& X) override;//插入元素
23 virtual void ReMove(const int& i) override;//移除指定位置的元素
24 virtual void Erase(const ElemType& X) override;//删除表中所有X元素
25 virtual int Search(const ElemType& X) const override;//搜索某个元素
26 virtual void Traverse() const override;//遍历数据结构
27 virtual ElemType Visit(const int& i)const override;//访问某个元素
28 void Inverse();//逆置
29 const int GetSize() const { return CurrentLength; }
30 /*--------迭代器--------*/
31 class Iterator
32 {
33 friend sCycleList;
34 private:
35 Node* cur;
36 public:
37
38 Iterator(Node* p=nullptr) :cur(p) {}
39 Iterator operator ++(int)
40 {
41 Node* tmp = cur;
42 cur = cur->next;
43 return tmp;
44 }
45 Iterator operator ++()
46 {
47 return cur = cur->next;
48 }
49
50 ElemType& operator *()
51 {
52 return cur->data;
53 }
54 bool operator ==(const Iterator& x)
55 {
56 return cur == x.cur;
57 }
58 bool operator !=(const Iterator& x)
59 {
60 return cur != x.cur;
61 }
62 bool IsNull(const Iterator& x)
63 {
64 return x == nullptr;
65 }
66
67 };
68 Iterator begin() const;
69 void insert(Iterator& p, const ElemType& x);
70 void erase(Iterator& p);
71 Iterator search(const ElemType& x);
72 void traverse(const sCycleList& sList) const;
73 };
74
75
76 template<class ElemType>
77 typename sCycleList<ElemType>::Node* sCycleList<ElemType>::Move(int i) const
78 {
79 Node* tmp = Head;
80 while (--i >= 0)
81 {
82 tmp = tmp->next;
83 }
84 return tmp;
85 }
86
87 template<class ElemType>
88 void sCycleList<ElemType>::Clear()
89 {
90 if (Head != nullptr)
91 {
92 Node* beg = Head, * tmp = nullptr;
93 do
94 {
95 tmp = Head->next;
96 delete Head;
97 Head = tmp;
98 --CurrentLength;
99 } while (beg == Head);
100 }
101 }
102
103 template<class ElemType>
104 void sCycleList<ElemType>::Insert(const int& i, const ElemType& X)
105 {
106 if (Head == nullptr)
107 {
108 Head = new Node(X, Head);
109 Head->next = Head;
110 }
111 else
112 {
113 if (i == 0)
114 {
115 Node* newNode = new Node(X, Head);
116 Head = newNode;
117 Node* tail = Move(CurrentLength);
118 tail->next = Head;
119 }
120 else
121 {
122 Node* pre = Move(i - 1);
123 Node* newNode = new Node(X, pre->next);
124 pre->next = newNode;
125 }
126 }
127 ++CurrentLength;
128 }
129
130 template<class ElemType>
131 void sCycleList<ElemType>::ReMove(const int& i)
132 {
133 Node* pre = Move(i - 1);
134
135 if (pre == Head)
136 {
137 Node* delp = pre;
138 Head = Head->next;
139 delete delp;
140 Node* tail = Move(CurrentLength-1);
141 tail->next = Head;
142 }
143 else
144 {
145 Node* delp = pre->next;
146 pre->next = pre->next->next;
147 delete delp;
148 }
149 --CurrentLength;
150 }
151
152 template<class ElemType>
153 void sCycleList<ElemType>::Erase(const ElemType& X)
154 {
155 if (Head == nullptr)
156 return;
157 int num = CurrentLength;
158 Node* p = Head;
159 Node* tail = Move(CurrentLength-1);
160 Node* pre = Head;
161 while (num--)
162 {
163 if (num + 1 == CurrentLength)
164 {
165 if (p->data == X)
166 {
167 Head = Head->next;
168 tail->next = Head;
169 delete p;
170 p = Head;
171 --CurrentLength;
172 }
173 else
174 {
175 pre = p;
176 p = p->next;
177 }
178 }
179 else
180 {
181 if (p->data == X)
182 {
183 if (p == Head)
184 {
185 Head = Head->next;
186 tail->next = Head;
187 delete p;
188 p = Head;
189 }
190 else
191 {
192 p = p->next;
193 delete pre->next;
194 pre->next = p;
195 }
196 --CurrentLength;
197 }
198 else
199 {
200 pre = p;
201 p = p->next;
202 }
203 }
204 }
205 }
206
207 template<class ElemType>
208 int sCycleList<ElemType>::Search(const ElemType& X) const
209 {
210 Node* p = Head;
211 int i = 0;
212 while (p->data != X)
213 {
214 ++i;
215 if (i == CurrentLength)
216 return -1;
217 p = p->next;
218 }
219 return i;
220 }
221
222 template<class ElemType>
223 void sCycleList<ElemType>::Traverse() const
224 {
225 int num = CurrentLength;
226 Node* p = Head;
227 while (num--)
228 {
229 std::cout << p->data << std::endl;
230 p = p->next;
231 }
232 }
233
234 template<class ElemType>
235 ElemType sCycleList<ElemType>::Visit(const int& i) const
236 {
237 return Move(i)->data;
238 }
239
240 template<class ElemType>
241 void sCycleList<ElemType>::Inverse()
242 {
243 Node* pn = Head->next;
244 Node* tmp = Head;
245 while (pn!= tmp)
246 {
247 Node* pt = pn->next;
248 Node* pr = Head;
249 Head = pn;
250 Head->next = pr;
251 pn = pt;
252 }
253 pn->next = Head;
254 }
255
256 template<class ElemType>
257 typename sCycleList<ElemType>::Iterator sCycleList<ElemType>::begin() const
258 {
259 return Head;
260 }
261
262
263
264 template<class ElemType>
265 void sCycleList<ElemType>::insert(Iterator& p, const ElemType& x)
266 {
267 if (p.cur == nullptr)
268 {
269 Head = p.cur = new Node(x);
270 Head->next = Head;
271 }
272 else
273 {
274 p.cur = p.cur->next = new Node(x, p.cur->next);
275 }
276 ++CurrentLength;
277 }
278
279 template<class ElemType>
280 void sCycleList<ElemType>::erase(Iterator& p)
281 {
282 if (nullptr == p.cur)
283 {
284 return;
285 }
286 if (p.cur->next == p.cur)
287 {
288 delete p.cur;
289 Head = p.cur = nullptr;
290 }
291 else
292 {
293 Node* q = p.cur->next;
294 p.cur->next = q->next;
295 if (q == Head)
296 Head = q->next;
297 delete q;
298 }
299 --CurrentLength;
300 }
301
302 template<class ElemType>
303 typename sCycleList<ElemType>::Iterator sCycleList<ElemType>::search(const ElemType& x)
304 {
305 Iterator p = begin(), q = p;
306 for (++p; p != q; ++p)
307 if (x == *p)
308 return p;
309 return nullptr;
310 }
311
312 template<class ElemType>
313 void sCycleList<ElemType>::traverse(const sCycleList &sList) const
314 {
315 int i = 0;
316 for (Iterator Itr = sList.begin(); i++ < sList.GetSize(); ++Itr)
317 {
318 std::cout << *Itr << std::endl;
319 }
320 }
321 #endif
1 #include <iostream>
2 #include <string.h>
3 #include "sCycleList.h"
4 void IntTest()
5 {
6 std::cout<< "\n----------------------IntTest----------------------" << std::endl;
7 sCycleList<int> sList;
8 for (int i = 0; i < 10; ++i)
9 sList.Insert(i,i+10);
10 sList.Traverse();
11 std::cout << "---------ReMove---------" << std::endl;
12 sList.ReMove(0);
13 sList.Traverse();
14 std::cout << "---------Insert---------" << std::endl;
15 sList.Insert(9, 9999);
16 sList.Insert(0, 777);
17 sList.Insert(4, 777);
18 sList.Insert(4, 777);
19 sList.Insert(10, 777);
20 sList.Traverse();
21 std::cout << "---------Erase---------" << std::endl;
22 sList.Erase(777);
23 sList.Erase(-111);
24 sList.Traverse();
25 std::cout << "---------Search---------" << std::endl;
26 std::cout << sList.Search(1111111)<<std::endl;
27 std::cout << "---------Visit---------" << std::endl;
28 std::cout << sList.Visit(11) << std::endl;
29 std::cout << "---------Inverse---------" << std::endl;
30 sList.Inverse();
31 sList.Traverse();
32 }
33
34 void StringTest()
35 {
36 std::cout << "\n----------------------StringTest----------------------" << std::endl;
37 std::string sarr[] = { "aaaa", "bbb", "ccc", "ddd","eee", "fff", "ggg", "hhh","iii","jjj" };
38 sCycleList<std::string> sList;
39 for (int i = 0; i < 10; ++i)
40 sList.Insert(i, sarr[i]);
41 sList.Traverse();
42 std::cout << "---------ReMove---------" << std::endl;
43 sList.ReMove(0);
44 sList.Traverse();
45 std::cout << "---------Insert---------" << std::endl;
46 sList.Insert(0,"ggg");
47 sList.Insert(3, "ggg");
48 sList.Traverse();
49 std::cout << "---------Erase---------" << std::endl;
50 sList.Erase("ggg");
51 sList.Traverse();
52 std::cout << "---------Search---------" << std::endl;
53 std::cout << sList.Search("ddd") << std::endl;
54 std::cout << "---------Visit---------" << std::endl;
55 std::cout << sList.Visit(5) << std::endl;
56 std::cout << "---------Inverse---------" << std::endl;
57 sList.Inverse();
58 sList.Traverse();
59 }
60
61 struct MyStruct
62 {
63 int id;
64 char name[20];
65 void copy(const MyStruct& tmp)
66 {
67 id = tmp.id;
68 for (int i = 0; i < 20; ++i)
69 {
70 name[i] = tmp.name[i];
71 }
72 }
73 bool operator ==(const MyStruct&tmp) const
74 {
75 if (this->id == tmp.id)
76 {
77 for (int i = 0; i < 20; ++i)
78 {
79 if (this->name[i] != tmp.name[i])
80 return false;
81 }
82 }
83 else
84 {
85 return false;
86 }
87 return true;
88 }
89 MyStruct& operator =(const MyStruct& right)
90 {
91 copy(right);
92 return *this;
93 }
94
95 bool operator !=(const MyStruct& right)
96 {
97 if (right == *this)
98 return false;
99 return true;
100 }
101
102 friend std::ostream& operator <<(std::ostream &os,const MyStruct&self)
103 {
104 os << self.id << " " << self.name;
105 return os;
106 }
107 };
108 static MyStruct Stdudent[10] =
109 {
110 {1,"ge"},
111 {2,"sheng"},
112 {3,"lu"},
113 {4,"ge1"},
114 {5,"sheng1"},
115 {6,"lu1"},
116 {7,"ge2"},
117 {8,"sheng2"},
118 {9,"lu2"},
119 {10,"lu3"},
120 };
121
122 void ObjectTest()
123 {
124 std::cout << "\n----------------------ObjectTest----------------------" << std::endl;
125 sCycleList<MyStruct> sList;
126 for (int i = 0; i < 10; ++i)
127 sList.Insert(i, Stdudent[i]);
128 sList.Traverse();
129 std::cout << "---------ReMove---------" << std::endl;
130 sList.ReMove(0);
131 sList.Traverse();
132 std::cout << "---------Insert---------" << std::endl;
133 sList.Insert(0, Stdudent[7]);
134 sList.Insert(3, Stdudent[7]);
135 sList.Traverse();
136 std::cout << "---------Erase---------" << std::endl;
137 sList.Erase(Stdudent[7]);
138 sList.Traverse();
139 std::cout << "---------Search---------" << std::endl;
140 std::cout << sList.Search(Stdudent[5]) << std::endl;
141 std::cout << "---------Visit---------" << std::endl;
142 std::cout << sList.Visit(5) << std::endl;
143 std::cout << "---------Inverse---------" << std::endl;
144 sList.Inverse();
145 sList.Traverse();
146 }
147
148 void TestIterator()
149 {
150 std::cout << "\n----------------------TestIterator----------------------" << std::endl;
151 sCycleList<MyStruct> sList;
152 sCycleList<MyStruct>::Iterator Itr;
153
154 for (int i = 0; i < 10; ++i)
155 sList.Insert(i, Stdudent[i]);
156 sList.traverse(sList);
157 sCycleList<MyStruct>::Iterator Itr2(sList.begin());
158
159 std::cout << "---------begin() ++ end()---------" << std::endl;
160 int i = 0;
161 for (Itr = sList.begin(); i++ <= sList.GetSize(); ++Itr)
162 {
163 std::cout << *Itr << std::endl;
164 }
165 Itr = sList.begin();
166 std::cout << "--------- == != ---------" << std::endl;
167 if (Itr2 == Itr)
168 {
169 std::cout << "==" << std::endl;
170 }
171 else
172 {
173 std::cout << "!=" << std::endl;
174 }
175 std::cout << "---------insert---------" << std::endl;
176 sList.insert(Itr, Stdudent[2]);
177 sList.traverse(sList);
178
179 std::cout << "---------erase---------" << std::endl;
180 sList.erase(Itr);
181 sList.traverse(sList);
182
183 std::cout << "---------search---------" << std::endl;
184 ++Itr;
185 ++Itr;
186 sCycleList<MyStruct>::Iterator Itr3(sList.search(*(Itr)));
187 if (Itr3!=nullptr)
188 {
189 std::cout << *Itr3 << std::endl;
190 }
191 }
192
193 int main()
194 {
195 /*IntTest();
196 StringTest();
197 ObjectTest();*/
198 TestIterator();
199 return 0;
200 }
来源：https://www.cnblogs.com/jiangnansytle/p/12367041.html