Нахождение середины списка

     Node* GetMiddle(MyList c)
     {
         MyList a = c;
         MyList b = c;
         MyList Tail = NULL;
 
         while(b->Next != Tail && b->Next->Next != Tail)
         {
             a = a->Next;
             b = b->Next->Next;
         }
         return a;
     }

template <class T>
struct Node                             //Структура, являющаяся звеном списка
 {
 public:
    T data;                             //Значение x будет передаваться в список
    Node *Next, *Prev;                 //Указатели на адреса следующего и предыдущего элементов списка
     
};
 
template <class T>
 class MyList                              //Создаем тип данных Список
 {
public:
    Node<T> *Head;                 //Указатели на адреса начала списка и его конца
    Node<T> *Tail;  
    int size;  // размер списка, понадобится в ф-ии для удаления
 
    MyList():Head(NULL),Tail(NULL), size(0) {};    //Инициализируем адреса как пустые
    
    ~MyList()                           //Прототип деструктора
    {
        while (Head)                       //Пока по адресу на начало списка что-то есть
        {
            Tail = Head->Next;             //Резервная копия адреса следующего звена списка
            delete Head;                   //Очистка памяти от первого звена
            Head = Tail;                   //Смена адреса начала на адрес следующего элемента
        }
    }
    
    void Show()                       //Прототип функции отображения списка на экране
    {
        Node<T> *temp = Head;
 
        if(temp == NULL)
        {
            cout << "Список пуст!" << endl;
        }
        else
        {
            while(temp)
            {
                cout << temp->x;
                temp = temp->Next;
            }
        }
    }
    
    void Add(T data)                   //Прототип функции добавления элементов в список
    {
        Node<T> *temp = new Node<T>;               //Выделение памяти под новый элемент структуры
        temp->Next = NULL;                   //Указываем, что изначально по следующему адресу пусто
        temp->data = data; // ЗДЕСЬ ПРОИСХОДИТ МАГИЯ
 
        if (Head != NULL)                    //Если список не пуст
        {
            temp->Prev = Tail;               //Указываем адрес на предыдущий элемент в соотв. поле
            Tail->Next = temp;               //Указываем адрес следующего за хвостом элемента
            Tail = temp;                     //Меняем адрес хвоста
        }
        else //Если список пустой
        {
            temp->Prev = NULL;               //Предыдущий элемент указывает в пустоту
            Head = Tail = temp;              //Голова=Хвост=тот элемент, что сейчас добавили
        }
        size++;
    }
    
    int GetSize()  // получаем размер списка
    {
        Node *temp = Head;
        int i(0);
 
        while(temp)
        {
            i++;
            temp = temp->Next;
        }
 
        return i;
    }
    
    void Remove(int index)  // удаление по индексу
    {
            Node<T> *temp = Head;
 
    if ((index > size) || (index < 0))    //если указанный элемент не существует, то
        cout << "Задайте другой индекс!!!" << endl;  //выводим предупреждение на экран
    else
    {
        for(int i = 0; i != index; i++)  //иначе, переходим до этого элемента
        {
            temp = temp->Next;
        }
 
        if (temp->Prev == NULL)        //если удаляем первый элемент
        {
            if (size == 1)         //если этот элемент единственный
            {
                Head = NULL;
                Tail = NULL;
            }
            else                //если он первый, но не единственный
            {
                temp->Next->Prev = NULL;
                Head = temp->Next;
            }
 
            delete temp;
            size--;
            return;
        }
 
        if (temp->Next == NULL)        //если удаляем последний элемент, то
        {
            temp->Prev->Next = NULL;   //предыдущий элемент указывает на NULL
            Tail = temp->Prev;        //указатель на последний элемент указывает на предпоследний
 
            delete temp;
            return;
        }       
 
//если элемент находится в центре списка
        if (temp->Next != NULL && temp->Prev != NULL) 
        {
            temp->Prev->Next = temp->Next; //предыдущий элемент указывает на следующий
            temp->Next->Prev = temp->Prev; //следующий указывает на предыдущий
            delete temp;
            return;
        }
    }
    }
    
    void Insert(class x, int index); // помещаем новый элемент по заданному индексу
 
    void Clear() // ф-я для очищения списка, хотя детруктор и так долен очищать список после работы
    {
        while(Head)
        {
            Tail = Head->Next;
            delete Head;
            Head = Tail;
        }
    }
        
     Node* GetMiddle(MyList c)
     {
         MyList a = c;
         MyList b = c;
         MyList Tail = NULL;
 
         while(b->Next != Tail && b->Next->Next != Tail)
         {
             a = a->Next;
             b = b->Next->Next;
         }
         return a;
     }
    
};

MyList<int>

student Merge(student a, student b)
{
    student head = NULL;
    student tail = NULL;
 
    while (true)
    {
 
        if (a == NULL)
        {
            if (tail == NULL)
            {
                head = b;
                head->Prev = NULL;
 
                return head;
            }
            else
            {
                tail->Next = b;
                b->Prev = tail;
 
                return head;
            }
        }
        if (b == NULL)
        {
            if (tail == NULL)
            {
                head = a;
                a->Prev = NULL;
 
                return head;
            }
            else
            {
                tail->Next = a;
                a->Prev = tail;
 
                return head;
            }
        }
 
        if (a->growth > b->growth)
        {
            if (tail == NULL)
            {
                head = a;
                tail = a;
                head->Prev = NULL;
            }
            else
            {
                tail->Next = a;
                a->Prev = tail;
                tail = a;
            }
            a = a->Next;
            tail->Next = NULL;
        }
        else
        {
            if (tail == NULL)
            {
                head = b;
                tail = b;
                head->Prev = NULL;
            }
            else
            {
                tail->Next = b;
                b->Prev = tail;
                tail = b;
            }
 
            b = b->Next;
            tail->Next = NULL;
        }
    }
}
 
student GetMiddle(student c, student tail = NULL)  //поиск середины
{
    student a = c;
    student b = c;
    if (tail != NULL) tail = tail->Next;
    while (b->Next != tail && b->Next->Next != tail)
    {
        a = a->Next;
        b = b->Next->Next;
    }
    return a;
}
 
student MergeSort(student c)
{
    if (c->Next == NULL)
    {
        return c;
    }
 
    student middle = GetMiddle(c);
    student r = middle->Next;  //Начало второй части списка (после разделения)
 
    r->Prev = NULL;
    middle->Next = NULL;
 
    c = MergeSort(c);
    r = MergeSort(r);
 
    return Merge(c, r);
}

template <typename T> MyList<T> GetMiddle(MyList<T>& list)
     {
         MyList<T> result=list;
         int size=list.size;
         for (int i=0; i<size/2; ++i){
             result.Remove(i);
             list.Remove(size-1-i);
         }
         if (size%2) list.Remove(size/2+1);
         return result;
     }

MyList(MyList& list):MyList(){for (int i=list.size-1; i>=0; --i) add(list.get(i))}

if (size%2) list.Remove(size/2);

MyList<T> half_list=GetMiddle(some_list);