在template情况下删除带头节点单链表的第i个元素的代码

以下是删除带头节点单链表的第i个元素的代码：

void deleteNode(ListNode* head, int i) {
    ListNode* pre = head;
    for (int j = 0; j < i - 1; j++) {
        pre = pre->next;
    }
    ListNode* cur = pre->next;
    pre->next = cur->next;
    delete cur;
}

其中，ListNode 是单链表的节点结构体，包含一个 val 值和一个 next 指针，指向下一个节点。head 是单链表的头节点，不包含实际的数据，只是一个指向第一个节点的指针。i 是要删除的节点的位置，从 1 开始计数。

相关问题

在template情况下获得删除的代码

可以使用以下代码来在template情况下获得删除的代码：

template<typename T>
void remove(std::vector<T>& vec, const T& value) {
    vec.erase(std::remove(vec.begin(), vec.end(), value), vec.end());
}

这个函数使用了STL中的remove和erase函数来删除vector中的元素。

在template情况下获得链表长度的代码

### 回答1：
可以使用以下代码来在template情况下获得链表长度：

template<typename T>
int getLinkedListLength(Node<T>* head) {
    int length = 0;
    Node<T>* current = head;
    while (current != nullptr) {
        length++;
        current = current->next;
    }
    return length;
}

其中，Node是链表节点的结构体或类，包含一个指向下一个节点的指针next，以及一个值value。这个函数接受一个指向链表头节点的指针head，遍历整个链表，每遍历一个节点就将长度加1，最后返回链表长度。

### 回答2：
在使用模板类的情况下，获取链表长度的代码可以如下所示：

template<typename T>
class LinkedList {
public:
    // 链表节点结构
    template<typename U>
    struct Node {
        U data;       // 节点数据
        Node<U>* next; // 指向下一个节点的指针
    };

    // 构造函数
    LinkedList() : head(nullptr) {}

    // 插入节点
    void insert(const T& newData) {
        Node<T>* newNode = new Node<T>;
        newNode->data = newData;
        newNode->next = nullptr;
        
        if (head == nullptr) {  // 空链表情况
            head = newNode;
        } else {  // 非空链表情况，找到链表尾部插入新节点
            Node<T>* temp = head;
            while (temp->next != nullptr) {
                temp = temp->next;
            }
            temp->next = newNode;
        }
    }

    // 获取链表长度
    int getLength() const {
        int length = 0;
        Node<T>* temp = head;
        while (temp != nullptr) {
            length++;
            temp = temp->next;
        }
        return length;
    }

private:
    Node<T>* head; // 头节点指针
};

使用该模板类实例化一个链表对象后，可以调用`getLength()`方法来获取链表的长度。例如：

LinkedList<int> myList;
myList.insert(1);
myList.insert(2);
myList.insert(3);
int length = myList.getLength();

上述代码中，`myList`是一个整型的链表对象，通过`insert()`方法插入了三个节点，然后调用`getLength()`方法获取了链表的长度，最终将其赋值给`length`变量。

### 回答3：
在模板情况下，我们可以使用递归的方式来获得链表的长度。

首先，我们可以定义一个模板类`ListNode`表示链表节点，其中包含一个成员变量`value`表示节点的值，和一个指向下一个节点的指针`next`。

接下来，我们可以定义一个模板函数`getLinkedListLength`来计算链表的长度。该函数接受一个指向链表头节点的指针，并且返回链表的长度。

在函数内部，我们首先判断传入的指针是否为空，如果为空则说明当前节点为链表的末尾节点，此时返回0表示链表的长度为0。

如果传入的指针不为空，则说明当前节点不是链表的末尾节点，我们可以通过调用递归的方式将当前节点的下一个节点传入`getLinkedListLength`函数中，并将返回值加1表示当前节点及其后面的节点组成的链表的长度。

以下是完整的代码实现：

template<typename T>
class ListNode {
public:
    T value;
    ListNode<T>* next;

    ListNode(T val) : value(val), next(nullptr) {}
};

template<typename T>
int getLinkedListLength(ListNode<T>* head) {
    if (head == nullptr) {
        return 0;
    }

    return 1 + getLinkedListLength(head->next);
}

// 测试代码
int main() {
    ListNode<int> node1(1);
    ListNode<int> node2(2);
    ListNode<int> node3(3);

    node1.next = &node2;
    node2.next = &node3;
    
    int length = getLinkedListLength(&node1);
    std::cout << "链表的长度为：" << length << std::endl;

    return 0;
}

以上代码可以计算出链表的长度，并输出结果为3。