单链表的插入算法—第i个元素之前插入元素e的C语言代码怎么写

typedef struct ListNode {
int val;
struct ListNode *next;
} ListNode;

ListNode* insert(ListNode* head, int i, int e) {
ListNode* node = (ListNode*)malloc(sizeof(ListNode));
node->val = e;
node->next = NULL;
if(i == 1) {
node->next = head;
head = node;
return head;
}
ListNode* p = head;
for(int j = 1; j < i - 1; j++) {
p = p->next;
}
node->next = p->next;
p->next = node;
return head;
}

相关问题

C语言代码实现带头结点的单链表插入排序

下面是一个使用C语言实现带头结点的单链表插入排序的示例代码：

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

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

// 创建新结点
ListNode* createNode(int data) {
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    if (newNode == NULL) {
        printf("内存分配失败！\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 插入结点到链表末尾
void insertNode(ListNode** head, int data) {
    ListNode* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    } else {
        ListNode* curr = *head;
        while (curr->next != NULL) {
            curr = curr->next;
        }
        curr->next = newNode;
    }
}

// 打印链表
void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

// 单链表插入排序
void insertionSort(ListNode** head) {
    if (*head == NULL || (*head)->next == NULL) {
        return;
    }
    
    ListNode* sortedList = *head;
    ListNode* curr = sortedList->next;
    sortedList->next = NULL;
    
    while (curr != NULL) {
        ListNode* prev = NULL;
        ListNode* temp = curr;
        curr = curr->next;
        
        if (temp->data < sortedList->data) {
            temp->next = sortedList;
            sortedList = temp;
        } else {
            ListNode* search = sortedList;
            while (search != NULL && temp->data > search->data) {
                prev = search;
                search = search->next;
            }
            prev->next = temp;
            temp->next = search;
        }
    }
    
    *head = sortedList;
}

int main() {
    ListNode* head = NULL;
    insertNode(&head, 5);
    insertNode(&head, 3);
    insertNode(&head, 8);
    insertNode(&head, 1);
    insertNode(&head, 6);
    
    printf("排序前的链表：");
    printList(head);
    
    insertionSort(&head);
    
    printf("排序后的链表：");
    printList(head);
    
    return 0;
}

这段代码会创建一个带头结点的单链表，并使用插入排序算法对链表进行排序。在 `main` 函数中，我们插入了一些随机的整数，然后调用 `insertionSort` 函数进行排序，最后打印出排序后的链表。

C语言单链表的基本算法代码

单链表的基本算法代码如下：

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

//创建单链表
ListNode* createList(int arr[], int n){
ListNode *head = NULL, *tail = NULL;
for(int i = ; i < n; i++){
ListNode *node = (ListNode*)malloc(sizeof(ListNode));
node->val = arr[i];
node->next = NULL;
if(head == NULL){
head = tail = node;
}else{
tail->next = node;
tail = node;
}
}
return head;
}

//遍历单链表
void traverseList(ListNode *head){
ListNode *p = head;
while(p != NULL){
printf("%d ", p->val);
p = p->next;
}
}

//插入节点
ListNode* insertNode(ListNode *head, int val){
ListNode *node = (ListNode*)malloc(sizeof(ListNode));
node->val = val;
node->next = NULL;
if(head == NULL){
head = node;
}else{
ListNode *p = head;
while(p->next != NULL){
p = p->next;
}
p->next = node;
}
return head;
}

//删除节点
ListNode* deleteNode(ListNode *head, int val){
if(head == NULL){
return NULL;
}
if(head->val == val){
ListNode *p = head;
head = head->next;
free(p);
return head;
}
ListNode *p = head;
while(p->next != NULL && p->next->val != val){
p = p->next;
}
if(p->next != NULL){
ListNode *q = p->next;
p->next = q->next;
free(q);
}
return head;
}

//反转单链表
ListNode* reverseList(ListNode *head){
ListNode *prev = NULL, *curr = head;
while(curr != NULL){
ListNode *next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
return prev;
}