用C语言实现判断线性表L是否为空

在C语言中，要判断一个线性表（也称为数组或动态数组）是否为空，通常会检查表头元素的值或通过指针来确认。下面是一个简单的示例：

#include <stdbool.h> // 引入bool类型

// 定义线性表节点结构体
typedef struct Node {
    int data;      // 数据域
    struct Node* next; // 指向下一个节点的指针
} Node;

// 判断线性表L是否为空的函数
bool isListEmpty(Node* head) {
    // 如果头节点为空，则表示列表为空
    return head == NULL;
}

int main() {
    Node* list = NULL; // 初始化一个空的线性表
    if (isListEmpty(list)) {
        printf("线性表L为空。\n");
    } else {
        printf("线性表L非空。\n");
    }
    return 0;
}

在这个例子中，`isListEmpty`函数接受一个指向头节点的指针，如果头节点`head`为`NULL`，则返回`true`，表示列表为空；反之，返回`false`。

相关问题

使用c语言实现一般线性表的建立、增、删、改、查，采用顺序存储和链式存储两种方法实现

1. 顺序存储

首先定义一个结构体，用于存储线性表中的元素。其中elem为存储数据的数组，length为当前线性表的长度。

#define MAXSIZE 100 // 线性表的最大长度

typedef struct {
    int elem[MAXSIZE];
    int length;
} SqList;

接下来实现建立线性表的函数，需要注意的是，需要先输入线性表的长度，再输入每个元素的值。

void create(SqList *L) {
    int i, len;
    printf("请输入线性表的长度：");
    scanf("%d", &len);
    printf("请输入线性表中的元素：");
    for (i = 0; i < len; i++) {
        scanf("%d", &L->elem[i]);
    }
    L->length = len;
}

增加元素的函数可以在末尾插入一个元素，需要先判断线性表是否已满。

void insert(SqList *L, int pos, int val) {
    int i;
    if (L->length == MAXSIZE) {
        printf("线性表已满，无法插入！");
        return;
    }
    if (pos < 1 || pos > L->length + 1) {
        printf("插入位置不合法！");
        return;
    }
    for (i = L->length; i >= pos; i--) {
        L->elem[i] = L->elem[i - 1];
    }
    L->elem[pos - 1] = val;
    L->length++;
}

删除元素的函数可以删除指定位置的元素，需要先判断位置是否合法。

void delete(SqList *L, int pos) {
    int i;
    if (pos < 1 || pos > L->length) {
        printf("删除位置不合法！");
        return;
    }
    for (i = pos; i < L->length; i++) {
        L->elem[i - 1] = L->elem[i];
    }
    L->length--;
}

修改元素的函数可以修改指定位置的元素，需要先判断位置是否合法。

void update(SqList *L, int pos, int val) {
    if (pos < 1 || pos > L->length) {
        printf("修改位置不合法！");
        return;
    }
    L->elem[pos - 1] = val;
}

查找元素的函数可以查找指定值的元素，返回它的位置。

int search(SqList L, int val) {
    int i;
    for (i = 0; i < L.length; i++) {
        if (L.elem[i] == val) {
            return i + 1;
        }
    }
    return 0;
}

2. 链式存储

首先定义一个结构体，用于表示链表中的一个节点。其中data为节点中存储的元素值，next为指向下一个节点的指针。

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

接下来实现建立链表的函数，需要输入链表的长度和每个节点中存储的元素值。

void create(LinkList *L) {
    int i, len, val;
    LNode *p, *q;
    printf("请输入链表的长度：");
    scanf("%d", &len);
    *L = (LinkList)malloc(sizeof(LNode));
    (*L)->next = NULL;
    q = *L;
    printf("请输入链表中的元素：");
    for (i = 0; i < len; i++) {
        scanf("%d", &val);
        p = (LNode*)malloc(sizeof(LNode));
        p->data = val;
        p->next = NULL;
        q->next = p;
        q = p;
    }
}

