c语言指针程序设计判断一个数是否是回文数,C语言中判断一个数是否是回文数...

最新推荐文章于 2023-02-04 19:41:15 发布

转载最新推荐文章于 2023-02-04 19:41:15 发布 · 1.1k 阅读

文章标签：

#c语言指针程序设计判断一个数是否是回文数

注：回文数即数字顺着和反着是同一个数！

看了郝斌老师的C语言视频，虽然还只看了80多个，但是还是有一些体会，编程应该养成良好的编程风格，至少到现在为止写的这些小程序都应该有下面这样一个过程：

1，流程；(知道程序是按照怎样的顺序运行的)

2，功能；(理解程序的作用)

3，试数；(我个人简单的理解为测试过程，把自己当作计算机去执行程序)

2012年4月20日 10:36:23

判断一个数是否是回文数

#include

int main(void)

{

int val; //存放待判断的数据

int m;

int sum = 0;

printf("请输入您需要判断的数字：\n");

scanf("%d",&val);

m = val;

/*这一块是核心代码块：

由sum 不断的从输入的数中获取各位、十位、百位……为了得到反数，需要*10并加上下一位作为个位

sum每更新一次，m值去掉最后一位同时更新

while (m)

{

sum = sum*10 + m%10;

m /= 10;

}

if (sum == val)

printf("Yes!\n");

else

printf("No!\n");

return 0;

}

试数过程(纯粹的体力活)

判断是否是回文数的试数过程

这里只测试核心块

1234

1 -> m = val = 1234; sum = 0 + 1234%10 = 4; m = 1234/10 =123;

2 -> m = 123; sum = 40 + 123%10 = 40+3 = 43; m = 123/10 = 12;

3 -> m = 12; sum = 430 + 12%10 = 432; m = 12/10 = 1;

4 -> m = 1; sum = 4320 + 1%10 = 4321; m = 1/10 = 0;

false

12321

1 -> m = val = 12321; sum = 0 + 12321%10 = 1; m = 12321/10 = 1232;

2 -> m = 1232; sum = 10 + 1232%10 = 12; m = 1232/10 = 123;

3 -> m = 123; sum = 120 + 123%10 = 123; m = 123/10 = 12;

4 -> m = 12; sum = 1230 + 12%10 = 1232; m = 12/10 = 1;

5 -> m = 1; sum = 12320 + 1%10 = 12321; m = 1/10 = 0;

false

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

清明梦境

关注关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

C/C++ 判断一个数是否是回文数Palindrome算法详解及源码

希望我的博客，能帮上你解决学习中工作中所遇到的问题

06-28

2480

回文数是指正序和倒序都相同的整数。算法的优点是简单直观，时间复杂度为O(n)，其中n为整数转换后的字符串长度。算法的优点是简单直观，时间复杂度为O(n)，其中n为整数转换后的字符串长度。算法的优点是简单直观，时间复杂度为O(n)，其中n为整数转换后的字符串长度。算法的优点是简单直观，时间复杂度为O(n)，其中n为整数转换后的字符串长度。算法的缺点是需要将整数转换为字符串，开销较大，可能会占用较多的内存空间。算法的缺点是需要将整数转换为字符串，开销较大，可能会占用较多的内存空间。

C语言任意输入一个数，判断该数是否为回文数（两种方法）

qq_3203700**的博客

07-02

2843

int huiwei(char* p) { int i; int len = strlen(p); for (i = 0; i

参与评论您还未登录，请先登录后发表或查看评论

C 语言指针实现字符串是否为回文

11-07

C语言用指针方式实现任意给定字符串的回文判定。

【C语言】判断一个数是不是回文数

最新发布

04-01

好的，用户之前已经问过关于C语言的介绍以及回文数判断的问题，现在他再次询问C语言如何判断回文数。我需要先回顾之前的回答，确保这次的内容不重复并且更详细。首先，用户可能已经看过之前的两种方法：数学反转和...

（C）通过指针判断回文

qq_53201950的博客

02-04

322

指针

判断一个数 是否是回文数 C语言代码!

T3rdw的专栏

08-04

1716

#include int main(void) { int val, m; int sum = 0; printf("请输入一个要判断的数字:\n"); scanf("%d",&val); m = val; while(m) { sum = sum * 10 + m%10; m /= 10; } if(sum == val) printf("YES!\n")

用c语言判断一个数是否是回文数

sanjunsheng的专栏

03-24

2176

今天去面试碰到这个笔试题目，c语言编程实现，没写出来，估计悲剧了，记录下来，以免再错。 回文数是一种神奇的数字，倒序后仍是原来的数字。比如12321，倒过来还是12321，再如33. 我在网上找到一个相对容易理解实现且有效的算法。就是将数逆转后和原来的值比较就可以了。经过验证应该是可以的。

C语言：判断一个数是不是回文数

aCHANQAQ的博客

07-07

2617

设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数。#include int main(int argc,const char* argv[]) { int num = 0,new = 0; printf("请输入一个正整数:"); scanf("%d",&num); int copy = num; while(0 < num) { new = ne...

用C语言判断一个数是否为回文数

HKpeng的学习记录

11-29

3445

输入一个数值判断是否为回文数（回文数是指一个像14641这样对称的数，即：这个数的数字按相反的顺序重新排列后，所得到的数和原来的数一样） #include<stdio.h> int main(void) { int i; int number; int sum = 0; printf("请输入您需要判断的数：“)； scanf("%d", &number); i ...

C语言——判断一个数是不是回文数（对称数）

泥菩萨会发光的小窝

10-07

9132

使用C语言判断某一个数是否是回文数（对称数），此次为个人练习，若有错误敬请提出。首先，我们需要知道回文数就是对称数，例如：12321是回文数（对称数），124421是回文数（对称数），1231不是回文数（对称数）。判断原理为：原整型数依次取余，将所得余数构造成一个新整型数，判断新整型数与原整型数是否一致。若一致，则该整型数是回文数，若不一致，则该整型数不是回文数。要求:输入一个整型数，判断是否是对称数，如果是，输出yes，否则输出no，不用考虑这个整型数过大，int类型存不下，不用考虑负值。

判断一个数字是否是回文数用C语言实现

02-25

<think>嗯，用户现在让我用C语言实现判断一个数字是否是回文数。首先，我需要确认回文数的定义。回文数指的是一个数正读和反读都一样的数字，比如121或者1331这样的数。那么，如何用C语言来实现这个功能呢？用户之前问过关于指针函数的问题，现在转向算法问题，可能是在学习编程基础，或者正在准备面试题。不管怎样，我需要提供一个清晰且高效的解决方案。首先，我得考虑输入的类型。题目说是“数字”，通常指的是整数。假设输入是一个整数，比如n。负数的情况需要考虑吗？比如-121，反读是121-，显然不是回文数。所以可能先处理负数的情况，直接返回false。接下来，基本的思路是将数字反转，然后比较反转后的数字是否与原数字相等。但需要注意反转可能导致整数溢出的问题，不过题目可能假设输入的数值在合理范围内，或者用其他方式处理。比如，对于int类型的数字，当反转后的数超过INT_MAX时可能溢出，但如果是回文数的话，反转后的数应该与原数相等，所以可能不会溢出。或者，可以只反转一半的数字，这样可以避免溢出问题。比如，对于数字1221，反转后半部分21得到12，前半部分是12，两者相等，所以是回文数。这种方法更高效，因为只需要处理一半的数字。不过，这样的实现需要考虑数字的位数是奇数还是偶数的情况。例如，12321这样的数，反转后得到后半部分123的前两位，而前半部分是12，中间的数可以忽略。那么，具体步骤可能是： 1. 处理特殊情况： - 如果数字是负数，直接返回false。 - 如果数字非零且以0结尾，比如120，因为反转后不可能以0开头，除非数字本身就是0，所以这种情况下也返回false。 2. 反转一半的数字： - 初始化反转后的数为0。 - 当原数字大于反转后的数字时，继续反转。例如，原数字是1221，反转后的数字逐步变为1，12，此时原数字变成12，反转后的数字是12，停止循环。 - 比较反转后的数字和原数字的前半部分，或者处理奇偶位数的情况。比如，对于原数字1221，反转后的部分是12，原数字剩下的也是12，相等，返回true。如果是12321，反转后的部分是123，原数字剩下的12，这时候需要将反转后的数除以10，得到12，与原数字剩下的12比较，相等则为回文。这样的话，可以避免处理整个数字的反转，减少计算量，同时避免溢出的可能。那如何实现这个反转过程呢？在每次循环中，取出原数字的最后一位，加到反转数的末尾，然后原数字除以10去掉最后一位。例如：原数字=1221，反转数=0 第一次循环：取出1，反转数=0*10 +1=1，原数字变为122 第二次循环：取出2，反转数=1*10+2=12，原数字变为12 此时原数字12不再大于反转数12，停止循环。然后，如果数字的位数是偶数（比如1221有4位），原数字等于反转数则是回文；如果是奇数位（如12321），原数字除以10后等于反转数除以10，也就是比较12和12。这样，代码的大致结构是： bool isPalindrome(int x) { if (x < 0 || (x % 10 == 0 && x != 0)) { return false; } int reverted = 0; while (x > reverted) { reverted = reverted * 10 + x % 10; x /= 10; } return x == reverted || x == reverted / 10; } 不过，用户可能希望的是用C语言实现，而C语言中的布尔类型需要包含stdbool.h，或者用整数代替。此外，处理输入为0的情况，比如x=0，应该返回true。测试一下这个逻辑是否正确：测试用例1：x=121，反转过程： x=121，reverted=0 → 进入循环第一次循环：reverted=0*10 +1=1，x=12 → x > reverted（12>1）第二次循环：reverted=1*10+2=12，x=1 → 现在x=1 < reverted=12，退出循环。此时x=1，reverted=12。判断x == reverted/10 → 12/10=1，所以成立，返回true。测试用例2：x=1221：循环两次后，x=12，reverted=12 → 退出循环，x==reverted，返回true。测试用例3：x=12321：循环三次：第一次：reverted=1，x=1232 第二次：reverted=12，x=123 第三次：reverted=123，x=12 → 此时x=12 < reverted=123，退出循环。判断x=12，reverted=123 → 123/10=12，所以x == 12，返回true。测试负数：x=-121 → 直接返回false。测试末尾为0的非零数：x=10 → 返回false。看起来逻辑是正确的。那接下来需要将这个思路用C语言编写出来，注意函数返回类型，以及处理特殊情况。另外，用户可能需要完整的代码示例，包括主函数来测试。所以可能需要提供一个完整的程序，或者至少一个函数。总结步骤： 1. 检查x是否为负数，或者非零但末尾为0的数，返回false。 2. 反转后半部分数字，直到x小于或等于reverted。 3. 比较x和reverted（偶数位情况）或者x和reverted/10（奇数位情况）。现在，编写代码时需要注意数据类型的范围。例如，当输入的x是很大的数，反转可能导致中间值溢出，但根据上面的方法，反转的是后半部分，所以当x是回文数时，反转后的数不会超过原来的数的一半，所以不会溢出。例如，最大的32位整数是2147483647，如果是回文数的话，反转后的部分可能在处理到一半的时候就满足条件了，所以不会溢出。但如果输入不是回文数，可能反转后的数会超过int的范围吗？例如，x=1999999999，反转后的数会很大，但在此方法中，循环会在x<=reverted时停止，可能不会溢出？例如，假设x=1999999999，原数是1999999999。反转过程：初始reverted=0 循环： reverted = 0*10 +9=9 → x=199999999 reverted=9*10 +9=99 → x=19999999 继续循环直到reverted超过x。可能需要测试这种情况是否会溢出，但在C语言中，int通常是32位的，所以当反转后的数超过INT_MAX时，会导致溢出，结果是未定义的。因此，这种方法在输入非常大的非回文数时可能存在问题。不过，题目假设输入是一个回文数的话，反转后的部分不会超过原数的一半，因此不会溢出。例如，对于最大的回文数，比如2147447412，反转到后半部分的时候，可能会正确。但如果是非回文数，比如1234567899，反转后的部分可能超过INT_MAX，导致溢出。例如，反转后的数可能变成998765432，超过了INT_MAX（2147483647），导致溢出，变为负数或者其他错误的值，从而影响判断。因此，这种方法在某些情况下可能有溢出的风险。但题目可能假设输入是有效的，或者题目中的测试用例不会导致这种情况。或者，可以限制输入的范围，或者使用更大的数据类型，比如long long来存储反转后的数。或者，改进算法，使用另一种方法，比如将数字转换为字符串，然后比较首尾字符。但这样需要额外的空间，但对于大数可能更安全。但用户要求的是用C语言实现，转换为字符串可能需要动态分配内存，或者使用固定大小的数组，但需要考虑数字的长度。例如，32位整数最多有10位数字（-2147483648），所以可以定义一个足够大的字符数组，比如12个字符（包括符号和结尾的'\0'）。这种方法的具体步骤是： 1. 处理特殊情况：x <0，返回false。 2. 将x转换为字符串。 3. 使用双指针法比较首尾字符是否相等，直到中间相遇。例如： bool isPalindrome(int x) { if (x < 0) return false; char str[12]; // 足够存放32位整数 sprintf(str, "%d", x); int left = 0; int right = strlen(str) - 1; while (left < right) { if (str[left] != str[right]) return false; left++; right--; } return true; } 这种方法比较直观，但需要处理字符串转换，可能效率稍低，但避免了反转数字时的溢出问题，并且代码更易读。对于面试题或练习题来说，两种方法都是可行的，但通常反转一半数字的方法更高效，空间复杂度为O(1)，而字符串转换需要O(n)的空间。用户可能希望的是更高效的解决方案，即反转一半数字的方法。那么，在C语言中，可能需要处理数据类型的问题。例如，用int可能会溢出，但如果输入的x是合法的回文数，则反转后的部分不会溢出，因为回文数的前半部分和后半部分是镜像的，所以反转后的数不会超过原数的一半，从而避免溢出。例如，x=123321，反转后半部分得到123，原数前半部分是123，此时反转数等于前半部分，返回true。对于x=2147447412，反转后的数后半部分是21474，原数前半部分是21474，相等。因此，反转一半的方法在正确的情况下不会溢出。但对于非回文数，比如x=1999999999，反转过程中可能会溢出。例如，当反转到后半部分时，原数变为199999，反转后的数可能为99991，此时继续循环，原数变为19999，反转后的数变为99991*10 +9=999919，此时可能已经溢出int的范围，导致错误。所以，这种方法在C语言中可能存在潜在的溢出问题。因此，使用更大的数据类型来存储反转后的数可能更安全，比如使用long类型。例如： bool isPalindrome(int x) { if (x < 0 || (x % 10 == 0 && x != 0)) { return false; } long reverted = 0; // 使用long防止溢出 int original = x; while (x > 0) { reverted = reverted * 10 + x % 10; x /= 10; } return original == reverted; } 这样，完全反转整个数字，但使用long来避免溢出。比如，对于x=12321，反转后的reverted是12321，与原数相等。而x=2147483647，反转后的数是7463847412，如果long是64位的，可以存储这个数，然后比较是否与原数相等。但原数x是int类型，此时原数x=2147483647，反转后的数远大于int的范围，所以原数不可能等于反转后的数，因此返回false，正确判断为非回文数。但这种方法需要反转整个数字，而之前的方法只反转一半，可能更高效。不过，当反转整个数字时，即使用long类型，也可能在64位系统下处理更大的数，但题目可能假设输入是32位整数。但用户的问题可能希望用更高效的反转一半的方法。所以需要权衡这两种方法。回到原来的思路，反转一半的方法，在C语言中如何避免溢出？例如，在反转过程中，当反转后的数超过INT_MAX/10时，下一次乘以10加上余数可能会溢出。但这种情况只有当原数不是回文数时才会发生。例如，x=1999999999，当反转后的数达到某个值时，继续乘以10会导致溢出，从而得到错误的值。但反转后的数如果超过了原数的前半部分，循环会提前终止吗？例如，x=1999999999，反转后的数初始为0：循环开始： x=1999999999，reverted=0 → 进入循环 reverted=0*10+9=9 → x=1999999999/10=199999999 继续循环： reverted=9*10 +9=99 → x=19999999 ... 直到反转后的数超过x时停止。假设在这种情况下，反转后的数可能已经溢出，导致错误的值。例如，当反转后的数在过程中超过了INT_MAX，结果可能变为负数，这样循环条件x > reverted可能仍然成立，导致无限循环或错误判断。因此，这种方法在C语言中使用int类型可能存在风险。因此，更安全的做法是使用long类型来存储反转后的数，即使反转整个数字。但用户的问题可能需要比较高效的解决方案，而反转一半的方法在正确的情况下不会溢出，所以可能还是采用原来的方法，但需要处理溢出问题。或者，可以添加一个检查，在每次反转时判断是否会导致溢出，例如：在反转的每一步中，检查reverted是否超过INT_MAX/10，或者在乘以10并加上余数后是否超过INT_MAX。如果会溢出，则说明原数不可能是回文数，可以提前返回false。例如： int reverted = 0; while (x > reverted) { int pop = x % 10; if (reverted > INT_MAX/10 || (reverted == INT_MAX/10 && pop > 7)) { // 假设INT_MAX是2147483647 return false; // 溢出，无法成为回文 } reverted = reverted * 10 + pop; x /= 10; } 这样可以在反转过程中检查溢出，如果溢出则直接返回false，因为原数x是正数，而反转后的数已经超过了int的范围，所以原数不可能是回文数。但这样增加了额外的检查步骤，可能让代码稍微复杂一些。不过，根据LeetCode上类似题目的解法，反转一半的方法通常是可行的，并且考虑到回文数的特性，反转过程中不会溢出，因为回文数的反转数应该与原数相等，而原数本身是一个有效的int，所以反转后的数也应该在int范围内。如果反转后的数超过了int范围，那么原数肯定不是回文数，因此可以在溢出时直接返回false。所以，结合以上分析，最终的C语言实现可能如下： #include <stdio.h> #include <stdbool.h> bool isPalindrome(int x) { // 特殊情况处理 if (x < 0 || (x % 10 == 0 && x != 0)) { return false; } int reverted = 0; while (x > reverted) { reverted = reverted * 10 + x % 10; x /= 10; } // 当数字长度为偶数时，x == reverted // 当数字长度为奇数时，x == reverted / 10 return x == reverted || x == reverted / 10; } int main() { int num; printf("请输入一个整数: "); scanf("%d", &num); if (isPalindrome(num)) { printf("%d 是回文数。\n", num); } else { printf("%d 不是回文数。\n", num); } return 0; } 这样，代码处理了负数和末尾为0的非零数的情况，使用反转一半的方法，避免了完全反转可能导致的溢出问题，并且在循环中不会处理到可能溢出的情况，因为如果原数是回文数，反转后的数一定不会溢出。如果原数不是回文数，可能在反转过程中导致reverted超过x，从而提前终止循环，而返回false。例如，对于x=12321，反转后的reverted在循环中会变成123，而x变成12。此时循环停止，因为x（12）小于reverted（123）。然后比较x == reverted/10（123/10=12），相等，返回true。对于非回文数如12345，反转后的reverted会是5432，而x变成1，此时循环停止，比较不相等，返回false。需要注意的是，在C语言中使用stdbool.h头文件来支持bool类型，否则需要替换为int类型，返回1或0。总结，用户需要的C语言实现判断回文数的代码，应该采用反转一半数字的方法，处理特殊情况和避免溢出，确保代码正确高效。</think>以下是使用C语言判断一个数字是否为回文数的实现方法，包含详细注释和示例： ### 实现思路 1. **处理特殊情况**： - 负数直接返回`false`（如 -121）。 - 末尾为 0 的非零数直接返回`false`（如 10，反转后开头不能为 0）。 2. **反转数字的后半部分**： - 将数字的后半部分反转，直到反转部分的值大于或等于剩余的前半部分。 - 通过比较前半部分和反转后的后半部分（或后半部分除以 10）判断是否回文。 --- ### 代码实现 ```c #include <stdio.h> #include <stdbool.h> // 支持布尔类型 bool isPalindrome(int x) { // 负数和末尾为0的非零数直接返回false if (x < 0 || (x % 10 == 0 && x != 0)) { return false; } int reverted = 0; // 存储反转后的后半部分 while (x > reverted) { reverted = reverted * 10 + x % 10; // 取最后一位并追加到反转数 x /= 10; // 去掉原数的最后一位 } // 数字长度为偶数时：x == reverted // 数字长度为奇数时：x == reverted / 10（忽略中间位） return x == reverted || x == reverted / 10; } int main() { // 测试用例 int test_cases[] = {121, -121, 10, 12321, 123}; for (int i = 0; i < 5; i++) { if (isPalindrome(test_cases[i])) { printf("%d 是回文数\n", test_cases[i]); } else { printf("%d 不是回文数\n", test_cases[i]); } } return 0; } ``` ### 示例输出 ``` 121 是回文数 -121 不是回文数 10 不是回文数 12321 是回文数 123 不是回文数 ``` --- ### 关键点说明 1. **反转逻辑**： - **反转过程**：每次取原数的最后一位，追加到反转数的末尾。 - **终止条件**：当反转数大于或等于剩余原数时停止（避免完全反转，减少计算量）。 2. **奇偶位数处理**： - 若数字长度为偶数（如 1221），反转后的后半部分与原前半部分相等。 - 若为奇数（如 12321），反转后的后半部分除以 10 后与原前半部分相等（忽略中间位）。 3. **时间复杂度**：O(log n)（数字位数），空间复杂度：O(1)。 --- ### 适用场景 - 输入为 32 位整数（范围：-2³¹ ~ 2³¹-1）。 - 需高效判断回文数的场景（如算法题、数据校验）。