Facebook
From Chocolate Echidna, 2 Months ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 23
  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. }