Выбрасывает исключение при сортировке

    Node<T>* GetNode(int index) const
    {
        if(index > size || index < 0)
        {
            throw("\nВыход за границы массива");
        }
        else
        {
            Node<T> *temp = Head;
 
            int i = 0;
 
            while(temp && i < index)
            {
                temp = temp->Next;
                i++;
            }
            
            return temp;
        }
    }
    const T& GetData(int index) const
    {
        if(GetNode(index))
        {
            return GetNode(index)->data;
        }
        else
        {
            throw("\nВыход за границы массва!");
        }
    }
    T& GetData(int index)
    {
        const auto& me = *this;
        const T& data = me.GetData(index);
        return const_cast<T&>(data);
    }

template<typename T> void DivList(Mylist<T>& list, Mylist<T>& left, Mylist<T>& right)
    {
        left=list;
        right=list;
        for (int i=0; i<list.size/2; ++i)
        {
            right.pop(0);
            left.pop(left.size-1);
        }
        if (list.size%2)
        {
            right.pop(0);
        }
    }
 
template<typename T> void MergeSort(Mylist<T>& list)
    {
        if (list.size>1)
        {
            Mylist<T> left;
            Mylist<T> right;
            DivList(list,left,right);
 
            MergeSort(left);
            MergeSort(right);
            Mylist<T> temp;
            while (0 < left.size || 0 < right.size)
            {
                if(left.GetData(0).get_departureTime() > right.GetData(0).get_departureTime())
                {
                    temp.push_back(left.GetData(0));
                    left.pop(0);
                }
                else
                {
                    temp.push_back(right.GetData(0));
                    right.pop(0);
                }
                if (left.size == 0)
                {
                    while (right.size)
                    {
                        temp.push_back(right.GetData(0));
                        right.pop(0);
                    }
                    break;
                }
                if (right.size == 0)
                {
                    while (left.size)
                    {
                        temp.push_back(left.GetData(0));
                        left.pop(0);
                    }
                    break;
                }
            }
 
            list = temp;
        }
    }

    void pop(int index)
    {
        Node<T> *temp = Head;
 
        if(index > size || index < 0)
        {
            throw("\nВыход за границы массива!");
        }
        else
        {
            for(int i = 0; i != index; i++)
            {
                temp = temp->Next;
            }
 
            if(temp->Prev == nullptr)
            {
                if(size == 1)
                {
                    Head = nullptr;
                    Tail = nullptr;
                }
                else
                {
                    temp->Next->Prev = nullptr;
                    Head = temp->Next;
                }
 
                delete temp;
                size--;
                return;
            }
            if(temp->Next == nullptr)
            {
                temp->Prev->Next = nullptr;
                Tail = temp->Prev;
 
                delete temp;
                size--;
                return;
            }
            if(temp->Next != nullptr && temp->Prev != nullptr)
            {
                temp->Prev->Next = temp->Next;
                temp->Next->Prev = temp->Prev;
                delete temp;
                size--;
                return;
            }
        }
    }

if (!temp)
    throw("\n!!!!!!!Выход за границы массива!");
 
if (temp == Head)
   Head = temp->Next;
if (temp == Tail)
   Tail = temp->Prev;
 
if (temp->Prev)
   temp->Prev->Next = temp->Next;
if (temp->Next)
   temp->Next->Prev  = temp->Prev;
 
delete temp;
--size;

   auto *node =  right.GetData(0);
  right.pop(0);
    temp.push_back(node);

Node<T>* GetNode(int i) const {
    if (i<0 || i>size - 1) return 0;
    Node<T>* temp = Head;
    for (int j = 0; j < i; ++j) temp = temp->Next;
    return temp;
}
 
T& GetData(int i) {
    Node<T>* temp = GetNode(i);
    if (temp) return GetNode(i)->data;
    else throw("\n!!!!!!!Выход за границы массива!");
}
 
void pop(int index) {
    Node<T> *temp = GetNode(index);
    if (!temp) return;
    if (temp->Next) temp->Next->Prev = temp->Prev;
    else Tail = temp->Prev;
    if (temp->Prev) temp->Prev->Next = temp->Next;
    else Head = temp->Next;
    delete temp;
    --size;
}