Linklist L; int len; ElemType a[]={2,31,3,5,3,8}; int n=sizeof(a)/(sizeof(a[0])); InitList(L); CreateListF(L,a,n); DispList(L);

在你提供的代码中，我注意到一个问题：在调用 `InitList` 函数时，你传递的是一个未初始化的指针 `L`，而函数内部会分配内存并将地址赋给 `L`。然而，这种方式无法将分配的内存地址返回给调用者。因此，你需要将 `InitList` 函数改为接受一个指向指针的指针，即 `bool InitList(Lnode **L)`，并在函数内部使用间接引用来修改 `L` 的值。

此外，你还需要在主函数中对 `L` 进行动态内存分配，可以将其改为 `Linklist L = (Lnode*)malloc(sizeof(Lnode));`。

下面是你提供的代码的修改版本：

Linklist L;
int len;
ElemType a[] = {2, 31, 3, 5, 3, 8};
int n = sizeof(a) / sizeof(a[0]);
InitList(&L);
CreateListF(&L, a, n);

DispList(&L);

请注意，我假设你已经定义了 `Linklist` 类型来表示单链表，并且定义了 `ElemType` 类型来表示链表元素的类型。确保在代码中正确声明这些类型，并且包含必要的头文件。

相关问题

循环链表： 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，其基本操作为LinkListInit(LinkList *L)。 （2）单链表L已存在，销毁单链表L，其基本操作为DestroyLinkList (LinkList *L)。 （3）单链表L已存在，若单链表L为空表，则返回0，否则返回1，调用函数可通过判断函数返回值确定结果状态，其基本操作为LinkListEmpty(LinkList *L)。 （4）单链表L已存在，返回单链表L中数据元素个数，其基本操作为LinkListLength (LinkList *L)。 （5）L为带头结点的单链表的头指针。当第i个元素存在时，返回其值，若这样的数据元素不存在，则给出相应的提示，其基本操作为GetLinkListElem(LinkList *L)。 （6）单链表L已存在，返回单链表L中第i个与e值相同的数据元素的位序，若这样的数据元素不存在，则给出相应的提示，其基本操作为LocateLinkListElem (LinkList *L, ElemType e)。 （7）在带头结点的单链表L中第i个位置之前插入元素e，若这样的数据元素不存在，则给出相应的提示，其基本操作为LinkListInsert(LinkList *L, int i, ElemType e)。 （8）在带头结点的单链表L中删除第i个元素，若这样的数据元素不存在或i值不符合要求，则给出相应的提示，其基本操作为LinkListDelete(LinkList *L, int i)。 （9）单链表L已存在，输出显示单链表L中的各个元素，其基本操作为DispLinkList(LinkList *L)。 （10） 头插法建立单链表L，其基本操作为CreateLinkListF(LinkList *L, ElemType d[ ], int n)。 （11） 尾插法建立单链表L，其基本操作为CreateLinkListR(LinkList *L, ElemType d[ ], int n)。

好的，我来依次回答你的问题。

1. 构造一个空的单链表L，其基本操作为LinkListInit(LinkList *L)。

typedef struct LNode {
    ElemType data; //数据域
    struct LNode *next; //指针域
} LNode, *LinkList;

//初始化链表
void LinkListInit(LinkList *L) {
    *L = (LinkList)malloc(sizeof(LNode)); //创建头结点
    (*L)->next = NULL; //头结点的指针域置空
}

2. 单链表L已存在，销毁单链表L，其基本操作为DestroyLinkList (LinkList *L)。

//销毁链表
void DestroyLinkList(LinkList *L) {
    LinkList p, q;
    p = (*L)->next; //p指向第一个结点
    while (p) {
        q = p->next; //q指向下一个结点
        free(p); //释放p结点
        p = q; //p指向下一个结点
    }
    free(*L); //释放头结点
    *L = NULL; //头指针置空
}

3. 单链表L已存在，若单链表L为空表，则返回0，否则返回1，调用函数可通过判断函数返回值确定结果状态，其基本操作为LinkListEmpty(LinkList *L)。

//判断链表是否为空
int LinkListEmpty(LinkList *L) {
    if ((*L)->next == NULL) {
        return 0; //空表
    }
    else {
        return 1; //非空表
    }
}

4. 单链表L已存在，返回单链表L中数据元素个数，其基本操作为LinkListLength (LinkList *L)。

//获取链表长度
int LinkListLength(LinkList *L) {
    int len = 0;
    LinkList p = (*L)->next; //p指向第一个结点
    while (p) {
        len++; //长度加1
        p = p->next; //p指向下一个结点
    }
    return len;
}

