5.以C结构体或C++的“类”代替“第2章中复杂数据类型”，实现“链式线性表”，编写下面6个接口函数：CreateList、ListPrint、GetElem、ListLength、ListInsert、ListDelete

### 回答1：
1.定义链表节点结构体

typedef struct ListNode {
    int data;               // 节点中存储的数据
    struct ListNode* next;  // 指向下一个节点的指针
} ListNode;

2.定义链表结构体

typedef struct List {
    ListNode* head;  // 头节点指针
    int length;      // 链表长度
} List;

3.实现CreateList函数

List* CreateList() {
    List* list = (List*)malloc(sizeof(List));    // 分配链表结构体空间
    list->head = NULL;                           // 头节点指针初始化为NULL
    list->length = 0;                            // 链表长度初始化为0
    return list;
}

4.实现ListPrint函数

void ListPrint(List* list) {
    ListNode* p = list->head;                          // 从头节点开始遍历
    while (p != NULL) {
        printf("%d ", p->data);                        // 输出节点中的数据
        p = p->next;                                   // 指向下一个节点
    }
    printf("\n");
}

5.实现GetElem函数

int GetElem(List* list, int index) {
    if (index < 0 || index >= list->length) {          // 判断索引是否合法
        printf("Index out of range.\n");
        return -1;
    }
    int i = 0;
    ListNode* p = list->head;                          // 从头节点开始遍历
    while (i < index) {
        p = p->next;                                   // 指向下一个节点
        i++;
    }
    return p->data;                                    // 返回节点中的数据
}

6.实现ListLength函数

int ListLength(List* list) {
    return list->length;                               // 返回链表长度
}

7.实现ListInsert函数

void ListInsert(List* list, int index, int data) {
    if (index < 0 || index > list->length) {           // 判断索引是否合法
        printf("Index out of range.\n");
        return;
    }
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));  // 分配新节点空间
    node->data = data;                                    // 存储数据
    if (index == 0) {                                     // 在头部插入
        node->next = list->head;                          // 新节点的next指针指向原头节点
        list->head = node;                                // 头节点指向新节点
    } else {                                               // 在中间或尾部插入
        int i = 0;
        ListNode* p = list->head;                          // 从头节点开始遍历
        while (i < index - 1) {
            p = p->next;                                   // 指向下一个节点
            i++;
        }
        node->next = p->next;                              // 新节点的next指针指向原节点的下一个节点
        p->next = node;                                    // 原节点的next指针指向新节点
    }
    list->length++;                                        // 链表长度加一
}

8.实现ListDelete函数

void ListDelete(List* list, int index) {
    if (index < 0 || index >= list->length) {             // 判断索引是否合法
        printf("Index out of range.\n");
        return;
    }
    ListNode* p;
    if (index == 0) {                                     // 删除头节点
        p = list->head;                                   // p指向头节点
        list->head = p->next;                             // 头节点指向原头节点的下一个节点
    } else {                                               // 删除中间或尾部节点
        int i = 0;
        ListNode* q = list->head;                         // 从头节点开始遍历
        while (i < index - 1) {
            q = q->next;                                  // 指向下一个节点
            i++;
        }
        p = q->next;                                      // p指向要删除的节点
        q->next = p->next;                                // 前一个节点的next指针指向要删除节点的下一个节点
    }
    free(p);                                               // 释放被删除节点的空间
    list->length--;                                        // 链表长度减一
}

### 回答2：
以下是使用C结构体实现链式线性表的代码：

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

// 定义链式线性表的节点结构体
typedef struct Node{
    int data;
    struct Node *next;
}Node;

// 创建链式线性表，返回头节点的指针
Node* CreateList(){
    Node *head = (Node*)malloc(sizeof(Node)); // 创建头节点
    head->next = NULL;  // 头节点的next指针置空
    return head;
}

// 打印链式线性表的元素
void ListPrint(Node *head){
    Node *p = head->next;  // 从第一个节点开始打印
    while(p != NULL){
        printf("%d ", p->data);  // 打印节点的数据
        p = p->next;  // 指向下一个节点
    }
    printf("\n");
}

// 获取链式线性表中第i个元素的值
int GetElem(Node *head, int i){
    int j = 0;
    Node *p = head->next;  // 从第一个节点开始查找
    while(p != NULL && j < i-1){
        p = p->next;  // 指向下一个节点
        j++;
    }
    if(p == NULL || j > i-1){
        printf("元素不存在\n");
        return -1;
    }
    return p->data;
}

