1. #include "DoubleLinkedList.h"
2.  
3. // инициализация двусвязного списка
4. void InitDList(DList *L) {
5.         L->left = NULL;
6.         L->right = NULL;
7.         L->ptr = NULL;
8.         DListError = DListEmpty;
9. }
10.  
11. // включить элемент в список перед рабочим указателем
12. void PrevPutDList(DList *L, BaseType E) {
13.         PtrEl next = NULL;                              // сохранение следующего значения
14.         PtrEl prev = NULL;                              // сохранение предыдущего значения
15.         PtrEl NewEl = new elementDList [1];
16.  
17.         // если не получилось выделить память
18.         if (NewEl == NULL) {
19.                 DListError = DListNotMem;
20.                 return;
21.         }
22.  
23.         // если список пуст, то нужно указатели на левую и правую часть
24.         // списка переназначить на новый элемент
25.         if (EmptyDList(L)) {
26.                 L->left = NewEl;
27.                 L->right = L->left;
28.                 L->ptr = L->left;
29.         } else {
30.                 next = L->ptr;           // запомнить текущий элемнент
31.                 prev = L->ptr->prev; // запомнить указатель на предыдущий элемент
32.  
33.                 L->ptr->prev = NewEl;
34.                 L->ptr = NewEl;
35.  
36.                 if (BeginDList(L)) {
37.                         L->left = L->ptr;
38.                 } else {
39.                         prev->next = NewEl;
40.                 }
41.         }
42.  
43.         L->ptr->next = next;
44.         L->ptr->prev = prev;
45.         L->ptr->data = E;
46.         DListError = DListOk;
47. }
48.  
49. // включить элемент в список после рабочего указателя
50. void NextPutDList(DList *L, BaseType E) {
51.         PtrEl next = NULL;
52.         PtrEl prev = NULL;
53.         PtrEl NewEl = new elementDList [1];
54.  
55.         if (NewEl == NULL) {
56.                 DListError = DListNotMem;
57.                 return;
58.         }
59.  
60.         if (EmptyDList(L)) {
61.                 L->left = NewEl;
62.                 L->right = L->left;
63.                 L->ptr = L->left;
64.         } else {
65.                 next = L->ptr->next;
66.                 prev = L->ptr;
67.  
68.                 L->ptr->next = NewEl;
69.                 L->ptr = NewEl;
70.  
71.                 if (EndDList(L)) {
72.                         L->right = NewEl;
73.                 } else {
74.                         next->prev = NewEl;
75.                 }
76.         }
77.  
78.         L->ptr->next = next;
79.         L->ptr->prev = prev;
80.         L->ptr->data = E;
81.         DListError = DListOk;
82. }
83.  
84. // исключить элемент из списка до указателя
85. void PrevGetDList(DList *L, BaseType *E) {
86.         if (EmptyDList(L)) {
87.                 return;
88.         }
89.  
90.         ReadDList(L, E);
91.  
92.         if (L->left == L->right && L->left == L->ptr) {
93.                 *E = L->ptr->data;
94.                 delete L->ptr;
95.                 L->ptr = NULL;
96.                 L->left = NULL;
97.                 L->right = NULL;
98.                 return;
99.         }
100.  
101.         if (BeginDList(L)) {
102.                 return;
103.         } else {
104.                 *E = L->ptr->prev->data;
105.                 if (L->ptr->prev->prev) {
106.                         PtrEl pntr = L->ptr->prev;
107.                         delete L->ptr->prev;
108.                         L->ptr->prev = pntr->prev;
109.                         pntr->prev->next = L->ptr;
110.                 } else {
111.                         L->left = L->ptr;
112.                         delete L->ptr->prev;
113.                         L->ptr->prev = NULL;
114.                 }
115.  
116.         }
117.  
118. }
119.  
120. // исключить элемент из списка после указателя
121. void NextGetDList(DList *L, BaseType *E) {
122.         if (EmptyDList(L)) {
123.                 return;
124.         }
125.  
126.         if (L->left == L->right && L->left == L->ptr) {
127.                 *E = L->ptr->data;
128.                 delete L->ptr;
129.                 L->ptr = NULL;
130.                 L->left = NULL;
131.                 L->right = NULL;
132.                 return;
133.         }
134.  
135.         if (EndDList(L)) {
136.                 return;
137.         } else {
138.                 *E = L->ptr->next->data;
139.                 if (L->ptr->next->next) {
140.                         PtrEl pntr = L->ptr->next->next;
141.                         delete L->ptr->next;
142.                         L->ptr->next = pntr;
143.                         L->ptr->next->prev = L->ptr;
144.                 } else {
145.                         L->right = L->ptr;
146.                         delete L->ptr->next;
147.                         L->ptr->next = NULL;
148.                 }
149.  
150.         }
151.  
152. }
153.  
154. // прочитать текущий элемент из списка
155. void ReadDList(DList *L, BaseType *E) {
156.         if (EmptyDList(L)) {
157.                 return;
158.         }
159.  
160.         *E = L->ptr->data;
161. }
162.  
163. // удалить список
164. void DoneDList(DList *L) {
165.         BeginPtrDList(L);
166.         BaseType e;
167.  
168.         while (!EmptyDList(L)) {
169.                 NextGetDList(L, &e);
170.         }
171.  
172.         NextGetDList(L, &e);
173. }
174.  
175. // передвинуть указатель вперед
176. void NextMoveDList(DList *L) {
177.         if (!EndDList(L)) {
178.                 L->ptr = L->ptr->next;
179.         }
180. }
181.  
182. // передвинуть указатель назад
183. void PrevMoveDList(DList *L) {
184.         if (!BeginDList(L)) {
185.                 L->ptr = L->ptr->prev;
186.         }
187. }
188.  
189. // проверить, пуст ли список
190. int EmptyDList(DList *L) {
191.         if (!L->left && !L->right) {
192.                 DListError = DListEmpty;
193.                 return 1;
194.         }
195.  
196.         return 0;
197. }
198.  
199. // проверить, на начале ли списка установлен рабочий указатель
200. int BeginDList(DList *L) {
201.         if (EmptyDList(L) || !L->ptr->prev) {
202.                 DListError = DListBegin;
203.                 return 1;
204.         }
205.  
206.         return 0;
207. }
208.  
209. // проверить, в конце ли списка установлен рабочий указатель
210. int EndDList(DList *L) {
211.         if (EmptyDList(L) || !L->ptr->next) {
212.                 DListError = DListEnd;
213.                 return 1;
214.         }
215.  
216.         return 0;
217. }
218.  
219. // установить указатель в начало
220. void BeginPtrDList(DList *L) {
221.         L->ptr = L->left;
222.         BeginDList(L);
223. }
224.  
225. // установить указатель в конец
226. void EndPtrDList(DList *L) {
227.         L->ptr = L->right;
228.         EndDList(L);
229. }
230.  
231. // получить последнюю ошибку списка
232. int GetLastErrorDList() {
233.         return DListError;
234. }