编写一个读入一个字符串，把它顺序存入一个顺序表，并按逆序打印的程序。

以下是 Python 语言的实现：

s = input("请输入字符串：")  # 读入一个字符串
lst = list(s)  # 将字符串转换为列表

print("顺序表存储的结果为：")
for item in lst:
    print(item, end=' ')
print()

print("逆序打印的结果为：")
for i in range(len(lst) - 1, -1, -1):
    print(lst[i], end=' ')
print()

这个程序首先读入一个字符串，然后将其转换为列表存储在顺序表中，依次输出顺序表中的元素，接着使用循环逆序遍历列表，输出逆序结果。

相关问题

编写一个读入一个字符串，把它顺序存入一个顺序表，并按逆序打印的程序。c

以下是一个基于 C 语言的实现示例：

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

#define MAX_SIZE 100

typedef struct {
    char data[MAX_SIZE];
    int length;
} SeqList;

void initList(SeqList *list) {
    list->length = 0;
}

void insert(SeqList *list, char element) {
    if (list->length == MAX_SIZE) {
        printf("List is full.\n");
        return;
    }
    list->data[list->length] = element;
    list->length++;
}

void reversePrint(SeqList *list) {
    for (int i = list->length - 1; i >= 0; i--) {
        printf("%c", list->data[i]);
    }
}

int main() {
    SeqList list;
    initList(&list);

    char input[MAX_SIZE];
    printf("Enter a string: ");
    scanf("%s", input);

    for (int i = 0; i < strlen(input); i++) {
        insert(&list, input[i]);
    }

    printf("Reversed string: ");
    reversePrint(&list);

    return 0;
}

首先，我们定义了一个顺序表的结构体 `SeqList`，其中包含了一个字符数组 `data` 和一个整数 `length`，用于存储顺序表中的元素和当前元素个数。然后，我们定义了一些操作顺序表的函数，如 `initList` 用于初始化顺序表，`insert` 用于在顺序表末尾插入元素，`reversePrint` 用于按逆序打印顺序表中的元素。

在 `main` 函数中，我们首先初始化顺序表 `list`，然后读入一个字符串 `input`，并将其顺序存入顺序表中。最后，我们调用 `reversePrint` 函数将顺序表中的元素按逆序打印出来。

注意，这个实现并没有对输入字符串的长度进行限制，因此可能会存在越界的风险。在实际使用中，应该根据具体情况对输入字符串的长度进行检查。

1、顺序表、单链和双向链表的定义字符串，初始化、插入和删除操作函数，并利用这些操作完成： 2、编写一个读入一个字符串，把它顺序存入一个顺序表，并按逆序打印的程序。（线性表） 3、编写一个读入一个字符串，把它顺序存入一个双向链表，并按逆序打印的程序。（线性表）4、写出主函数验证函数功能

顺序表的定义：

#define MaxSize 100
typedef struct{
    char data[MaxSize];
    int length;
}SqList;

单链表的定义：

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

双向链表的定义：

typedef struct DLNode{
    char data;
    struct DLNode *prior, *next;
}DLNode, *DLinkList;

顺序表的初始化：

void InitList(SqList &L){
    L.length = 0;
}

单链表的初始化：

void InitList(LinkList &L){
    L = (LNode*)malloc(sizeof(LNode));
    L->next = NULL;
}

双向链表的初始化：

void InitList(DLinkList &L){
    L = (DLNode*)malloc(sizeof(DLNode));
    L->prior = L->next = NULL;
}

顺序表的插入：

bool ListInsert(SqList &L, int i, char e){
    if(i < 1 || i > L.length+1) return false;
    if(L.length >= MaxSize) return false;
    for(int j = L.length; j >= i; j--){
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

单链表的插入：

bool ListInsert(LinkList &L, int i, char e){
    if(i < 1) return false;
    LNode *p;
    int j = 0;
    p = L;
    while(p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if(p == NULL) return false;
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

双向链表的插入：

bool ListInsert(DLinkList &L, int i, char e){
    if(i < 1) return false;
    DLNode *p;
    int j = 0;
    p = L;
    while(p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if(p == NULL) return false;
    DLNode *s = (DLNode*)malloc(sizeof(DLNode));
    s->data = e;
    s->next = p->next;
    s->prior = p;
    if(p->next != NULL) p->next->prior = s;
    p->next = s;
    return true;
}

顺序表的删除：

bool ListDelete(SqList &L, int i, char &e){
    if(i < 1 || i > L.length) return false;
    e = L.data[i-1];
    for(int j = i; j < L.length; j++){
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

单链表的删除：

bool ListDelete(LinkList &L, int i, char &e){
    if(i < 1) return false;
    LNode *p;
    int j = 0;
    p = L;
    while(p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if(p == NULL || p->next == NULL) return false;
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}

双向链表的删除：

bool ListDelete(DLinkList &L, int i, char &e){
    if(i < 1) return false;
    DLNode *p;
    int j = 0;
    p = L;
    while(p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if(p == NULL || p->next == NULL) return false;
    DLNode *q = p->next;
    e = q->data;
    p->next = q->next;
    if(q->next != NULL) q->next->prior = p;
    free(q);
    return true;
}

顺序表读入字符串并逆序打印：

void ReversePrint(SqList L){
    for(int i = L.length-1; i >= 0; i--){
        printf("%c", L.data[i]);
    }
}

双向链表读入字符串并逆序打印：

void ReversePrint(DLinkList L){
    DLNode *p = L->next;
    while(p != NULL){
        p = p->next;
    }
    while(p != L){
        printf("%c", p->data);
        p = p->prior;
    }
}

主函数：

int main(){
    //顺序表测试
    SqList L;
    InitList(L);
    char str[MaxSize];
    printf("请输入字符串：");
    scanf("%s", str);
    for(int i = 0; str[i] != '\0'; i++){
        ListInsert(L, i+1, str[i]);
    }
    printf("逆序输出：");
    ReversePrint(L);
    printf("\n");

    //双向链表测试
    DLinkList DL;
    InitList(DL);
    printf("请输入字符串：");
    scanf("%s", str);
    int len = strlen(str);
    for(int i = 0; i < len; i++){
        ListInsert(DL, i+1, str[i]);
    }
    printf("逆序输出：");
    ReversePrint(DL);
    printf("\n");

    return 0;
}