ошибка сегментации связанного списка исправлена с помощью cerr

У меня есть следующий код. что делает этот код, так это то, что он объединяет два отсортированных связанных списка, а затем удаляет как связанные списки, так и возвращает новый список:

#include <iostream>

using namespace std;

class node {
    public:
        node(int, node*);
        node* get_next() const;
        void set_next(node*);
        int get_item() const;
        void set_item(int);
    private:
        int item;
        node* next;
};

node* clone_and_destroy(node* a)
{
    node* new_list;
    node* prev;
    node* ret_val;
    while ( a )
    {
        new_list = new node(a->get_item(),NULL);
        if ( prev ){
            prev->set_next(new_list);
            prev = prev->get_next();
        }
        else{
        prev = new_list;
        ret_val = prev;
        }
        node* temp = a;
        a = a->get_next();
        delete temp;
    }
    return ret_val;
}

node* merge(node*& a, node*& b){
    if ( !a ){// cerr<<"\r";
        return clone_and_destroy(b);}
    if ( !b )
        return clone_and_destroy(a);

    node* smaller_node, *bigger_node;
    if ( a->get_item() < b->get_item() ){
        smaller_node = a;
        bigger_node = b;
    }
    else {
        smaller_node = b;
        bigger_node = a;
    }
    node* next_node = smaller_node->get_next(); 
    node* merged_list = new node(smaller_node->get_item(),smaller_node->get_next());
    delete smaller_node;
    merged_list->set_next(merge(next_node,bigger_node));
    a = NULL ;
    b = NULL ;
    return merged_list;
}

/*node* merge(node*& a, node*& b){
    if ( !a )
        return b;
    if ( !b )
        return a;
    if ( a->get_item() < b->get_item() ){
        node* a_next = a->get_next();
        node* merged_list = a;
        merged_list->set_next(merge(a_next,b));
        delete a;
        return merged_list;
    }
    else {
        node* b_next = b->get_next();
        node* merged_list = b;
        merged_list->set_next(merge(a,b_next));
        delete b;
        return merged_list;
    }
}*/     

void print(node* a)
{   
    while ( a )
    {
        cout << a->get_item() << " ";
        a = a->get_next();
    }
    cout << endl;
}

node::node(int _item, node* _next)
{
    item = _item;
    next = _next;
}
node* node::get_next() const
{
    return next;
}
void node::set_next(node* new_next)
{
    next = new_next;
}
int node::get_item() const { return item; }
void node::set_item(int _item)
{ 
    item = _item;
}

int main() {
    node* l1 = NULL, *l2 = NULL;
    cout << "Before Merging: " << endl;
    for (int i = 5; i > 0; i--) {
        l1 = new node(i, l1);
        l2 = new node(2*i-3, l2);
    }
    cout << "List 1 is: \t\t";
    print(l1);
    cout << endl;
    cout << "List 2 is: \t\t";
    print(l2);
    cout << endl << "After Merging:" << endl;
    node* m = merge(l1, l2);
    cout << "List 1 is: \t\t";
    print(l1);
    cout << "Should be: \t\t[ ]" << endl;
    cout << endl;
    cout << "List 2 is: \t\t";
    print(l2);
    cout << "Should be: \t\t[ ]" << endl;
    cout << endl;
    cout << "Merged List is: \t";
    print(m);
    cout << "Should be: \t\t[ -1 1 1 2 3 3 4 5 5 7 ]" << endl;


    for (node* h = m; h != NULL; h = m) {
        m = m->get_next();
        delete h;
    }
    return 0;
}

важной частью кода является функция слияния, остальные - просто инструменты для реализации этой функции. теперь смешная вещь случается! этот код получает ошибку сегментации, когда я запускаю его, но когда я пытался отлаживать свой код, я использовал cerr в первой строке функции слияния (он прокомментировал), и вдруг это сработало нормально !!! может кто-нибудь, пожалуйста, объясните мне это !? что это cerr делает?! и как я могу исправить свой код без этого cerr и с минимальными изменениями в коде!? теперь я знаю, что cerr останавливает укусы от буферизации, но я не думаю, что здесь дело!