// 返回链式线性表的长度
int ListLength(Node *head){
    int length = 0;
    Node *p = head->next;  // 从第一个节点开始计数
    while(p != NULL){
        length++;
        p = p->next;  // 指向下一个节点
    }
    return length;
}

// 在链式线性表的第i个位置插入新的元素
void ListInsert(Node *head, int i, int elem){
    int j = 0;
    Node *p = head;  // 从头节点开始查找
    while(p != NULL && j < i-1){
        p = p->next;  // 指向下一个节点
        j++;
    }
    if(p == NULL || j > i-1){
        printf("位置不合法\n");
        return;
    }
    Node *newNode = (Node*)malloc(sizeof(Node));  // 创建新的节点
    newNode->data = elem;  // 赋值新节点的数据
    newNode->next = p->next;  // 将新节点插入到链表中
    p->next = newNode;
}

// 在链式线性表中删除第i个元素
void ListDelete(Node *head, int i){
    int j = 0;
    Node *p = head;  // 从头节点开始查找
    while(p->next != NULL && j < i-1){
        p = p->next;  // 指向下一个节点
        j++;
    }
    if(p->next == NULL || j > i-1){
        printf("位置不合法\n");
        return;
    }
    Node *temp = p->next;  // 将要删除的节点
    p->next = temp->next;  // 从链表中删除节点
    free(temp);  // 释放节点的内存空间
}

int main(){
    Node *list = CreateList();  // 创建链式线性表
    ListInsert(list, 1, 10);  // 在第一个位置插入元素10
    ListInsert(list, 2, 20);  // 在第二个位置插入元素20
    ListInsert(list, 3, 30);  // 在第三个位置插入元素30
    printf("链表的元素：");
    ListPrint(list);  // 打印链表的元素

    printf("链表的第2个元素：%d\n", GetElem(list, 2));  // 获取链表中第2个元素的值

    printf("链表的长度：%d\n", ListLength(list));  // 获取链表的长度

    ListDelete(list, 2);  // 删除链表中第2个元素
    printf("链表的元素：");
    ListPrint(list);  // 打印链表的元素

    return 0;
}

以上代码中，使用了一个结构体`Node`来表示链式线性表的节点，结构体包含一个整型数据`data`和一个指向下一个节点的指针`next`。接口函数`CreateList`用来创建链式线性表并返回头节点指针，`ListPrint`用来打印链式线性表的元素，`GetElem`用来获取链式线性表中第i个元素的值，`ListLength`用来返回链式线性表的长度，`ListInsert`用来在链式线性表的第i个位置插入新的元素，`ListDelete`用来在链式线性表中删除第i个元素。在主函数中，通过调用以上接口函数来实现对链式线性表的操作。

### 回答3：
链式线性表是一种常用的数据结构，可以通过C结构体或C的“类”来实现。下面是6个接口函数的实现：

1. CreateList：该函数用于创建链式线性表。可以通过分配一个结构体来表示链表的节点，包含数据域和指向下一个节点的指针。函数会根据输入的数据，逐个创建节点，并将节点按照顺序连接起来。

2. ListPrint：该函数用于打印链式线性表的内容。从链表的起始节点开始，通过遍历每个节点，打印节点中的数据。

3. GetElem：该函数用于获取链式线性表中指定位置的元素。从链表的起始节点开始，通过遍历每个节点，直到找到指定位置的节点，并返回该节点中的数据。

4. ListLength：该函数用于获取链式线性表的长度。从链表的起始节点开始，通过遍历每个节点，计数器加一，直到遍历完整个链表。最后返回计数器的值。

5. ListInsert：该函数用于在链式线性表中指定位置插入一个元素。首先需要创建一个新的节点，并将要插入的数据存储在该节点中。然后找到要插入位置的前一个节点，修改前一个节点的指针，使其指向新节点，新节点的指针指向原来的后一个节点。

6. ListDelete：该函数用于删除链式线性表中指定位置的元素。首先需要找到要删除位置的前一个节点和要删除的节点。然后修改前一个节点的指针，使其指向要删除节点的后一个节点，释放要删除节点的内存空间。

通过以上6个接口函数的实现，就可以完整操作链式线性表，包括创建、打印、获取元素、获取长度、插入元素和删除元素。