Lista jednokierunkowa - przepinanie węzłów na koniec

Męczę się z funkcją biblioteki sznur mającą przepinać węzły zawierające liczby parzyste na koniec listy, odwracając przy tym ich kolejność.
np po wpisaniu listy 3->2->5->4->6 otrzymamy 3->5->6->4->2.
Algorytm, który chcę zastosować to wypięcie parzystego węzła i wstawienie go jako następny po zapamiętanym ogonie. Niestety program albo w nieskończoność wypisuje liste albo wykrzacza się kiedy napotka liczbę parzystą i nie wypisuje nic(to aktualna sytuacja). Jak powinno to wyglądać?

Funkcja w pliku biblioteki sznur.cpp:

void Sznur::przestawParzyste()
{
    Node* tail_mem = tail;
    Node* runner;
    Node* follower = nullptr;
   

    runner = head;



    while(runner != tail_mem)
    {
        if(runner->data%2 == 0)
        {
            ///wypięcie
            if(runner == head)
            {
                ///aktualizacja poczatku
                head=runner->next;
            }


            follower->next=runner->next;
            tail_mem->next=runner;

	    ///przepięcie
            runner->next=nullptr;
            tail=runner;





        }
        else
        {
            follower = runner;
            runner = runner -> next;

        }
    }
}







plik sznur.h:


#ifndef ZNAM_SZNUR9_H
#define ZNAM_SZNUR9_H

struct Sznur{
private:
    struct Node{
        int data;
        Node* next;
        Node(int d, Node* n=nullptr)
        {
            data=d;
            next=n;
        }
    };
    int howBig=0;
    Node* head=nullptr;
    Node* tail=nullptr;

public:
    Sznur()=default;
    ~Sznur();
    void write();
    void add(int a);
    // usunFragmenty(int b);
    //void usunZPar(int c);
    void przestawParzyste();

};


#endif // ZNAM_SZNUR9_H


```cpp

Stwórz drugą listę (lista 2). Przeglądaj elementy pierwszej listy. Przy spełnieniu warunku (wartość parzysta) dodaj element do listy 2 (na początek) i usuń z listy 1. Po wszystkim doklej listę 2 na końcu listy 1.

#include <iostream>
using namespace std;

class List
{
	private:
	struct Node
	{
		int data;
		Node *next;
		Node(int data):data(data),next(nullptr) {}
		ostream &out(ostream &s)const { return s<<data; }
		friend ostream &operator<<(ostream &s,const Node &node) { return node.out(s); }
		bool operator<(const Node &node)const
		{
			int odd=data%2,nodd=node.data%2,v=(nodd<odd)-(odd<nodd);
			return v!=0?v>0:(odd>0)^(data>node.data);
		}
	};
	Node *head=nullptr,*tail=nullptr;
	public:
	List()=default;
	~List() { clear(); }
	void clear()
	{
		for(Node *i=head,*next=nullptr;i;i=next,next=i->next) delete i;
		head=tail=nullptr;
	}
	ostream &out(ostream &s)const
	{
		for(const Node *i=head;i;i=i->next) s<<*i<<" -> ";
		return s;
	}
	friend ostream &operator<<(ostream &s,const List &list) { return list.out(s); }
	void insert(int data)
	{
		Node *node=new Node(data);
		for(Node **curr=&head;*curr;curr=&((*curr)->next))
		{
			if(*node<**curr)
			{
				node->next=*curr;
				*curr=node;
				return;
			}
		}
		tail=(tail?tail->next:head)=node;
	}
};

int main()
{
	List L;
	L.insert(3);	cout<<L<<endl;
	L.insert(2);	cout<<L<<endl;
	L.insert(5);	cout<<L<<endl;
	L.insert(4);	cout<<L<<endl;
	L.insert(6);	cout<<L<<endl;
	return 0;
}

Nie można pomocniczych sznurów użyć? Żaden problem, pomocniczy node wystarczy :D.

W stylu C:

void Sznur::przestawParzyste()
{
    Node even_list_head;
    Node *even_tail = &even_list_head; 
    Node **node_link = &head;

    while (*node_link != nullptr) {
        Node *node = *node_link;

        if (node->data % 2 == 0) {
            *node_link = node->next;
            even_tail->next = node;
            even_tail = even_tail->next;
            even_tail->next = nullptr;
        } else {
            node_link = &node->next;
        }
    }

    *node_link = even_list_head.next;
    tail = even_tail;
}

Można pomocniczy node zamienić na wskaźnik, jedynie ifów przybędzie. Wskaźnik na wskaźnik też można zamienić na wskaźnik na poprzedni element, ale znowu przybędzie ifów.

Generalnie najlepiej przepinać elementy do drugiej listy. Można ją reprezentować przez 2 wskaźniki - head i tail.
Odradzam przepinanie ich w locie do ogona, bo łatwo o błąd.