带头结点的单链表插入操作

带头结点的单链表插入操作通常涉及以下几个步骤：

1. **创建新节点**：首先，你需要创建一个新的节点，这个节点将存储你要插入的数据。

2. **获取头结点的引用**：如果链表不为空，你需要找到链表的第一个节点（即头结点），通常它的`next`指针是空的。

3. **设置头结点**：如果你要插入的是第一个元素，那么新节点就是新的头结点，此时它的`next`应该指向原来的头结点。

4. **插入数据节点**：对于非头部的插入，新节点的`next`属性应指向当前节点，然后将当前节点的`next`指向前一个节点的`next`，形成链接。

5. **更新头结点**：如果插入的位置不是第一个元素，需要将原头结节点的`next`指向新插入的节点。

下面是一个伪代码示例：

// 假设有一个Node类和一个Head指针
class Node:
    data = None
    next = None

def insert_at_head(data):
    new_node = Node(data)
    if Head is not None:
        new_node.next = Head
    Head = new_node

def insert_after_node(data, current_node):
    new_node = Node(data)
    new_node.next = current_node.next
    current_node.next = new_node

相关问题

设计一个算法，将一个结点值为自然数的带头结点单链表拆分为两个带头结点单链表，原表中保留值为偶数的结点，而值为奇数的结点按它们在原表中的相对次序组成一个新的带头结点单链表。

算法如下：

1. 定义两个新的带头结点单链表，分别为evenList和oddList。

2. 遍历原链表，如果结点的值为偶数，则将该结点插入evenList中；如果结点的值为奇数，则将该结点插入oddList中。

3. 遍历完原链表后，将oddList插入到evenList的末尾。

4. 返回evenList和oddList。

代码实现如下：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

pair<ListNode*, ListNode*> splitList(ListNode* head) {
    ListNode* evenList = new ListNode(0);
    ListNode* oddList = new ListNode(0);
    ListNode* evenTail = evenList;
    ListNode* oddTail = oddList;
    ListNode* cur = head->next;
    while (cur != NULL) {
        if (cur->val % 2 == 0) {
            evenTail->next = cur;
            evenTail = evenTail->next;
        } else {
            oddTail->next = cur;
            oddTail = oddTail->next;
        }
        cur = cur->next;
    }
    evenTail->next = oddList->next;
    oddTail->next = NULL;
    return make_pair(evenList, oddList);
}

编写不带头结点单链表的插入操作和删除操作算法c语言

插入操作：

void insert(Node* &head, int val) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = val;
    newNode->next = NULL;
    if (head == NULL) {
        head = newNode;
        return;
    }
    Node* cur = head;
    while (cur->next != NULL) {
        cur = cur->next;
    }
    cur->next = newNode;
}

删除操作：

void delete(Node* &head, int val) {
    if (head == NULL) {
        return;
    }
    if (head->val == val) {
        Node* temp = head;
        head = head->next;
        free(temp);
        return;
    }
    Node* cur = head;
    while (cur->next != NULL && cur->next->val != val) {
        cur = cur->next;
    }
    if (cur->next != NULL) {
        Node* temp = cur->next;
        cur->next = cur->next->next;
        free(temp);
    }
}