Сортировка слиянием кольцевого списка

#include <iostream>
using namespace std; 
 
template <class T>
class Double_list
{
public:
    struct Double_node
    {
        Double_node *next;
        Double_node *prev;
        int val;
        Double_node() {}
        Double_node(T x)
        {
            val = x;
        }
        Double_node(T a, Double_node* b, Double_node* c)
        {
            val = a;
            next = b;
            prev = c;
        }
    };
    class iterator
    {
        public:
        Double_node* node;
    public:
        iterator(Double_node* tmp)
        {
            node = tmp;
        }
        T& operator*() const
        {
            return node->val;
        }
        iterator operator++(int)
        {
            iterator it(node);
            node = node->next;
            return it;
        }
        iterator operator--(int)
        {
            iterator it(node);
            node = node->prev;
            return it;
        }
        iterator operator++()
        {
            node = node->next;
            return *this;
        }
        iterator operator--()
        {
            node = node->prev;
            return *this;
        }
        bool operator==(iterator it)
        {
            return it.node == this->node;
        }
        bool operator!=(iterator it)
        {
            return it.node != this->node;
        }
        iterator operator+(int n)
        {
            iterator p = node;
            for (int i = 0; i < n; i++)
            {
                p++;
            }
            return p;
        }
        iterator operator-(int n)
        {
            iterator p = node;
            for (int i = 0; i < n; i++)
            {
                p--;
            }
            return p;
        }
        int operator-(iterator  q)
        {
            int counter = 0;
            iterator p = node;
            for (q; q != p; q++)
            {
                counter++;
            }
            return counter;
        }
    };
    void merge_sort_rec(iterator first, iterator last)
    {
        int we_need = last - first;
        if (we_need> 1)
        {
            iterator mid = first + sz / 2;
            merge_sort_rec(first, mid);
            merge_sort_rec(mid, last);
            merge(first, mid, last);
        }
    }
    void merge(iterator first, iterator middle, iterator last)
    {
        iterator f1 = first;
        iterator f2 = middle;
        Double_node* tmp;
        while (f2 != last && f1 != middle)//посл из первой половины указ на мид
        {
            if (*f1 < *f2)
            {
                tmp = f1.node->next;
                f2.node->prev->next = f1.node;
                f1.node->prev = f2.node->prev;
                f1.node->next = f2.node;
                f2.node->prev = f1.node;
                f1.node = tmp;
            }
            else
            {
                tmp = f2.node->next;
                f1.node->prev->next = f2.node;
                f2.node->prev = f1.node->prev;
                f2.node->next = f1.node;
                f1.node->prev = f2.node;
                f2.node = tmp;
            }
        }
    }
    private:
        Double_node *tail;
        int sz;
    public:
        //tail->next=первый
        //tail->prev=последний
        //tail-узел ограничитель.в поле val-лежит мусор
        iterator rbegin()
        {
            return iterator(tail->next);
        }
        iterator rend()
        {
            return iterator(tail);
        }
        Double_list();
        ~Double_list();
        bool is_empty();
        void add_front(T);
        void add_rear(T);
        void insert_after(int, T);
        T remove(int);
        T remove_front();
        T remove_rear();
        bool find(T);
        T get_nth(int);
        int size();
        void sort()
        {
            iterator p = rbegin();
            iterator q = rend();
            merge_sort_rec(p, q);
        }
        void insert(iterator it, T x)
        {
            Double_node* mem_next = it.node->next;
            Double_node* added = new Double_node(x);
            it.node->next = added;
            added->prev = it.node;
            added->next = mem_next;
            mem_next->prev = added;
            sz++;
        }
        void remove_iter(iterator it)
        {
            Double_node* mem = it.node;
            Double_node* mem_next = it.node->next;
            Double_node* mem_prev = it.node->prev;
            mem_prev->next = mem_next;
            mem_next->prev = mem_prev;
            delete it.node;
            sz--;
        }
        void print()
        {
            Double_node* i = tail->next;
            while (i != tail)
            {
                cout << i->val << ' ';
                i = i->next;
            }
            cout << endl;
        }
    };
 
 
template <class T> Double_list<T>::Double_list()
{
    tail = new Double_node;
    tail->prev = tail;
    tail->next = tail;
    sz = 0;
}
 
template<class T>  Double_list<T>::~Double_list()
{
     while (!tail) 
     {
     Double_node* tmp=tail->next;
     delete tail;
     tail = tmp;
     } 
     delete tail;
     sz = 0; 
}
 
template<class T>  int Double_list<T>::size()
{
    return sz;
}
 
template<class T>  bool Double_list<T>::is_empty()
{
    return sz == 0;
}
 
template<class T>  void Double_list<T>::add_front(T x)
{
    if (sz == 0)
    {
        Double_node* add = new Double_node(x);
        add->prev = tail;
        tail->next = add;
        add->next = tail;
        tail->prev = add;
    }
    else
    {
        Double_node* add = new Double_node(x);
        Double_node* add_next = tail->next;
        tail->next = add;
        add->prev = tail;
        add_next->prev = add;
        add->next = add_next;
    }
    sz++;
}
 
template<class T>  void Double_list<T>::add_rear(T x)
{
    if (sz == 0)
    {
        add_front(x);
    }
    else
    {
        Double_node* tail_prev = tail->prev;
        Double_node* add = new Double_node(x);
        tail->prev = add;
        add->next = tail;
        tail_prev->next = add;
        add->prev = tail_prev;
        sz++;
    }
    
}
template<class T>  void Double_list<T>::insert_after(int n, T x)
{
    
    if (sz > n)
    {
        Double_node* mem = tail;
        for (int i = 0; i < n; i++)
        {
            mem = mem->next;
        }
        Double_node* mem_next = mem->next;
        Double_node* add = new Double_node(x);
        add->next = mem_next;
        mem_next->prev = add;
        mem->next = add;
        add->prev = mem;
        sz++;
    }
}
 
template<class T>  T Double_list<T>::remove(int n)
{
    Double_node* mem = tail;
    for (int i = 0; i < n; i++)
    {
        mem = mem->next;
    }
    T memory = mem->val;
    mem->next->prev = mem->prev;
    mem->prev->next = mem->next;
    delete mem;
    sz--;
    return memory;
}
 
template<class T>  T Double_list<T>::remove_front()
{
    
    T memory = tail->next->val;
    Double_node* removeable = tail->next;
    tail->next->next -> prev = tail;
    tail->next =removeable->next;
    delete removeable;
    sz--;
    return memory;
}
 
template<class T>  T Double_list<T>::remove_rear()
{
    
    T memory = tail->prev->val;
    Double_node* removeable = tail->prev;
    tail->prev = tail->prev->prev;
    tail->prev->prev->next = tail;
    delete removeable;
    sz--;
    return memory;
}
 
template<class T>  bool Double_list<T>::find(T x)
{
    Double_node* mem = tail=>next;
    while (mem != tail)
    {
        if (mem->val == x)
        {
            return true;
        }
        mem = mem->next;
    }
    return false;
}
 
template<class T>  T Double_list<T>::get_nth(int n)
{
    Double_node* mem = tail->next;
    for (int i = 0; i < n; i++, mem = mem->next);
    return mem->val;
}

    Double_list<int> l;
    l.add_front(1);
    l.add_front(2);
    l.print();
    l.merge_sort_rec(l.rbegin(), l.rend());
    l.print();

Double_list<int> l;
    l.add_front(1);
    l.add_front(2);
    l.add_front(3);
    l.print();
    l.merge_sort_rec(l.rbegin(), l.rend());
    l.print();

iterator _Mid = _STD next(_First, _Size / 2);