利用C语言写一个程序，包含顺序表、单链和双向链表的定义，初始化、插入和删除操作函数，并利用这些操作完成:编写一个读入一个字符串，把它顺序存入一个顺序表，并按逆序打印的程序

下面是一个示例代码，实现了顺序表、单链表和双向链表的定义，以及初始化、插入和删除操作函数。并且根据题目要求，编写了一个读入一个字符串，把它顺序存入一个顺序表，并按逆序打印的程序。

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

// 定义顺序表
#define MAXSIZE 100
typedef struct {
    char data[MAXSIZE];
    int length;
} SqList;

// 定义单链表
typedef struct LNode {
    char data;
    struct LNode *next;
} LNode, *LinkList;

// 定义双向链表
typedef struct DNode {
    char data;
    struct DNode *prior, *next;
} DNode, *DLinkList;

// 初始化顺序表
void InitList_Sq(SqList *L) {
    L->length = 0;
}

// 插入元素到顺序表
void ListInsert_Sq(SqList *L, int i, char e) {
    if (i < 1 || i > L->length + 1) {
        printf("插入位置不合法！\n");
        return;
    }
    if (L->length >= MAXSIZE) {
        printf("顺序表已满！\n");
        return;
    }
    for (int j = L->length; j >= i; j--) {
        L->data[j] = L->data[j-1];
    }
    L->data[i-1] = e;
    L->length++;
}

// 删除顺序表中的元素
void ListDelete_Sq(SqList *L, int i) {
    if (i < 1 || i > L->length) {
        printf("删除位置不合法！\n");
        return;
    }
    for (int j = i; j < L->length; j++) {
        L->data[j-1] = L->data[j];
    }
    L->length--;
}

// 初始化单链表
void InitList_L(LinkList *L) {
    *L = (LNode*)malloc(sizeof(LNode));
    (*L)->next = NULL;
}

// 插入元素到单链表
void ListInsert_L(LinkList L, int i, char e) {
    LNode *p = L;
    int j = 0;
    while (p && j < i-1) {
        p = p->next;
        j++;
    }
    if (!p || j > i-1) {
        printf("插入位置不合法！\n");
        return;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
}

// 删除单链表中的元素
void ListDelete_L(LinkList L, int i) {
    LNode *p = L;
    int j = 0;
    while (p->next && j < i-1) {
        p = p->next;
        j++;
    }
    if (!p->next || j > i-1) {
        printf("删除位置不合法！\n");
        return;
    }
    LNode *q = p->next;
    p->next = q->next;
    free(q);
}

// 初始化双向链表
void InitList_DL(DLinkList *L) {
    *L = (DNode*)malloc(sizeof(DNode));
    (*L)->prior = NULL;
    (*L)->next = NULL;
}

// 插入元素到双向链表
void ListInsert_DL(DLinkList L, int i, char e) {
    DNode *p = L;
    int j = 0;
    while (p && j < i-1) {
        p = p->next;
        j++;
    }
    if (!p || j > i-1) {
        printf("插入位置不合法！\n");
        return;
    }
    DNode *s = (DNode*)malloc(sizeof(DNode));
    s->data = e;
    s->prior = p;
    s->next = p->next;
    if (p->next) {
        p->next->prior = s;
    }
    p->next = s;
}

// 删除双向链表中的元素
void ListDelete_DL(DLinkList L, int i) {
    DNode *p = L;
    int j = 0;
    while (p->next && j < i-1) {
        p = p->next;
        j++;
    }
    if (!p->next || j > i-1) {
        printf("删除位置不合法！\n");
        return;
    }
    DNode *q = p->next;
    p->next = q->next;
    if (q->next) {
        q->next->prior = p;
    }
    free(q);
}

int main() {
    char str[MAXSIZE];
    printf("请输入一个字符串：");
    scanf("%s", str);

    SqList L1;
    InitList_Sq(&L1);
    for (int i = 0; i < strlen(str); i++) {
        ListInsert_Sq(&L1, i+1, str[i]);
    }
    printf("顺序表逆序输出：");
    for (int i = L1.length; i > 0; i--) {
        printf("%c", L1.data[i-1]);
    }
    printf("\n");

    LinkList L2;
    InitList_L(&L2);
    for (int i = 0; i < strlen(str); i++) {
        ListInsert_L(L2, i+1, str[i]);
    }
    printf("单链表逆序输出：");
    LNode *p = L2->next;
    while (p) {
        ListInsert_L(L2, 1, p->data);
        p = p->next;
    }
    p = L2->next;
    while (p) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");

    DLinkList L3;
    InitList_DL(&L3);
    for (int i = 0; i < strlen(str); i++) {
        ListInsert_DL(L3, i+1, str[i]);
    }
    printf("双向链表逆序输出：");
    DNode *q = L3->next;
    while (q) {
        ListInsert_DL(L3, 1, q->data);
        q = q->next;
    }
    q = L3->next;
    while (q) {
        printf("%c", q->data);
        q = q->next;
    }
    printf("\n");

    return 0;
}

注意，这里的顺序表、单链表和双向链表的实现仅供参考，具体实现方式可能有所不同，需要根据实际情况进行调整。另外，这里只是针对题目要求编写了一个读入一个字符串，把它顺序存入一个顺序表，并按逆序打印的程序，如果需要实现其他功能，还需要进行相应的修改。