编写C语言程序，定义字符指针变量p，实现输入一个字符串，按相反次序输出其中的所有字符。

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

int main() {
    char str[100];
    char *p;
    printf("请输入一个字符串：");
    gets(str);  // 推荐使用fgets(str, 100, stdin)替代
    p = str + strlen(str) - 1;  // 指向字符串最后一个字符
    printf("相反次序输出：");
    while (p >= str) {
        printf("%c", *p);
        p--;
    }
    printf("\n");
    return 0;
}

这里使用了指针来实现字符串的反转输出。首先，定义一个字符数组 `str`，用于存储输入的字符串。然后定义一个字符指针 `p`，指向字符串 `str` 的最后一个字符。接着，通过 `while` 循环遍历字符串，从最后一个字符开始输出，直到遍历到字符串的第一个字符。在循环内部，使用 `printf` 函数输出指针 `p` 指向的字符，然后将指针 `p` 向前移动一个位置，以便输出下一个字符。最后，输出一个换行符，结束程序的执行。

相关问题

从键盘读入一个字符串，把它存入一个链表（每个结点存储1个字符），并按相反的次序将字符串输出到显示屏。

### 回答1：
首先，需要定义一个链表结构体，每个结点存储一个字符和指向下一个结点的指针。

然后，从键盘读入一个字符串，逐个字符创建链表结点，并将其插入链表的头部。

最后，遍历链表，按相反的次序输出每个结点存储的字符到显示屏。

具体实现可以参考以下代码：

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

// 链表结构体
typedef struct node {
    char data;          // 存储的字符
    struct node* next;  // 指向下一个结点的指针
} Node;

int main() {
    char str[100];      // 存储输入的字符串
    Node* head = NULL;  // 链表头指针

    // 从键盘读入一个字符串
    printf("请输入一个字符串：");
    scanf("%s", str);

    // 逐个字符创建链表结点，并将其插入链表头部
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->data = str[i];
        node->next = head;
        head = node;
    }

    // 遍历链表，按相反的次序输出每个结点存储的字符到显示屏
    printf("相反的次序输出字符串：");
    Node* p = head;
    while (p != NULL) {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");

    // 释放链表结点的内存
    p = head;
    while (p != NULL) {
        Node* q = p;
        p = p->next;
        free(q);
    }

    return 0;
}

### 回答2：
首先，在C语言中可以使用结构体来实现链表。结构体中可以包含一个字符型变量和一个指针变量，指向下一个结点。定义一个结构体Node如下：

typedef struct Node{
    char c;
    struct Node *next;
}Node;

现在，我们可以开始实现将字符串存入链表的程序了。算法思路可以如下：

1. 读入字符串。
2. 新建一个头结点，将第一个字符存入头结点中。
3. 循环读入字符串中的每个字符，新建一个结点，将字符存入结点中。将新结点插入到链表中。
4. 最终得到一个包含所有字符的链表。

代码如下：

int main(){
    char str[100];
    printf("请输入字符串:");
    scanf("%s",str);

    Node *head = (Node*)malloc(sizeof(Node));
    head -> c = str[0];
    head -> next = NULL;

    int len = strlen(str);
    for(int i=1; i<len; i++){
        Node *p = (Node*)malloc(sizeof(Node));
        p -> c = str[i];
        p -> next = head;
        head = p;
    }

    // 遍历链表并输出
    Node *p = head;
    while(p){
        printf("%c",p->c);
        p = p->next;
    }

    return 0;
}

在程序中，我们从第二个字符开始循环读入，建立新结点并将新结点插入到链表的头部。最后得到的head就是整个链表的头结点。遍历链表并输出时，按照相反的次序输出即可。

### 回答3：
题目要求将键盘输入的字符串存储到链表中，然后按相反的顺序输出到显示屏上。这个问题可以通过以下步骤解决：

步骤一：定义链表结构体

首先要定义一个链表结构体来存储字符串，每个结点存储1个字符。链表结构体可以定义如下：

struct ListNode{
char data;
ListNode* next;
};

步骤二：读取输入的字符串并存储到链表中

程序可以通过循环方式读取键盘输入的字符，并将每一个字符存储到链表中，可以使用以下代码实现：

ListNode* head = NULL; //链表头结点指针
ListNode* p = NULL; //链表指针
char c; //读取的字符
while((c = getchar()) != '\n'){
ListNode* node = new ListNode;
node->data = c;
node->next = NULL;
if(head == NULL){ //如果是第一个元素，则将其作为头结点
head = node;
p = head;
}
else{ //将结点加入链表末尾
p->next = node;
p = p->next;
}
}

步骤三：按相反的顺序输出链表

输出链表时，可以使用递归的方式来遍历整个链表。具体来说，递归函数可以按逆序输出链表，然后输出当前结点。如下所示：

void reversePrint(ListNode* p){
if(p != NULL){
reversePrint(p->next);
putchar(p->data);
}
}

步骤四：完整代码

以下是完整的代码：

#include<iostream>
using namespace std;

struct ListNode{
char data;
ListNode* next;
};

void reversePrint(ListNode* p){
if(p!=NULL){
reversePrint(p->next);
putchar(p->data);
}
}

int main(){
ListNode* head = NULL;
ListNode* p = NULL;
char c;
while((c=getchar())!='\n'){
ListNode* node = new ListNode;
node->data = c;
node->next = NULL;
if(head == NULL){
head = node;
p = head;
}
else{
p->next = node;
p = p->next;
}
}
reversePrint(head);
return 0;
}

上述代码可以读取任意长度的字符串并逆序输出到屏幕上。注意在使用链表时一定要记得释放内存。