在构建的单链表基础上，实现单链表的插入、删除操作（插入、删除位置自定，插入元素值自定）。 在定义的单链表类中添加析构函数并实现。 实现两个循环单链表的合并。c++

在C++中，我们可以定义一个简单的单链表结构，包含节点和指针，并实现插入和删除操作。首先，我们创建一个`Node`类用于表示链表的节点：

class Node {
public:
    int data;
    Node* next;

    // 构造函数
    Node(int value) : data(value), next(nullptr) {}
};

接下来，我们需要一个链表类`LinkedList`，包括插入、删除、析构函数以及合并两个循环链表的功能：

class LinkedList {
private:
    Node* head;
    bool isCircular;

public:
    LinkedList() : head(nullptr), isCircular(false) {}

    ~LinkedList() { // 析构函数，释放内存
        clearList();
    }

    // 插入节点
    void insertNode(int value, Node** position = nullptr) {
        if (!head) {
            head = new Node(value);
            return;
        }
        
        if (!position) {
            Node* newNode = new Node(value);
            newNode->next = head;
            head = newNode;
            if (isCircular)
                newNode->next = newNode; // 设置循环链接
        } else {
            Node* current = *position;
            Node* newNode = new Node(value);
            newNode->next = current->next;
            *position->next = newNode;
            if (isCircular)
                newNode->next = current;
        }
    }

    // 删除节点（位置自定）
    void deleteNode(Node* position) {
        if (!position || !position->next) return;
        
        Node* temp = position->next;
        if (temp == head && isCircular) {
            head = head->next;
            head->next = head;
        } else {
            position->next = temp->next;
            if (isCircular)
                position->next->next = position;
        }
        delete temp;
    }

    // 合并循环链表
    static LinkedList* mergeCircularLinkedLists(LinkedList* list1, LinkedList* list2) {
        if (!list1 || !list2 || !list1->head || !list2->head) return list1 ? list1 : list2;

        Node* tail1 = list1->getTail(isCircular);
        Node* tail2 = list2->getTail(isCircular);

        if (!tail1) tail1 = list1->head;
        if (!tail2) tail2 = list2->head;

        tail1->next = tail2->next;
        if (isCircular) {
            tail1->next->next = tail1;
            list1->isCircular = true;
        }

        return list1;
    }

private:
    // 获取循环链表的尾部
    Node* getTail(bool circular) {
        Node* current = head;
        while (true) {
            if (current == head && circular) break;
            current = circular ? current->next : current->next->next;
        }
        return current;
    }

    // 清理链表，释放所有节点
    void clearList() {
        Node* temp = head;
        while (temp) {
            Node* nextTemp = temp->next;
            delete temp;
            temp = nextTemp;
        }
        head = nullptr;
    }
};

// 示例用法
int main() {
    LinkedList list1, list2;
    list1.insertNode(1); // 插入节点到list1
    list2.insertNode(2); // ...

    // ... 更多操作 ...

    LinkedList* mergedList = LinkedList::mergeCircularLinkedLists(&list1, &list2);
    // ... 操作合并后的链表 ...

    return 0;
}