已知 head 指向一个带头结点的单向链表,链表中每个结点包含数据 long 和指向本结

点的指针 next，现在要在链表尾部插入一个新结点，请问该如何操作？

可以按照以下步骤进行操作：

1. 创建一个新结点，用变量 new_node 指向它，同时将新结点的数据部分设置为需要插入的数据。

2. 将新结点的指针部分设置为 NULL，表示它是链表的最后一个结点。

3. 找到链表的最后一个结点，可以通过循环遍历链表来实现。具体操作是从头结点开始遍历链表，依次访问每个结点的指针 next，直到找到最后一个结点，即指针 next 为 NULL 的结点。

4. 将最后一个结点的指针 next 指向新结点，即可将新结点插入到链表的尾部。

完整代码如下：

struct ListNode {
    long data;
    ListNode* next;
};

void insert_at_tail(ListNode* head, long data) {
    // 创建新结点
    ListNode* new_node = new ListNode;
    new_node->data = data;
    new_node->next = NULL;

    // 找到最后一个结点
    ListNode* curr = head;
    while (curr->next != NULL) {
        curr = curr->next;
    }

    // 将新结点插入到链表尾部
    curr->next = new_node;
}

相关问题

已知head指向一个带头结点的单向链表，链表中每个结点包含字符串数据和指向本结构结点的指针。编写函数实现在值为“jone”的结点前插入值为输入值的结点，若没有值为“jone”的结点，则插在链表最后。

题目描述：已知head指向一个带头结点的单向链表，链表中每个结点包含字符串数据和指向本结构的指针。编写函数实现在值为“jone”的结点前插入值为输入值的结点，若没有值为“jone”的结点，则插入在链表最后。

解题思路：遍历链表，若遇到值为“jone”的结点则在其前面插入新结点，否则在链表最后插入新结点。

Python代码：

2.已知head指向一个带头结点的单向链表，链表中每个结点包含字符型数据和指向本结构结点的指针。编写函数实现在值为“jone”的结点前插入值为“marit”的结点，若没有值为“jone”的结点，则插在链表最后。

以下是实现该功能的C代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义链表结点
typedef struct Node {
    char data;
    struct Node *next;
} Node;

// 在值为“jone”的结点前插入值为“marit”的结点
void insert(Node *head, char *marit, char *jone) {
    Node *prev = head;
    Node *cur = head->next;
    while (cur != NULL) {
        if (strcmp(cur->data, jone) == 0) {
            // 在jone前插入marit
            Node *new_node = (Node *)malloc(sizeof(Node));
            new_node->data = *marit;
            new_node->next = cur;
            prev->next = new_node;
            return;
        }
        prev = cur;
        cur = cur->next;
    }
    // 没有找到jone，插入到链表末尾
    Node *new_node = (Node *)malloc(sizeof(Node));
    new_node->data = *marit;
    new_node->next = NULL;
    prev->next = new_node;
}

int main() {
    // 初始化链表
    Node *head = (Node *)malloc(sizeof(Node));
    head->next = NULL;
    char str[] = "hello world";
    for (int i = strlen(str) - 1; i >= 0; i--) {
        Node *new_node = (Node *)malloc(sizeof(Node));
        new_node->data = str[i];
        new_node->next = head->next;
        head->next = new_node;
    }

    // 插入结点
    char marit[] = "m";
    char jone[] = "j";
    insert(head, marit, jone);

    // 打印链表
    Node *cur = head->next;
    while (cur != NULL) {
        printf("%c", cur->data);
        cur = cur->next;
    }
    printf("\n");

    // 释放链表空间
    cur = head->next;
    while (cur != NULL) {
        Node *tmp = cur;
        cur = cur->next;
        free(tmp);
    }
    free(head);

    return 0;
}

这里使用了带头结点的单向链表来存储数据，使用了字符串比较函数`strcmp`来比较链表结点中的数据是否为“jone”。如果找到了“jone”，则在其前面插入一个新结点；如果没有找到，则在链表末尾插入一个新结点。最后打印输出链表中的所有元素，并释放链表空间。