void insert(LinkList *list, int n) { LinkList *t = list, *in; int i = 0; while (i < n && t != NULL) { t = t->next; i++; } if (t != NULL) { in = (LinkList*)malloc(sizeof(LinkList)); puts("输入要插入的值"); scanf("%d", &in->score); in->next = t->next;//填充in节点的指针域，也就是说把in的指针域指向t的下一个节点 t->next = in;//填充t节点的指针域，把t的指针域重新指向in } else { puts("节点不存在"); } }

这是一个在链表中插入节点的函数`insert`，它接受两个参数：一个是指向链表头节点的指针`list`，另一个是要插入的节点的位置`n`。

首先，定义了两个指针变量`t`和`in`，并将`t`指向链表头节点`list`，同时初始化一个计数器`i`为0。

然后，通过一个循环遍历链表，直到找到第`n`个节点或者遍历到链表尾部。在每次循环中，将指针`t`指向下一个节点，并将计数器`i`自增1。

接着，判断指针`t`是否为NULL。如果不为NULL，表示找到了第`n`个节点，那么通过`malloc`函数动态分配了一个`LinkList`大小的内存空间给新节点`in`。

然后，提示用户输入要插入的值，并通过`scanf`函数将输入的值存储到新节点的`score`成员中。

接下来，将新节点插入到链表中。将新节点`in`的`next`指针指向节点`t`的下一个节点，即新节点指向原来位置的后续节点。然后将节点`t`的`next`指针指向新节点`in`，即修改节点`t`的指针域，使其指向新插入的节点。

如果指针`t`为NULL，表示找不到第`n`个节点，输出提示信息"节点不存在"。

这样，函数就完成了在链表中指定位置插入节点的操作。

相关问题

循环链表： 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)  排序函数： Status ListSort(LinkList L)

好的，我来逐一回答您的问题。

1. 建立带表头节点的单链线性表L，建立后(逆序建立)，再输出。

首先需要定义一个单链表的结构体：

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

然后，可以按照如下代码实现 CreateList 和 Print 函数：

void CreateList(LinkList L, int n) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    while (n--) {
        LNode *p = (LNode*)malloc(sizeof(LNode));
        scanf("%d", &p->data);
        p->next = L->next;
        L->next = p;
    }
}

void Print(LinkList L) {
    LNode *p = L->next;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
}

2. 在第一问的基础上，完成以下函数：

- 判空函数： `Status ListEmpty(LinkList L)`

Status ListEmpty(LinkList L) {
    return L->next == NULL ? TRUE : FALSE;
}

- 插入函数： `Status ListInsert(LinkList L, int i, ElemType e)`

Status ListInsert(LinkList L, int i, ElemType e) {
    LNode *p = L;
    while (i > 1 && p) {
        p = p->next;
        i--;
    }
    if (!p || i < 1) {
        return ERROR;
    }
    LNode *new_node = (LNode*)malloc(sizeof(LNode));
    new_node->data = e;
    new_node->next = p->next;
    p->next = new_node;
    return OK;
}

- 删除函数： `Status ListDelete(LinkList L, int i, ElemType *e)`

Status ListDelete(LinkList L, int i, ElemType *e) {
    LNode *p = L;
    while (i > 1 && p->next) {
        p = p->next;
        i--;
    }
    if (!p->next || i < 1) {
        return ERROR;
    }
    LNode *q = p->next;
    *e = q->data;
    p->next = q->next;
    free(q);
    return OK;
}

- 排序函数： `Status ListSort(LinkList L)`

Status ListSort(LinkList L) {
    if (ListEmpty(L)) {
        return ERROR;
    }
    LNode *p = L->next;
    int len = 0;
    while (p) {
        len++;
        p = p->next;
    }
    for (int i = 0; i < len - 1; i++) {
        p = L->next;
        for (int j = 0; j < len - i - 1; j++) {
            if (p->data > p->next->data) {
                ElemType tmp = p->data;
                p->data = p->next->data;
                p->next->data = tmp;
            }
            p = p->next;
        }
    }
    return OK;
}

希望以上代码能够帮到您。

循环链表： 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`使用冒泡排序算法实现对循环链表的排序。