从键盘依次输入10个整数，按输入顺序进行逆序输出在c语言

实现这个功能的 C 语言代码如下：

#include <stdio.h>

int main() {
    int nums[10];
    int i;

    printf("请输入10个整数：\n");

    // 读入10个整数
    for (i = 0; i < 10; i++) {
        scanf("%d", &nums[i]);
    }

    printf("逆序输出：");
    // 逆序输出
    for (i = 9; i >= 0; i--) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    return 0;
}

在程序中，首先定义了一个长度为10的整型数组 `nums`，用来存放输入的10个整数。然后使用 `for` 循环读入这10个整数，并按照输入顺序存储到数组中。

接着使用另一个 `for` 循环来逆序输出这10个整数，从 `nums[9]` 开始，一直输出到 `nums[0]`。最后输出一个换行符结束整个程序的执行。

相关问题

C语言 1. 数据结构和ACM2023-第三章-栈-创建堆栈 - LJD 【问题描述】 堆栈的基本操作 从键盘读入n个整数，依次放入堆栈中，之后再将整数从堆栈弹出并打印。 要求使用顺序栈 【输入形式】 整数个数n n个整数（以空格分隔） 【输出形式】 逆序输出堆栈的所有元素，输出元素的个数 【样例输入】 3 1 2 3 【样例输出】 3 2 1 3

下面是 C 语言的代码实现：

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

#define MAXSIZE 100

typedef struct {
    int data[MAXSIZE];
    int top;
} Stack;

void init(Stack *s) {
    s->top = -1;
}

int isEmpty(Stack *s) {
    return s->top == -1;
}

int isFull(Stack *s) {
    return s->top == MAXSIZE - 1;
}

void push(Stack *s, int x) {
    if (isFull(s)) {
        printf("Stack is full\n");
        exit(1);
    }
    s->data[++s->top] = x;
}

int pop(Stack *s) {
    if (isEmpty(s)) {
        printf("Stack is empty\n");
        exit(1);
    }
    return s->data[s->top--];
}

int main() {
    Stack s;
    int n, i, x;

    init(&s);
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        push(&s, x);
    }
    printf("%d ", n);
    while (!isEmpty(&s)) {
        printf("%d ", pop(&s));
    }
    printf("\n");

    return 0;
}

代码实现的思路是：先定义一个结构体 `Stack`，里面包含一个整型数组 `data` 和一个整型变量 `top`，表示栈顶元素在数组中的位置。然后定义一些基本操作，如初始化（`init`）、判断是否为空（`isEmpty`）、判断是否为满（`isFull`）、入栈（`push`）、出栈（`pop`）等。

在主函数中，先初始化堆栈，然后从键盘读入整数个数 `n`，依次将这些整数压入堆栈中。最后逆序输出堆栈的所有元素，并输出元素的个数 `n`。

先将键盘输入的一组整数依次存入单链表，然后删除其中的最大最小元素，最后将其余元素逆序输出。（写个c语言代码）

这是一个典型的链表操作问题，我们可以使用C语言编写如下代码来解决这个问题：

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

// 定义链表结构体
typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

// 创建新节点
ListNode* createNode(int val) {
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->val = val;
    newNode->next = NULL;
    return newNode;
}

// 比较大小并返回最大值
int findMax(ListNode* head) {
    int maxVal = INT_MIN;
    ListNode* current = head;
    while (current != NULL) {
        if (maxVal < current->val) {
            maxVal = current->val;
        }
        current = current->next;
    }
    return maxVal;
}

// 删除最大值节点
ListNode* deleteMax(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    
    ListNode* dummyHead = (ListNode*)malloc(sizeof(ListNode));
    dummyHead->next = head;
    
    ListNode* maxNode = head;
    ListNode* current = head->next;
    while (current != NULL && current->val > maxNode->val) {
        maxNode = current;
        current = current->next;
    }

    maxNode->next = maxNode->next->next;
    free(maxNode);
    return dummyHead->next;
}

// 删除最小值节点
ListNode* deleteMin(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }

    ListNode* minNode = head;
    ListNode* current = head->next;
    while (current != NULL && current->val < minNode->val) {
        minNode = current;
        current = current->next;
    }

    if (minNode != head) { // 如果最小值不是头结点
        minNode->next = minNode->next->next;
    } else { // 最小值是头结点，需要特殊处理
        ListNode* temp = head->next;
        free(head);
        head = temp;
    }
    return head;
}

// 逆序输出链表
void printReverse(ListNode* head) {
    ListNode* prev = NULL;
    ListNode* current = head;
    while (current != NULL) {
        ListNode* nextTemp = current->next;
        current->next = prev;
        prev = current;
        current = nextTemp;
    }
    head = prev; // 更新头指针
    while (head != NULL) {
        printf("%d ", head->val);
        head = head->next;
    }
    printf("\n");
}

// 主函数
int main() {
    int n;
    printf("Enter the number of elements: ");
    scanf("%d", &n);

    ListNode* list = NULL;
    for (int i = 0; i < n; i++) {
        int num;
        scanf("%d", &num);
        list = createNode(num);
        list->next = (list == NULL) ? NULL : list->next;
    }

    list = deleteMin(list); // 删除最小值
    list = deleteMax(list); // 删除最大值

    printf("Reversed list after deleting min and max: ");
    printReverse(list);

    return 0;
}

这个代码首先创建链表，接着删除最小值和最大值节点，最后逆序打印剩余元素。注意，此代码假设输入的整数都是非空的，并且不会修改原始输入顺序。