请写出一段链表插入结点的c语言代码

struct Node {
int data;
struct Node* next;
};

void insertNode(struct Node** head_ref, int new_data) {
struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}

相关问题

用c语言写一段代码1. 实现单循环链表的初始化、求数据元素个数、插入、删除、取数据元素等操作； 2. 用插入法建立带头结点的单循环链表； 3. 设计一个测试主函数验证所设计单循环链表的正确性。 4. 用单循环链表解决一个实际问题。

在C语言中，我们可以创建一个简单的单循环链表结构体来实现上述功能。这里是一个基础的实现：

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

// 定义链表节点
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 初始化链表
Node* initList() {
    Node* head = (Node*)malloc(sizeof(Node));
    if (!head) {
        printf("Memory allocation failed.\n");
        return NULL;
    }
    head->next = head; // 设置环形结构
    head->data = -1;   // 通常头节点设特殊值表示空链表
    return head;
}

// 求链表元素个数
int countNodes(Node* head) {
    int count = 0;
    Node* temp = head;
    while (temp != head->next) {
        count++;
        temp = temp->next;
    }
    return count;
}

// 插入节点
void insertNode(Node** head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        printf("Memory allocation failed.\n");
        return;
    }
    newNode->data = value;
    newNode->next = (*head)->next;
    (*head)->next = newNode;
}

// 删除节点（仅支持删除最后一个节点）
void deleteLastNode(Node** head) {
    if (*head == NULL || (*head)->next == *head) {
        printf("Cannot delete from empty or circular list.\n");
        return;
    }
    Node* last = *head;
    while (last->next != *head) {
        last = last->next;
    }
    free(last);
    *head = last->next;
}

// 取数据元素
int getData(Node* head) {
    if (head == head->next) {
        printf("List is empty or contains only one element.\n");
        return -1; // 或者抛出异常
    }
    return head->data;
}

// 主测试函数
int main() {
    Node* list = initList();
    
    // 测试插入
    insertNode(&list, 5);
    insertNode(&list, 10);

    // 打印并验证长度
    printf("Number of elements: %d\n", countNodes(list));

    // 删除最后一个元素
    deleteLastNode(&list);

    // 再次打印确认删除效果
    printf("After deletion: ");
    for (Node* temp = list; temp != list->next; temp = temp->next)
        printf("%d ", temp->data);
    printf("\n");

    // 获取并检查数据
    int value = getData(list);
    if (value != -1)
        printf("First element: %d\n", value);
    else
        printf("Error: Unable to get first element.\n");

    free(list); // 释放内存
    return 0;
}

这个代码实现了单循环链表的基本操作，包括初始化、插入、删除和获取数据元素。注意，这里的删除操作只针对循环链表的尾部，其他情况需要额外处理。

用c语言写一段完整的代码 实现单循环链表的初始化、求数据元素个数、插入、删除、取数据元素等操作； 用插入法建立带头结点的单循环链表；要求把单链表以头文件形式保存且采用模块化程序设计方法实现单循环链表。

以下是使用 C 语言实现单循环链表的一些基本操作的代码示例。我们将创建一个名为`single_linked_list.h`的头文件，以及一个名为`single_linked_list.c`的实现文件。

**single_linked_list.h**

#ifndef SINGLE_LINKED_LIST_H
#define SINGLE_LINKED_LIST_H

// 定义链表节点结构体
typedef struct Node {
    int data; // 节点的数据
    struct Node* next; // 指向下一个节点的指针
} Node;

// 单循环链表结构体
typedef struct SingleLinkedList {
    Node* head; // 链表头部
    int length; // 链表长度
} SingleLinkedList;

// 初始化链表
SingleLinkedList* create_list();

// 插入节点
void insert_node(SingleLinkedList* list, int value, int position);

// 删除节点
void delete_node(SingleLinkedList* list, int index);

// 取数据元素
int get_data_element(const SingleLinkedList* list, int index);

// 获取链表元素个数
int get_length(const SingleLinkedList* list);

#endif // SINGLE_LINKED_LIST_H

**single_linked_list.c**

#include "single_linked_list.h"

// 实现函数
SingleLinkedList* create_list() {
    SingleLinkedList* list = (SingleLinkedList*)malloc(sizeof(SingleLinkedList));
    list->head = NULL;
    list->length = 0;
    return list;
}

void insert_node(SingleLinkedList* list, int value, int position) {
    if (position <= 0 || position > list->length + 1) {
        printf("Invalid position.\n");
        return;
    }
    
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = list->head;

    if (position == 1) {
        newNode->next->next = newNode;
    } else {
        Node* current = list->head;
        for (int i = 1; i < position - 1; i++) {
            current = current->next;
        }
        newNode->next = current->next;
        current->next = newNode;
    }

    list->length++;
}

void delete_node(SingleLinkedList* list, int index) {
    if (index < 1 || index > list->length) {
        printf("Invalid index.\n");
        return;
    }

    if (index == 1) {
        Node* temp = list->head;
        list->head = list->head->next;
        free(temp);
    } else {
        Node* current = list->head;
        for (int i = 1; i < index - 1; i++) {
            current = current->next;
        }
        Node* temp = current->next;
        current->next = temp->next;
        free(temp);
    }

    list->length--;
}

int get_data_element(const SingleLinkedList* list, int index) {
    if (index < 1 || index > list-1; // 或者抛出异常
    }

    Node* current = list->head;
    for (int i = 1; i < index; i++) {
        current = current->next;
    }
    return current->data;
}

int get_length(const SingleLinkedList* list) {
    return list->length;
}

使用这个代码，你可以分别导入`single_linked_list.h`并实现链表的初始化、插入、删除、取值和获取长度的操作。注意，这里没有处理所有边界条件，实际项目中需要完善错误检查和处理。