用c++写一个位数反转的程序 如反转数字是零 则舍去

以下是用 C 语言编写的位数反转程序：

#include <stdio.h>

int main() {
    int num, reversed_num = 0;
    printf("请输入一个正整数：");
    scanf("%d", &num);

    while (num) {
        int digit = num % 10;
        if (digit != 0) {
            reversed_num = reversed_num * 10 + digit;
        }
        num /= 10;
    }

    printf("反转后的数字为：%d\n", reversed_num);
    return 0;
}

程序首先提示用户输入一个正整数，然后使用 while 循环逐位反转该数字。在每次循环中，取出数字的个位数 digit，如果 digit 不是零，则将其添加到反转后的数字 reversed_num 的末尾。最后输出反转后的数字。

例如，如果输入 1230450，则程序会输出 54321。

相关问题

用c++写一个反转链表的程序

以下是一个反转链表的C程序：

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

typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

ListNode* reverseList(ListNode* head) {
    ListNode *prev = NULL, *curr = head, *next = NULL;
    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

void printList(ListNode* head) {
    while (head != NULL) {
        printf("%d ", head->val);
        head = head->next;
    }
    printf("\n");
}

int main() {
    ListNode *head = (ListNode*)malloc(sizeof(ListNode));
    head->val = 1;
    head->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->val = 2;
    head->next->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->next->val = 3;
    head->next->next->next = NULL;

    printf("Original list: ");
    printList(head);

    head = reverseList(head);

    printf("Reversed list: ");
    printList(head);

    return 0;
}

在这个程序中，我们定义了一个链表节点结构体`ListNode`，并定义了一个函数`reverseList`，它接受一个链表头结点指针作为参数，并返回反转后的链表头结点指针。我们还定义了一个函数`printList`，它接受一个链表头结点指针作为参数，并打印出链表中所有节点的值。

在`reverseList`函数中，我们定义了三个指针变量`prev`、`curr`和`next`，用来保存当前节点、前一个节点和后一个节点。我们使用一个while循环遍历整个链表，每次将当前节点的下一个节点保存到`next`指针中，然后将当前节点的`next`指向前一个节点，最后将`prev`指针指向当前节点，`curr`指针指向`next`节点。当遍历完成后，`prev`指向的就是反转后的链表头结点，我们将它返回即可。

在`main`函数中，我们创建了一个包含三个节点的链表，并打印出原始链表和反转后的链表。

用c++写一个反转链表

以下是使用C++实现反转一个单向链表的代码：

#include <iostream>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode* reverseList(ListNode* head) {
    ListNode* prev = NULL;
    ListNode* curr = head;
    while (curr != NULL) {
        ListNode* next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

int main() {
    // 创建链表 1 -> 2 -> 3 -> 4 -> 5
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(5);

    // 反转链表
    ListNode* newHead = reverseList(head);

    // 输出反转后的链表
    while (newHead != NULL) {
        cout << newHead->val << " ";
        newHead = newHead->next;
    }
    cout << endl;

    return 0;
}

在上面的代码中，我们首先定义了一个链表节点的结构体 `ListNode`，包括一个值域 `val` 和一个指向下一个节点的指针 `next`。然后，我们定义了一个 `reverseList()` 函数来反转链表。函数中使用了三个指针，分别为 `prev`、`curr` 和 `next`，其中 `prev` 表示当前节点的前一个节点，`curr` 表示当前节点，`next` 表示当前节点的下一个节点。

在 `while` 循环中，我们首先将 `curr` 的下一个节点保存到 `next` 中，然后将 `curr` 的 `next` 指针指向 `prev`，最后将 `prev` 指向 `curr`，`curr` 指向 `next`。这样，我们就完成了一次节点的反转。循环直到 `curr` 为 `NULL`，即链表处理完毕，返回 `prev`，即为反转后的头节点。

在 `main()` 函数中，我们创建了一个链表 `1 -> 2 -> 3 -> 4 -> 5`，然后调用 `reverseList()` 函数来反转链表。最后，我们输出反转后的链表。输出结果为 `5 4 3 2 1`。