void ListInsert_L(LinkList &L,int i,ElemType e) { //在单链表的第i个位置之前插入一个元素e，如果插入位置不合理，输出提示信息"插入位置非法",如果是空表输出提示信息”空表“}

以下是在单链表的第i个位置之前插入一个元素e的代码，你可以参考：

void ListInsert_L(LinkList &L, int i, ElemType e) {
    if (L == NULL) {
        printf("空表\n");
        return;
    }
    if (i < 1 || i > ListLength_L(L) + 1) {
        printf("插入位置非法\n");
        return;
    }
    LinkList p = L, s;
    int j = 1;
    while (p && j < i) {
        p = p->next;
        j++;
    }
    s = (LinkList) malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
}

其中，ListLength_L(L) 是单链表 L 的长度，可以用以下代码实现：

int ListLength_L(LinkList L) {
    int len = 0;
    LinkList p = L;
    while (p) {
        len++;
        p = p->next;
    }
    return len;
}

相关问题

根据提示，在右侧编辑器 Begin-End 区间补充代码，完成单链表的初始化操作，遍历操作及插入操作三个子函数的定义，具体要求如下： void InitList(LinkList &L);//构造一个空的单链表L int ListInsert(LinkList &L,int i,ElemType e) ;//在单链表L中第i个位置之前插入新的数据元素 void ListTraverse(LinkList L,void(*vi)(ElemType));// 依次调用函数vi()输出单链表L的每个数据元素

* L); // 初始化单链表

void TraverseList(LinkList L); // 遍历单链表

void InsertList(LinkList* L, int pos, int val); // 在单链表的指定位置插入元素

以下是代码：

// 单链表结构体
typedef struct Node {
int val;
struct Node* next;
}Node, * LinkList;

void InitList(LinkList* L) {
// 创建头节点
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL;
}

void TraverseList(LinkList L) {
// 从头节点开始遍历
LinkList p = L->next;
while (p) {
printf("%d ", p->val);
p = p->next;
}
}

void InsertList(LinkList* L, int pos, int val) {
// 创建新节点
LinkList newNode = (LinkList)malloc(sizeof(Node));
newNode->val = val;
newNode->next = NULL;
// 找到插入位置的前一个节点
LinkList pre = *L;
for (int i = 1; i < pos; i++) {
pre = pre->next;
if (pre == NULL) {
printf("插入位置不合法\n");
return;
}
}
// 插入新节点
newNode->next = pre->next;
pre->next = newNode;
}

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