5. L为带头结点的单链表的头指针。当第i个元素存在时，返回其值，若这样的数据元素不存在，则给出相应的提示，其基本操作为GetLinkListElem(LinkList *L)。

//获取指定位置的结点元素值
int GetLinkListElem(LinkList *L, int i, ElemType *e) {
    int j = 1;
    LinkList p = (*L)->next; //p指向第一个结点
    while (p && j < i) {
        p = p->next; //p指向下一个结点
        j++; //计数器加1
    }
    if (!p || j > i) {
        return 0; //未找到指定位置的结点
    }
    *e = p->data; //获取结点元素值
    return 1;
}

6. 单链表L已存在，返回单链表L中第i个与e值相同的数据元素的位序，若这样的数据元素不存在，则给出相应的提示，其基本操作为LocateLinkListElem (LinkList *L, ElemType e)。

//查找指定元素值的结点位序
int LocateLinkListElem(LinkList *L, ElemType e) {
    int i = 1;
    LinkList p = (*L)->next; //p指向第一个结点
    while (p) {
        if (p->data == e) {
            return i; //返回结点位序
        }
        p = p->next; //p指向下一个结点
        i++; //计数器加1
    }
    return 0; //未找到指定元素值的结点
}

7. 在带头结点的单链表L中第i个位置之前插入元素e，若这样的数据元素不存在，则给出相应的提示，其基本操作为LinkListInsert(LinkList *L, int i, ElemType e)。

//在指定位置插入结点
int LinkListInsert(LinkList *L, int i, ElemType e) {
    int j = 1;
    LinkList p = (*L), s;
    while (p && j < i) {
        p = p->next; //p指向下一个结点
        j++; //计数器加1
    }
    if (!p || j > i) {
        return 0; //未找到指定位置的结点
    }
    s = (LinkList)malloc(sizeof(LNode)); //创建新结点
    s->data = e; //新结点赋值
    s->next = p->next; //新结点指向原来的结点
    p->next = s; //前一个结点指向新结点
    return 1;
}

8. 在带头结点的单链表L中删除第i个元素，若这样的数据元素不存在或i值不符合要求，则给出相应的提示，其基本操作为LinkListDelete(LinkList *L, int i)。

//删除指定位置的结点
int LinkListDelete(LinkList *L, int i) {
    int j = 1;
    LinkList p = (*L), q;
    while (p->next && j < i) {
        p = p->next; //p指向下一个结点
        j++; //计数器加1
    }
    if (!(p->next) || j > i) {
        return 0; //未找到指定位置的结点
    }
    q = p->next; //q指向要删除的结点
    p->next = q->next; //前一个结点指向后一个结点
    free(q); //释放结点
    return 1;
}

9. 单链表L已存在，输出显示单链表L中的各个元素，其基本操作为DispLinkList(LinkList *L)。

//输出链表元素
void DispLinkList(LinkList *L) {
    LinkList p = (*L)->next; //p指向第一个结点
    while (p) {
        printf("%d ", p->data); //输出结点元素
        p = p->next; //p指向下一个结点
    }
    printf("\n");
}

10. 头插法建立单链表L，其基本操作为CreateLinkListF(LinkList *L, ElemType d[ ], int n)。

//头插法建立链表
void CreateLinkListF(LinkList *L, ElemType d[], int n) {
    LinkList p;
    int i;
    *L = (LinkList)malloc(sizeof(LNode)); //创建头结点
    (*L)->next = NULL; //头结点的指针域置空
    for (i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(LNode)); //创建新结点
        p->data = d[i]; //新结点赋值
        p->next = (*L)->next; //新结点指向第一个结点
        (*L)->next = p; //头结点指向新结点
    }
}

11. 尾插法建立单链表L，其基本操作为CreateLinkListR(LinkList *L, ElemType d[ ], int n)。

//尾插法建立链表
void CreateLinkListR(LinkList *L, ElemType d[], int n) {
    LinkList p, r;
    int i;
    *L = (LinkList)malloc(sizeof(LNode)); //创建头结点
    r = *L; //r指向头结点
    for (i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(LNode)); //创建新结点
        p->data = d[i]; //新结点赋值
        r->next = p; //尾结点指向新结点
        r = p; //r指向新结点
    }
    r->next = NULL; //尾结点的指针域置空
}

以上就是单链表的各种基本操作啦，希望能对你有所帮助！