用c++类实现链表初始化，头插、尾插、中间插、删除结点、删除链表、初始化链表获取链表长度，拷贝构造函数，析构函数

好的，下面是一个完整的 C++ 类实现链表的示例代码，包括链表的初始化、头插、尾插、中间插、删除结点、删除链表、获取链表长度、拷贝构造函数和析构函数：

#include <iostream>

using namespace std;

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

    Node(int val) {
        data = val;
        next = NULL;
    }
};

class LinkedList {
public:
    Node* head;

    LinkedList() {
        head = NULL;
    }

    LinkedList(int arr[], int n) {
        head = NULL;
        for (int i = 0; i < n; i++) {
            insertTail(arr[i]);
        }
    }

    void insertHead(int val) {
        Node* newNode = new Node(val);
        newNode->next = head;
        head = newNode;
    }

    void insertTail(int val) {
        Node* newNode = new Node(val);
        if (head == NULL) {
            head = newNode;
            return;
        }
        Node* temp = head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }

    void insert(int pos, int val) {
        if (pos < 0) {
            cout << "Invalid position." << endl;
            return;
        }
        if (pos == 0) {
            insertHead(val);
            return;
        }
        Node* newNode = new Node(val);
        Node* temp = head;
        for (int i = 0; i < pos - 1; i++) {
            if (temp == NULL) {
                cout << "Invalid position." << endl;
                return;
            }
            temp = temp->next;
        }
        newNode->next = temp->next;
        temp->next = newNode;
    }

    void deleteNode(int val) {
        if (head == NULL) {
            cout << "List is empty." << endl;
            return;
        }
        Node* temp = head;
        if (head->data == val) {
            head = head->next;
            delete temp;
            return;
        }
        while (temp->next != NULL) {
            if (temp->next->data == val) {
                Node* deleteNode = temp->next;
                temp->next = deleteNode->next;
                delete deleteNode;
                return;
            }
            temp = temp->next;
        }
        cout << "Node not found." << endl;
    }

    void deleteList() {
        Node* temp = head;
        while (head != NULL) {
            head = head->next;
            delete temp;
            temp = head;
        }
    }

    int getLength() {
        int length = 0;
        Node* temp = head;
        while (temp != NULL) {
            length++;
            temp = temp->next;
        }
        return length;
    }

    LinkedList(const LinkedList& list) {
        head = NULL;
        Node* temp = list.head;
        while (temp != NULL) {
            insertTail(temp->data);
            temp = temp->next;
        }
    }

    ~LinkedList() {
        deleteList();
    }

    void display() {
        if (head == NULL) {
            cout << "List is empty." << endl;
            return;
        }
        Node* temp = head;
        while (temp != NULL) {
            cout << temp->data << " ";
            temp = temp->next;
        }
        cout << endl;
    }
};

int main() {
    int arr[] = {10, 20, 30};
    int n = sizeof(arr) / sizeof(arr[0]);

    LinkedList list1(arr, n);
    list1.display();
    cout << "Length: " << list1.getLength() << endl;

    LinkedList list2(list1);
    list2.display();
    cout << "Length: " << list2.getLength() << endl;

    list2.insertHead(5);
    list2.display();
    cout << "Length: " << list2.getLength() << endl;

    list2.insertTail(40);
    list2.display();
    cout << "Length: " << list2.getLength() << endl;

    list2.insert(2, 15);
    list2.display();
    cout << "Length: " << list2.getLength() << endl;

    list2.deleteNode(15);
    list2.display();
    cout << "Length: " << list2.getLength() << endl;

    list2.deleteList();
    list2.display();
    cout << "Length: " << list2.getLength() << endl;

    return 0;
}

这个链表类实现了以下功能：

- 初始化链表：通过构造函数传入数组和数组长度，初始化链表。
- 头插：在链表的头部插入一个新节点。
- 尾插：在链表的尾部插入一个新节点。
- 中间插：在链表的指定位置插入一个新节点。
- 删除结点：删除链表中的指定节点。
- 删除链表：删除整个链表。
- 初始化链表获取链表长度：获取链表的长度。
- 拷贝构造函数：实现链表的拷贝构造。
- 析构函数：实现链表的析构。

在 `LinkedList` 类的构造函数中，可以传入一个数组和数组长度，用于初始化链表。在 `insertHead()` 函数中，创建一个新节点，将其指针指向头节点，然后将头节点指向新节点。在 `insertTail()` 函数中，先创建一个新节点，然后找到链表中的最后一个节点，将其指针指向新节点。在 `insert()` 函数中，先判断插入位置是否合法，如果位置为 0，则调用 `insertHead()` 函数；否则，找到插入位置的前一个节点，将其指针指向新节点，新节点指针指向插入位置的后一个节点。在 `deleteNode()` 函数中，先判断链表是否为空，如果头节点的值等于要删除的值，则删除头节点；否则，找到要删除节点的前一个节点，将其指针指向要删除节点的后一个节点。在 `deleteList()` 函数中，遍历整个链表，依次删除每个节点。在 `getLength()` 函数中，遍历链表，统计节点的个数。在拷贝构造函数中，先将新链表的头节点指向空，然后遍历原链表，依次插入每个节点。在析构函数中，调用 `deleteList()` 函数，删除整个链表。最后在 `main()` 函数中，创建两个链表，分别测试所有功能。