c语言指针程序设计判断一个数是否是回文数,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

<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)。 - 需高效判断回文数的场景(如算法题、据校验)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值