尾插法建立带头结点单链表的定义

尾插法是在创建单链表时常用的一种方法，尤其适用于动态添加元素的情况。它的工作原理是每次新节点不再作为列表的第一个元素（头结点），而是直接插入到现有链表的最后一个节点之后，形成新的尾部链接。

在定义上，假设我们有一个名为`Node`的链表节点结构，每个节点包含一个数据域`data`和一个指向下一个节点的指针`next`。对于带头结点的链表，其定义可能如下：

class ListNode:
    def __init__(self, data=0):
        self.data = data
        self.next = None

def tail_insert(head, new_data):
    if not head:
        return ListNode(new_data)  # 如果链表为空，直接新建节点作为头
    current = head
    while current.next:
        current = current.next  # 遍历到最后一个节点
    current.next = ListNode(new_data)  # 新节点作为当前节点的后继
    return head  # 返回原链表头部

# 使用示例：
head = ListNode(1)
head = tail_insert(head, 2)  # 新增节点2并保持原有链表顺序

相关问题

在C语言中用尾插法建立带头结点的单链表函数

以下是用尾插法建立带头结点的单链表的函数示例：

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

typedef struct Node {
    int data;
    struct Node *next;
} Node, *LinkedList;

LinkedList createLinkedList() {
    LinkedList head = (LinkedList) malloc(sizeof(Node));
    head->next = NULL;
    return head;
}

void insert(LinkedList head, int data) {
    Node *newNode = (Node*) malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;

    Node *p = head;
    while (p->next != NULL) {
        p = p->next;
    }
    p->next = newNode;
}

void printLinkedList(LinkedList head) {
    Node *p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {
    LinkedList list = createLinkedList();

    insert(list, 1);
    insert(list, 2);
    insert(list, 3);

    printLinkedList(list);

    return 0;
}

在上面的示例代码中，我们定义了一个 `Node` 结构体表示链表中的节点，还定义了一个 `LinkedList` 类型表示链表。`createLinkedList()` 函数用于创建一个带头结点的链表，`insert()` 函数用于插入一个新的元素到链表的末尾，`printLinkedList()` 函数用于打印链表中的所有元素。

在 `main()` 函数中，我们首先创建了一个空的链表 `list`，然后依次插入了三个元素 1、2 和 3 到链表中，最后打印了链表中的所有元素。运行程序后，输出应该为：

1 2 3

用C语言设计尾插法建立带头结点的单链表的函数

以下是用C语言设计尾插法建立带头结点的单链表的函数的示例代码：

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

// 定义链表结点结构体
typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

// 建立带头结点的单链表的函数
ListNode* createList(void) {
    ListNode* head = (ListNode*)malloc(sizeof(ListNode)); // 创建头结点
    head->next = NULL;

    ListNode* tail = head; // 定义尾指针

    int val;
    while (scanf("%d", &val) != EOF) {
        ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); // 创建新结点
        newNode->val = val;
        newNode->next = NULL;

        tail->next = newNode; // 将新结点插入到尾部
        tail = newNode; // 更新尾指针
    }

    return head; // 返回头结点
}

// 测试函数
int main() {
    ListNode* head = createList();

    ListNode* cur = head->next;
    while (cur != NULL) {
        printf("%d ", cur->val);
        cur = cur->next;
    }

    return 0;
}

在这个示例代码中，我们首先定义了一个链表结点结构体 `ListNode`，用于表示单链表的一个结点。然后我们定义了一个 `createList` 函数，用于建立带头结点的单链表。在这个函数中，我们首先创建了头结点，然后定义了一个尾指针 `tail`，用于指向链表的尾部。接着我们循环读入链表结点的值，每次创建一个新结点，并将其插入到链表的尾部，然后更新尾指针。最后，我们返回头结点。

在 `main` 函数中，我们调用 `createList` 函数建立链表，并遍历链表中的每个结点，输出它们的值。