如何在不交换数据的情况下对c++中的双向链表进行排序，只传输(条目)节点

#include <iostream>

struct Node {
    int data;
    Node* prev;
    Node* next;
};

Node* getMiddle(Node* start, Node* end) {
    Node* slow = start;
    Node* fast = start;
    while (fast != end && fast->next != end) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

Node* merge(Node* left, Node* right) {
    Node dummy;
    Node* tail = &dummy;
    while (left && right) {
        if (left->data <= right->data) {
            tail->next = left;
            left->prev = tail;
            left = left->next;
        } else {
            tail->next = right;
            right->prev = tail;
            right = right->next;
        }
        tail = tail->next;
    }
    tail->next = left ? left : right;
    tail->next->prev = tail;
    return dummy.next;
}

Node* mergeSort(Node* start, Node* end) {
    if (start == end || start->next == end) {
        return start;
    }
    Node* middle = getMiddle(start, end);
    Node* right = mergeSort(middle, end);
    Node* left = mergeSort(start, middle);
    return merge(left, right);
}

Node* sortLinkedList(Node* head) {
    return mergeSort(head, nullptr);
}

void printLinkedList(Node* head) {
    Node* current = head;
    while (current) {
        std::cout << current->data << " ";
        current = current->next;
    }
    std::cout << std::endl;
}

int main() {
    // 创建一个双向链表
    Node* head = new Node{5, nullptr, nullptr};
    Node* node1 = new Node{3, nullptr, nullptr};
    Node* node2 = new Node{8, nullptr, nullptr};
    Node* node3 = new Node{1, nullptr, nullptr};
    Node* node4 = new Node{6, nullptr, nullptr};
    head->next = node1;
    node1->prev = head;
    node1->next = node2;
    node2->prev = node1;
    node2->next = node3;
    node3->prev = node2;
    node3->next = node4;
    node4->prev = node3;

    std::cout << "Before sorting: ";
    printLinkedList(head);

    head = sortLinkedList(head);

    std::cout << "After sorting: ";
    printLinkedList(head);

    // 释放链表内存
    Node* current = head;
    while (current) {
        Node* temp = current;
        current = current->next;
        delete temp;
    }

    return 0;
}