顺序表，单向链表双向链表的初始化，插入和删除操作函数怎么写

顺序表的初始化：

#define MAXSIZE 100 // 假设顺序表的最大长度为100
typedef struct {
    int data[MAXSIZE]; // 用数组存储数据元素
    int length; // 顺序表的当前长度
} SqList;

void InitList(SqList *L) {
    for(int i = 0; i < MAXSIZE; i++) {
        L->data[i] = 0; // 将所有元素初始化为0
    }
    L->length = 0; // 初始化长度为0
}

顺序表的插入操作：

bool InsertList(SqList *L, int i, int e) {
    if(i < 1 || i > L->length + 1) { // 判断插入位置是否合法
        return false;
    }
    if(L->length >= MAXSIZE) { // 判断顺序表是否已满
        return false;
    }
    for(int j = L->length; j >= i; j--) { // 将第i个元素及之后的元素后移
        L->data[j] = L->data[j-1];
    }
    L->data[i-1] = e; // 插入新元素
    L->length++; // 长度加1
    return true;
}

顺序表的删除操作：

bool DeleteList(SqList *L, int i) {
    if(i < 1 || i > L->length) { // 判断删除位置是否合法
        return false;
    }
    for(int j = i; j < L->length; j++) { // 将第i个元素之后的元素前移
        L->data[j-1] = L->data[j];
    }
    L->length--; // 长度减1
    return true;
}

单向链表的初始化：

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

void InitList(LinkList *L) {
    *L = (LinkList) malloc(sizeof(Node)); // 分配头结点空间
    (*L)->next = NULL; // 头结点指针域置为空
}

单向链表的插入操作：

bool InsertList(LinkList *L, int i, int e) {
    if(i < 1) { // 判断插入位置是否合法
        return false;
    }
    Node *p = *L;
    int j = 0;
    while(p && j < i-1) { // 查找第i-1个结点
        p = p->next;
        j++;
    }
    if(!p || j > i-1) { // 插入位置不合法
        return false;
    }
    Node *s = (Node*) malloc(sizeof(Node)); // 分配新结点空间
    s->data = e; // 插入新结点
    s->next = p->next;
    p->next = s;
    return true;
}

单向链表的删除操作：

bool DeleteList(LinkList *L, int i) {
    if(i < 1) { // 判断删除位置是否合法
        return false;
    }
    Node *p = *L;
    int j = 0;
    while(p->next && j < i-1) { // 查找第i-1个结点
        p = p->next;
        j++;
    }
    if(!(p->next) || j > i-1) { // 删除位置不合法
        return false;
    }
    Node *q = p->next; // 删除结点
    p->next = q->next;
    free(q);
    return true;
}

双向链表的初始化：

typedef struct DNode {
    int data;
    struct DNode *prior, *next;
} DNode, *DLinkList;

void InitList(DLinkList *L) {
    *L = (DLinkList) malloc(sizeof(DNode)); // 分配头结点空间
    (*L)->prior = NULL; // 头结点的前驱指针置为空
    (*L)->next = NULL; // 头结点的后继指针置为空
}

双向链表的插入操作：

bool InsertList(DLinkList *L, int i, int e) {
    if(i < 1) { // 判断插入位置是否合法
        return false;
    }
    DNode *p = *L;
    int j = 0;
    while(p && j < i-1) { // 查找第i-1个结点
        p = p->next;
        j++;
    }
    if(!p || j > i-1) { // 插入位置不合法
        return false;
    }
    DNode *s = (DNode*) malloc(sizeof(DNode)); // 分配新结点空间
    s->data = e; // 插入新结点
    s->prior = p;
    s->next = p->next;
    if(p->next) { // 如果p不是最后一个结点
        p->next->prior = s;
    }
    p->next = s;
    return true;
}

双向链表的删除操作：

bool DeleteList(DLinkList *L, int i) {
    if(i < 1) { // 判断删除位置是否合法
        return false;
    }
    DNode *p = *L;
    int j = 0;
    while(p->next && j < i-1) { // 查找第i-1个结点
        p = p->next;
        j++;
    }
    if(!(p->next) || j > i-1) { // 删除位置不合法
        return false;
    }
    DNode *q = p->next; // 删除结点
    if(q->next) { // 如果q不是最后一个结点
        q->next->prior = p;
    }
    p->next = q->next;
    free(q);
    return true;
}