增加元素的函数可以在指定位置插入一个元素，需要先找到插入位置的前一个节点。

void insert(LinkList *L, int pos, int val) {
    int i;
    LNode *p, *q;
    p = *L;
    for (i = 1; i < pos && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL) {
        printf("插入位置不合法！");
        return;
    }
    q = (LNode*)malloc(sizeof(LNode));
    q->data = val;
    q->next = p->next;
    p->next = q;
}

删除元素的函数可以删除指定位置的元素，需要先找到删除位置的前一个节点。

void delete(LinkList *L, int pos) {
    int i;
    LNode *p, *q;
    p = *L;
    for (i = 1; i < pos && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL || p->next == NULL) {
        printf("删除位置不合法！");
        return;
    }
    q = p->next;
    p->next = q->next;
    free(q);
}

修改元素的函数可以修改指定位置的元素，需要先找到指定位置的节点。

void update(LinkList L, int pos, int val) {
    int i;
    LNode *p;
    p = L->next;
    for (i = 1; i < pos && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL) {
        printf("修改位置不合法！");
        return;
    }
    p->data = val;
}

查找元素的函数可以查找指定值的元素，返回它的位置。

int search(LinkList L, int val) {
    int i;
    LNode *p;
    p = L->next;
    for (i = 1; p != NULL; i++) {
        if (p->data == val) {
            return i;
        }
        p = p->next;
    }
    return 0;
}

C语言实现用线性表随机生成10个1-100的有顺序的随机数，并输入一个元素插入

好的，我来为您解答。

首先，我们可以使用C语言中的rand()函数来生成随机数，并将它们存储在一个线性表中。具体实现如下：

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

#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int length;
} SqList;

void initList(SqList *L) {
    int i;
    srand((unsigned int)time(NULL)); // 初始化随机数种子
    for (i = 0; i < MAX_SIZE; i++) {
        L->data[i] = rand() % 100 + 1; // 生成1-100的随机数
    }
    L->length = MAX_SIZE;
}

void printList(SqList L) {
    int i;
    for (i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}

void insertElem(SqList *L, int elem) {
    int i, j;
    if (L->length >= MAX_SIZE) {
        printf("线性表已满，无法插入元素！\n");
        return;
    }
    for (i = 0; i < L->length; i++) {
        if (L->data[i] > elem) {
            break;
        }
    }
    for (j = L->length - 1; j >= i; j--) {
        L->data[j + 1] = L->data[j];
    }
    L->data[i] = elem;
    L->length++;
}

int main() {
    SqList L;
    initList(&L);
    printf("随机生成的有序线性表为：\n");
    printList(L);
    int elem;
    printf("请输入要插入的元素：");
    scanf("%d", &elem);
    insertElem(&L, elem);
    printf("插入后的有序线性表为：\n");
    printList(L);
    return 0;
}

以上代码中，我们定义了一个结构体类型`SqList`，它包含一个整型数组`data`和一个表示线性表长度的整型变量`length`。`initList()`函数用于初始化线性表，它通过调用`srand()`函数初始化随机数种子，然后使用`rand()`函数随机生成10个1-100的整数，并将它们存储在`data`数组中。`printList()`函数用于输出线性表中的元素。`insertElem()`函数用于向线性表中插入一个元素，它首先判断线性表是否已满，如果已满则输出提示信息并返回；否则，它从线性表的第一个元素开始遍历，找到第一个大于待插入元素的位置，然后将这个位置后面的元素都向后移动一位，最后将待插入元素插入到这个位置上。

最后，在`main()`函数中，我们先调用`initList()`函数初始化线性表，然后调用`printList()`函数输出线性表中的元素。接着，我们通过`scanf()`函数从标准输入中读取一个整数作为待插入元素，并调用`insertElem()`函数将它插入到线性表中。最后，我们再次调用`printList()`函数输出插入后的线性表。