constk

Одинокий суслик

Sep 21st, 2021
708
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #pragma once
  2.  
  3. #include "List.h"
  4.  
  5. template <typename Type>
  6. ref class CyclicSingleList : public List<Type>
  7. {
  8.     template <typename Type>
  9.     ref struct Node
  10.     {
  11.         Type data;
  12.         Node^ next = nullptr;
  13.     };
  14.  
  15. public:
  16.     CyclicSingleList();
  17.     ~CyclicSingleList();
  18.  
  19.     void Print(System::Windows::Forms::ListBox^ listBoxForPrint) override; // печать списка
  20.  
  21.     void InsertToBegin(Type) override; // вставка в начало
  22.     void Insert(Type, int) override; // вставка после элемента с указанным индексом
  23.  
  24.     void Delete(int) override; // удаление элемента с указанным индексом
  25.     void Clear() override; // удаление всего списка
  26.  
  27.     int Find(Type) override; // поиск элемента
  28.     Type At(int) override; // возвращает элемент с указанным индексом
  29.     bool IsEmpty() override; // проверка списка на пустоту
  30.     int Size() override; // возвращает размер списка
  31.  
  32. protected:
  33.     void CreateFirst(Type) override; // создать первый элемент списка
  34.  
  35.     Node<Type>^ head = nullptr; // указатель на начало списка
  36.     Node<Type>^ current = nullptr; // указатель на текущий элемент списка
  37. };
  38.  
  39. // ####################################### Реализация #######################################
  40.  
  41. // конструктор по умолчанию
  42. template<typename Type>
  43. CyclicSingleList<Type>::CyclicSingleList()
  44. {
  45.     head = nullptr;
  46. }
  47.  
  48. // деструктор
  49. template<typename Type>
  50. inline CyclicSingleList<Type>::~CyclicSingleList()
  51. {
  52.     if (this->IsEmpty())
  53.         return;
  54.     this->Clear();
  55. }
  56.  
  57. // печать списка
  58. template<typename Type>
  59. void CyclicSingleList<Type>::Print(System::Windows::Forms::ListBox^ listBoxForPrint)
  60. {
  61.     listBoxForPrint->ClearSelected();
  62.     listBoxForPrint->Items->Clear();
  63.     for (int i = 0; i != size; ++i)
  64.         listBoxForPrint->Items->Add(this->At(i));
  65. }
  66.  
  67. // вставка в начало
  68. template<typename Type>
  69. inline void CyclicSingleList<Type>::InsertToBegin(Type value)
  70. {
  71.     if (this->IsEmpty())
  72.         this->CreateFirst(value);
  73.     else
  74.     {
  75.         Node<Type>^ tmp = gcnew Node<Type>;
  76.         current = head;
  77.         tmp->data = value;
  78.         tmp->next = head;
  79.  
  80.         // следим, чтобы последний элемент списка всегда указывал на первый
  81.         while (current->next != head)
  82.             current = current->next;
  83.         current->next = tmp;
  84.         this->head = tmp;
  85.         this->size++;
  86.     }
  87. }
  88.  
  89. // вставка после элемента с указанным индексом
  90. template<typename Type>
  91. inline void CyclicSingleList<Type>::Insert(Type value, int index)
  92. {
  93.     if (this->IsEmpty())
  94.         throw gcnew System::Exception("List is empty");
  95.     if (index >= size)
  96.         throw gcnew System::IndexOutOfRangeException("Can not insert element");
  97.  
  98.     current = head;
  99.     for (int i = 0; i != index + 1; ++i)
  100.     {
  101.         if (i == index)
  102.         {
  103.             Node<Type>^ tmp = gcnew Node<Type>;
  104.             tmp->data = value;
  105.             tmp->next = current->next;
  106.             current->next = tmp;
  107.             this->size++;
  108.         }
  109.         current = current->next;
  110.     }
  111. }
  112.  
  113. // удаление элемента с указанным индексом
  114. template<typename Type>
  115. inline void CyclicSingleList<Type>::Delete(int index)
  116. {
  117.     if (this->IsEmpty())
  118.         throw gcnew System::Exception("List is empty");
  119.     if (index >= size)
  120.         throw gcnew System::IndexOutOfRangeException("Can not delete list element");
  121.  
  122.     current = head;
  123.     if (index == 0 && size == 1)
  124.         this->Clear();
  125.     else if (index == 0)
  126.     {
  127.         while (current->next != head)
  128.             current = current->next;
  129.         current->next = head->next;
  130.  
  131.         current = head;
  132.         head = current->next;
  133.         delete current;
  134.         --size;
  135.     }
  136.     else if (index < size)
  137.     {
  138.         Node<Type>^ prev = head;
  139.         current = head->next;
  140.         for (int i = 1; i != index; ++i)
  141.         {
  142.             prev = current;
  143.             current = current->next;
  144.         }
  145.         prev->next = current->next;
  146.         delete current;
  147.         --size;
  148.     }
  149. }
  150.  
  151. // удаление всего списка
  152. template<typename Type>
  153. inline void CyclicSingleList<Type>::Clear()
  154. {
  155.     if (this->IsEmpty())
  156.         return;
  157.     if (size == 1)
  158.     {
  159.         delete head;
  160.         head = nullptr;
  161.         size = 0;
  162.         return;
  163.     }
  164.  
  165.     for (int i = 1; i != size; ++i)
  166.         this->Delete(i);
  167.     this->Delete(0);
  168.    
  169.     head = nullptr;
  170. }
  171.  
  172. // поиск элемента
  173. template<typename Type>
  174. inline int CyclicSingleList<Type>::Find(Type dataToFind)
  175. {
  176.     if (this->IsEmpty())
  177.         throw gcnew System::Exception("List is empty");
  178.  
  179.     if (head->data == dataToFind)
  180.         return 0;
  181.  
  182.     current = head->next;
  183.     int index = 1;
  184.     while (current != head)
  185.     {
  186.         if (current->data == dataToFind)
  187.             return index;
  188.         ++index;
  189.         current = current->next;
  190.     }
  191.  
  192.     return -1;
  193. }
  194.  
  195. // возвращает элемент с указанным индексом
  196. template<typename Type>
  197. inline Type CyclicSingleList<Type>::At(int index)
  198. {
  199.     if (this->IsEmpty())
  200.         throw gcnew System::Exception("List is empty");
  201.     if (index >= size)
  202.         throw gcnew System::IndexOutOfRangeException("Can not get list element");
  203.  
  204.     if (index == 0)
  205.         return head->data;
  206.     else
  207.     {
  208.         current = head->next;
  209.         for (int i = 1; i != index + 1; ++i)
  210.         {
  211.             if (i == index)
  212.                 return current->data;
  213.             current = current->next;
  214.         }
  215.     }
  216. }
  217.  
  218. // проверка списка на пустоту
  219. template<typename Type>
  220. inline bool CyclicSingleList<Type>::IsEmpty()
  221. {
  222.     if (head == nullptr)
  223.         return true;
  224.     return false;
  225. }
  226.  
  227. // возвращает размер списка
  228. template<typename Type>
  229. inline int CyclicSingleList<Type>::Size()
  230. {
  231.     return this->size;
  232. }
  233.  
  234. // создать первый элемент списка
  235. template<typename Type>
  236. inline void CyclicSingleList<Type>::CreateFirst(Type value)
  237. {
  238.     this->head = gcnew Node<Type>;
  239.     this->head->data = value;
  240.     this->head->next = head;
  241.     this->size++;
  242. }
  243.  
RAW Paste Data