线性表的道理表存储结构 #include<stdio.h> #include<malloc.h> 申请空间 typedef int ElemType; typedef int Status; typedef struct Lnode { ElemType data; struct Lnode *next; }Lnode, *LinkList; 循环链表： 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)

好的，这里给出线性表的链式存储结构的实现代码，包括循环链表的创建、输出、判空、插入、删除和排序函数的实现。

#include<stdio.h>
#include<malloc.h>

typedef int ElemType;
typedef int Status;

//定义链表结点类型
typedef struct Lnode {
    ElemType data;
    struct Lnode *next;
} Lnode, *LinkList;

//创建循环链表，带头结点
void CreateList(LinkList L, int n) {
    L->next = NULL;  //初始为空链表
    for (int i = n; i > 0; i--) {
        Lnode *p = (LinkList)malloc(sizeof(Lnode));  //为新结点分配空间
        scanf_s("%d", &p->data);  //输入结点数据
        p->next = L->next;  //将新结点插入到头结点之后
        L->next = p;
    }
    //将最后一个结点的next指向头结点，形成循环链表
    Lnode *tail = L->next;
    while (tail->next != NULL) {
        tail = tail->next;
    }
    tail->next = L->next;
}

//输出循环链表
void Print(LinkList L) {
    Lnode *p = L->next;
    while (p != L) {  //遍历链表直到回到头结点
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

//判空函数
Status ListEmpty(LinkList L) {
    if (L->next == NULL) {
        return 1;  //链表为空
    }
    else {
        return 0;  //链表不为空
    }
}

//插入函数
Status ListInsert(LinkList L, int i, ElemType e) {
    if (i < 1) {
        return 0;  //插入位置不合法
    }
    Lnode *p = L;
    int j = 0;
    while (p != NULL && j < i - 1) {  //查找插入位置
        p = p->next;
        j++;
    }
    if (p == NULL) {
        return 0;  //插入位置不合法
    }
    Lnode *s = (LinkList)malloc(sizeof(Lnode));  //为新结点分配空间
    s->data = e;
    s->next = p->next;  //将新结点插入到p之后
    p->next = s;
    return 1;
}

//删除函数
Status ListDelete(LinkList L, int i, ElemType *e) {
    if (i < 1) {
        return 0;  //删除位置不合法
    }
    Lnode *p = L;
    int j = 0;
    while (p->next != NULL && j < i - 1) {  //查找删除位置的前一个结点
        p = p->next;
        j++;
    }
    if (p->next == NULL) {
        return 0;  //删除位置不合法
    }
    Lnode *q = p->next;  //删除结点
    *e = q->data;
    p->next = q->next;
    free(q);
    return 1;
}

//排序函数，使用冒泡排序算法
Status ListSort(LinkList L) {
    if (ListEmpty(L)) {
        return 0;  //链表为空，无法排序
    }
    int len = 0;  //计算链表长度
    Lnode *p = L->next;
    while (p != L) {
        len++;
        p = p->next;
    }
    for (int i = 0; i < len - 1; i++) {  //执行n-1趟冒泡排序
        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 1;
}

int main() {
    LinkList L = (LinkList)malloc(sizeof(Lnode));  //创建头结点
    int n;
    printf("请输入链表长度：");
    scanf_s("%d", &n);
    printf("请逆序输入链表中的元素：");
    CreateList(L, n);
    printf("逆序输出链表中的元素：");
    Print(L);
    printf("链表是否为空：%d\n", ListEmpty(L));
    int i, e;
    printf("请输入要插入元素的位置和值：");
    scanf_s("%d%d", &i, &e);
    if (ListInsert(L, i, e)) {
        printf("插入操作成功，插入后的链表为：");
        Print(L);
    }
    else {
        printf("插入操作失败，插入位置不合法！\n");
    }
    printf("请输入要删除元素的位置：");
    scanf_s("%d", &i);
    if (ListDelete(L, i, &e)) {
        printf("删除操作成功，删除的元素值为：%d，删除后的链表为：", e);
        Print(L);
    }
    else {
        printf("删除操作失败，删除位置不合法！\n");
    }
    if (ListSort(L)) {
        printf("排序操作成功，排序后的链表为：");
        Print(L);
    }
    else {
        printf("链表为空，无法进行排序！\n");
    }
    return 0;
}

注意，这里是带头结点的循环链表，头结点的next指向第一个结点，而不是NULL。在创建循环链表时，需要在最后一个结点的next指向头结点，形成循环链表。在输出循环链表时，需要遍历链表直到回到头结点。其他操作和单链表的实现类似，只是需要注意循环链表的特殊性质。