template <class T> class Node
{

   public:
    int ni; //кол-во эл-в я ячейке(=5)
    int nj; //кол-во ячеек
    T *mt;
    int k;
 class spisok
 {
  public:
  spisok *next;
  T *K;
  spisok(){K=new T[ 5 ];}
  ~spisok (){delete []K;}
 };
 public:
 spisok *root;
 Node(int n,int m){k= 0 ;ni=n;nj=m;mt=new T[ni*nj];root=NULL;}
 ~Node (){delete []mt;};

 //добавление
void Add( T y)
 {
   spisok *el=new spisok;
   el->next=NULL;
   spisok *cur=root;
  if (root==NULL)
   {nj++; root=el; mt[k]=y; k++;}
  else
  {while (cur->next!=NULL)
    {if ((k/ 5 )<=nj)
         {mt[k]=y;k++;}
      else {cur=cur->next;
                 cur->next=el;nj++;mt[k]=y;k++;}
     }
      }
     };

template <class T> class MySet
{

  class Node
 {
   public:
   T *K;
   Node *next;
   Node(){ K=new T[ 5 ];}
  ~Node(){delete []K;}
  };

 public:
  Node *root;
  MySet(){root=NULL;}
 // ~MySet();



 //Добавление элемента
 void Add(T y)
 {

   Node *el=new Node;
   Node *cur=root;
   el->next=NULL;

  if (root==NULL)
   { root=el;
      }
  else
    {

     while (cur->next!=NULL)

        cur=cur->next;
        cur->next=el;
    }
};

//Удаление
 void Dell( )
 {
  Node *cur=root;
  if (root==NULL)
    return;
  else
    {
     delete cur->next;
     cur->next=NULL;
    }
  };

 //доступ по индексу
T& operator[](int i)
{ Node *cur;
 for (cur=root;int k= 0 ,k<i/ 5 ;k++)
 cur=cur->next;
 return cur->k[i% 5 ];
};
};

template<class T>
class MyListFragment       // все для одного фрагмента
{
private:
    T* m_data;  //выделяем память   под фрагмент
    int m_length;  //кол-во эл-в в
    int m_count;   //счетик(сколько добавили)

public:
    MyListFragment* Next;
/**********************************************************************************/
    MyListFragment(int capacity)   //конструктор
    {
        m_data = new T[capacity];
        m_length = capacity;
        m_count =  0 ;
        Next = NULL;
    }
/*********************************************************************************/
    ~MyListFragment()                //дестуктор
    {
        if (Next != NULL)
        {
            delete Next;
        }
        delete [] m_data;
    }
/*********************************************************************************/
    void Add(T value)
    {
        if (!IsFull())
        {
            m_data[m_count] = value;
            ++m_count;
        }
    }
 /*******************************************************************************/
  T Remove(int index)
    {
        if (index >=  0  && index < m_count)
        {
            int result = m_data[index];
            for (int i = index; i < m_count -  1 ; ++i)
            {
                m_data = m_data[i +  1 ];
            }
            --m_count;
            return result;
        }
    }
/********************************************************************************/
    T Get(int index)
    {
        if (index >=  0  && index < m_count)
        {
            return m_data[index];
        }
     }
/********************************************************************************/
    bool IsFull()
    {
        return m_length == m_count;
    }
/********************************************************************************/
    int Count()
    {
        return m_count;
    }
/********************************************************************************/
    int Capacity()    //размер фрагмента
    {
        return m_length;
    }
/********************************************************************************/
};
/********************************************************************************/
template<class T>
class MyList
{
private:
    MyListFragment<T>* m_firstFragment;
    const static int m_fragmentsCapacity =  5 ;
public:
/*******************************************************************************/
    MyList()                          //конструктор
    {
        m_firstFragment = NULL;
    }
/********************************************************************************/
     ~MyList()                             //деструктор
    {
        if (m_firstFragment != NULL)
        {
            delete m_firstFragment;
        }
    }
/********************************************************************************/
    int Get (int index)                        //доступ по индексу
    {
        if (index >=  0  && index < Count())
        {
            MyListFragment<T>* fragment = m_firstFragment;
            int i =  0 ;
            while (fragment != NULL)
            {
                if (index < i + fragment->Capacity()) //i+длина фрагмента
                {
                    return fragment->Get(index - i);
                }
                i += fragment->Count();
                fragment = fragment->Next;
            }
        }
     }
/************************************************************************************************/
  void Remove(T value)
    {
        MyListFragment<T>* fragment = m_firstFragment;
        while (fragment != NULL)
        {
            for (int j =  0 ; j < fragment->Count(); j++)
            {
                if (fragment->Get(j) == value)
                {
                    fragment->Remove(j);
                    while (fragment != NULL && fragment->Next != NULL && fragment->Next->Count() >  0 )
                    {
                        int removed = fragment->Next->Remove( 0 );
                        fragment->Add(removed);
                        if (fragment->Next->Count() ==  0 )
                        {
                            delete fragment->Next; 
                            fragment->Next = NULL;
                        }
                        fragment = fragment->Next;
                    }
                    break;
                }
            }
           [i] fragment = fragment->Next;        }
    }
/**************************************************************************************/
   void Add(T value)
    {
        if (m_firstFragment == NULL)
        {
            m_firstFragment = new MyListFragment<T>(m_fragmentsCapacity);
        }

        MyListFragment<T>* fragment = m_firstFragment;
        while (true)
        {
            if (fragment->IsFull())
            {
                if (fragment->Next == NULL)
                {
                    fragment->Next = new MyListFragment<T>(m_fragmentsCapacity);
                }
                fragment = fragment->Next;
            }
            else
            {
                fragment->Add(value);
                break;
            }
        }
    }
/************************************************************************************/
    int Count()   //считает кол-во эл-в массива
    {
        int result =  0 ;
        MyListFragment<T>* fragment = m_firstFragment;
        while (fragment != NULL)
        {
            result += fragment->Count();
            fragment = fragment->Next;
        }
        return result;
    }
/***********************************************************************************/
};

#endif