1. #include <iostream>
2.  
3. using namespace std;
4.  
5. class Element
6. {
7.         private:
8.                 int v;
9.                 Element* next;
10.  
11.         public:
12.         Element()
13.         {
14.             v = 0;
15.             next = nullptr;
16.         }
17.         Element(int x, Element* next)
18.         {
19.             v = x;
20.             this->next = next;
21.         }
22.         int getValue()
23.         {
24.             return v;
25.         }
26.         void setValue(int v)
27.         {
28.             this->v = v;
29.             this->v = v;
30.         }
31.         Element* getNext()
32.         {
33.             return next;
34.         }
35.         void setNext(Element* p)
36.         {
37.             next = p;
38.         }
39. };
40.  
41. class LinkedList
42. {
43.     private:
44.         Element* head;                    
45.         Element* tail;                  
46.         int size;
47.  
48.     public:
49.         LinkedList()
50.         {
51.             head = nullptr;
52.             tail = nullptr;
53.             size = 0;
54.         }
55.         bool empty()
56.         {
57.             if (size == 0)
58.                 return true;
59.             else
60.                 return false;
61.         }
62.         int getSize()
63.         {
64.             return size;
65.         }
66.         Element* getFirst()
67.         {
68.             return head;
69.         }
70.         Element* getLast()
71.         {
72.             return tail;
73.         }
74.         Element* getNext(Element* p)
75.         {
76.             return p->getNext();
77.         }
78.         Element* getPrev(Element* p)
79.         {
80.             Element* tmp = head;
81.  
82.             do
83.             {
84.                 if (tmp->getNext() == p)
85.                     return tmp;
86.                 else
87.                     tmp = tmp->getNext();
88.             } while (tmp->getNext() != p);
89.  
90.             return nullptr;
91.         }
92.         int retrive(Element* p)
93.         {
94.             return p->getValue();
95.         }
96.         Element* locate(int x)
97.         {
98.             Element* tmp = head;
99.  
100.             for(int i = 0; i < size; i++)
101.             {
102.                 tmp = tmp->getNext();
103.                 if (tmp->getValue() == x)
104.                     return tmp;
105.             }
106.  
107.             return nullptr;
108.         }
109.         void append(int x)
110.         {
111.             if (empty())
112.             {
113.                 head = new Element(x, nullptr);
114.                 tail = head;
115.             }
116.             else
117.             {
118.                 tail->setNext(new Element(x, nullptr));
119.                 tail = tail->getNext();
120.             }
121.  
122.             size++;
123.         }
124.         void insert(Element* p, int x)
125.         {
126.             p->setValue(x);
127.         }
128.         void del(Element* p)
129.         {
130.             if (p == head)
131.             {
132.                 head = head->getNext();
133.                 delete p;
134.                 if (head == nullptr)
135.                     tail = nullptr;
136.             }
137.             else
138.             {
139.                 Element* tmp = getPrev(p);
140.                 tmp->setNext(getNext(p));
141.                 delete p;
142.                 if (getNext(tmp) == nullptr)
143.                     tail = tmp;
144.             }
145.  
146.             size--;
147.         }
148.         void clear()
149.         {
150.             Element* tmp;
151.  
152.             while (head != nullptr)
153.             {  
154.                 tmp = getNext(head);
155.                 delete head;
156.                 head = tmp;
157.             }  
158.         }
159.         friend ostream& operator<<(ostream& out, LinkedList* l)
160.         {
161.             Element* tmp = l->head;
162.  
163.             for (int i = 0; i < l->getSize(); i++)
164.             {
165.                 out << tmp->getValue() << " | ";
166.                 tmp = tmp->getNext();
167.             }
168.  
169.             return out;
170.         }
171.         void insert(int p, int x)
172.         {
173.             Element* tmp = head;
174.  
175.             for (int i = 0; i < p; i++)
176.             {
177.                 tmp = tmp->getNext();
178.             }
179.  
180.             Element* tmp2 = tmp;
181.            
182.             for (int i = p; i < size; i++)
183.             {
184.                 tmp->setValue(x);
185.                 tmp->setNext(tmp2);
186.                 tmp = tmp2;
187.                 tmp2 = tmp2->getNext();
188.             }
189.  
190.             size++;
191.  
192.             tail = tmp2;
193.         }
194.         void del(int p)
195.         {
196.             Element* tmp = head;
197.  
198.             for (int i = 0; i < p; i++)
199.             {
200.                 tmp = tmp->getNext();
201.             }
202.  
203.             del(tmp);
204.         }
205.         ~LinkedList();
206. };
207.  
208.  
209. int main()
210. {
211.     //Zadanie 5.1 - test
212.     cout << endl << "Zadanie 5.1 - test" << endl;
213.  
214.     LinkedList* a = new LinkedList();
215.  
216.     cout << endl << "empty(): 1 - " << a->empty();
217.     cout << endl << "getSize():  0 - " << a->getSize();
218.     cout << endl << "append(4): 4 | - "; a->append(4); cout << " " << a;
219.     cout << endl << "append(6): 4 | 6 | - "; a->append(6); cout << " " << a;
220.     //cout << endl << ": -" << ;
221.     cout << endl << "retrive(getPrev(tail)): 4 - " << a->retrive(a->getPrev(a->getLast()));
222.     cout << endl << "locate(6): adress - " << a->locate(6);
223.     cout << endl << "locate(7): nullptr - " << a->locate(7);
224.  
225.  
226.         return 0;
227. }