void InsertList(LinkList L,int i)//插入表的信息 { if(L==NULL) { printf("链表为空！\n"); return; } LinkNode *p,*q,*s; int j=1; p=L; if(i<1||i>Listlength(L)+1)//要插入的位置是否满足能够插入的空间内，因为要插入一个数据，所以最后的长度肯定会比当前表的长度加一 { printf("插入位置不正确!"); return; } s=(LinkNode *)malloc(sizeof(LinkNode)); printf("\n学号 姓名 班级 性别 成绩:\n"); scanf("%s%s%s%s%f",&s->data.num,&s->data.name,&s->data.clas,&s->data.sex,&s->data.score); while(j<=i) { q=p; p=p->next; j++; }//找到插入的位置 s->next=p; q->next=s; printf("成功插入新的学生信息"); }

这段代码实现了链表的插入操作，将一个新节点插入到链表中的指定位置。其中，LinkList 是一个链表类型的结构体，包含了指向链表头节点的指针；LinkNode 是链表中的节点类型的结构体，包含了数据域和指向下一个节点的指针。

具体实现过程如下：

1. 判断链表是否为空，如果为空则无法插入，直接返回。

2. 定义三个指针变量：p、q、s，其中 p 指向链表头节点，q 指向插入位置前一个节点，s 为新节点。

3. 判断插入位置是否合法，即 i 是否在 [1, Listlength(L)+1] 的范围内，如果不是则输出错误信息并返回。

4. 输入新节点的数据，将其存储到 s 的数据域中。

5. 遍历链表，找到要插入的位置，即第 i 个节点的前一个节点，将其保存到 q 中。

6. 将新节点 s 的 next 指针指向第 i 个节点，将 q 的 next 指针指向新节点 s，完成插入操作。

7. 输出成功插入的提示信息。

需要注意的是，该函数没有返回值，因为链表是通过指针传递的，直接修改链表即可。同时，该函数也没有进行内存分配的检查，如果内存不足可能会导致程序崩溃。

相关问题

利用数据结构c语言单链表编写一个void MaxMin(LinkList L)//显示最高分和最低分的学生信息

好的，下面是用C语言单链表实现显示最高分和最低分的学生信息的代码：

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

//定义链表节点结构体
typedef struct Node{
    int score;
    char name[20];
    struct Node *next;
}Node, *LinkList;

//创建链表
void CreateList(LinkList *L){
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;
}

//插入链表节点
void InsertNode(LinkList L, char name[], int score){
    Node *p = (Node*)malloc(sizeof(Node));
    p->score = score;
    strcpy(p->name, name);
    p->next = L->next;
    L->next = p;
}

//查找链表最高分和最低分学生信息
void MaxMin(LinkList L){
    int maxScore = 0, minScore = 100;
    char maxName[20], minName[20];
    Node *p = L->next;
    while(p){
        if(p->score > maxScore){
            maxScore = p->score;
            strcpy(maxName, p->name);
        }
        if(p->score < minScore){
            minScore = p->score;
            strcpy(minName, p->name);
        }
        p = p->next;
    }
    printf("最高分学生：%s，分数：%d\n", maxName, maxScore);
    printf("最低分学生：%s，分数：%d\n", minName, minScore);
}

//主函数
int main(){
    LinkList L;
    CreateList(&L);
    InsertNode(L, "小明", 90);
    InsertNode(L, "小红", 85);
    InsertNode(L, "小刚", 95);
    InsertNode(L, "小李", 80);
    MaxMin(L);
    return 0;
}

在这个代码中，我们通过定义链表节点结构体和创建链表函数来实现创建单链表。然后，我们通过插入链表节点函数来逐个添加学生信息（姓名和分数）。最后，我们通过查找最高分和最低分学生信息的函数来获得链表中的最高分和最低分学生信息，然后输出它们的姓名和分数。

循环链表： 1）建立带表头节点的单链线性表L,建立后(逆序建立)，再输出。 void CreateList(LinkList L,int n) void Print(LinkList L) 2）在第一问的基础上，完成以下个函数 判空函数： Status ListEmpty(LinkList L) 插入函数： Status ListInsert(LinkList L,int i, ElemType e) 删除函数： Status ListDelete(LinkList L, int i, ElemType *e) 排序函数：

以下是关于循环链表的代码实现，包括建立带表头节点的循环链表、判空函数、插入函数、删除函数和排序函数。

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

typedef int ElemType;
typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

// 建立带表头节点的循环链表
void CreateList(LinkList L, int n) {
    int i;
    LNode *p;
    L->next = NULL;
    for(i = n; i > 0; --i) {
        p = (LNode*)malloc(sizeof(LNode));
        printf("输入第%d个节点的值：", i);
        scanf("%d", &(p->data));
        p->next = L->next;
        L->next = p;
    }
    // 将表尾节点指向表头节点，形成循环链表
    p = L;
    while(p->next != NULL)
        p = p->next;
    p->next = L;
}

// 输出循环链表
void Print(LinkList L) {
    LNode *p = L->next;
    printf("循环链表：");
    while(p != L) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 判空函数
int ListEmpty(LinkList L) {
    return L->next == NULL;
}

// 插入函数
int ListInsert(LinkList L, int i, ElemType e) {
    int j = 0;
    LNode *p = L, *s;
    while(p->next != L && j < i - 1) {
        p = p->next;
        ++j;
    }
    if(p->next == L && j < i - 1) // i值不合法
        return 0;
    s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return 1;
}

// 删除函数
int ListDelete(LinkList L, int i, ElemType *e) {
    int j = 0;
    LNode *p = L, *q;
    while(p->next != L && j < i - 1) {
        p = p->next;
        ++j;
    }
    if(p->next == L && j < i - 1) // i值不合法
        return 0;
    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return 1;
}

// 排序函数
void ListSort(LinkList L) {
    LNode *p, *q;
    ElemType tmp;
    for(p = L->next; p != L; p = p->next) {
        for(q = p->next; q != L; q = q->next) {
            if(p->data > q->data) {
                tmp = p->data;
                p->data = q->data;
                q->data = tmp;
            }
        }
    }
}

int main() {
    int n, i, e;
    LNode L;
    printf("输入循环链表长度：");
    scanf("%d", &n);
    CreateList(&L, n);
    Print(&L);
    if(ListEmpty(&L))
        printf("循环链表为空\n");
    else
        printf("循环链表不为空\n");
    printf("输入要插入的元素及位置：");
    scanf("%d%d", &e, &i);
    if(ListInsert(&L, i, e))
        printf("插入成功\n");
    else
        printf("插入失败\n");
    Print(&L);
    printf("输入要删除的元素位置：");
    scanf("%d", &i);
    if(ListDelete(&L, i, &e))
        printf("删除成功，删除的元素是%d\n", e);
    else
        printf("删除失败\n");
    Print(&L);
    ListSort(&L);
    printf("排序后的循环链表：");
    Print(&L);
    return 0;
}

上述代码中，建立循环链表的函数`CreateList`使用逆序建立的方法，即从后往前插入节点。判空函数`ListEmpty`直接判断头节点的`next`指针是否为空指针即可。插入函数`ListInsert`在找到插入位置后，使用动态内存分配函数`malloc`申请新节点，将待插入元素赋值给新节点的`data`成员，将新节点插入到链表中，并返回插入结果。删除函数`ListDelete`在找到待删除位置后，将待删除节点从链表中删除，将其`data`成员赋值给输出参数`e`，并释放节点所占内存。排序函数`ListSort`使用冒泡排序算法实现对循环链表的排序。