在从 1 到 n 的正数中 1 出现的次数

本文探讨了两种计算整数范围内数字1出现次数的方法,一种是直接遍历每个数字进行计数,另一种是通过位操作高效计算。此外,还介绍了三种计算整数二进制表示中1的数量的方法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

输入一个整数 n,求从 1 到 n 这 n 个整数的十进制表示中 1 出现的次数。

例如输入 12,从 1 到 12 这些整数中包含 1  的数字有 1, 10, 1 1 和 12, 1 一共出现了 5 次

#include <stdio.h>
#include <stdlib.h>
  
int count1(int n);
int count2(int n);
  
int main(void)
{
  int x;
  
  printf("输入一个数:");
  scanf("%d",&x);
  printf("\n从0到%d一共遇到%d(%d)个1\n",x,count1(x),count2(x));
    
  return 0;
}
  
//解法一
int count1(int n)
{
  int count = 0;
  int i,t;
    
  //遍历1到n
  for(i=1;i<=n;i++)
  {
    t=i;
    //依次处理当前遍历到的数字的各个位
    while(t != 0)
    {
        //若为1则统计加一
      count += (t%10 == 1)?1:0;
      t/=10;
    }
  }
    
  return count;
}
  
//解法二:
int count2(int n)
{
  int count = 0;//统计变量
  int factor = 1;//分解因子
  int lower = 0;//当前处理位的所有低位
  int higher = 0;//当前处理位的所有高位
  int curr =0;//当前处理位
    
  while(n/factor != 0)
  {
    lower = n - n/factor*factor;//求得低位
    curr = (n/factor)%10;//求当前位
    higher = n/(factor*10);//求高位
      
    switch(curr)
    {
      case 0:
        count += higher * factor;
        break;
      case 1:
        count += higher * factor + lower + 1;
        break;
      default:
        count += (higher+1)*factor;
    }
      
    factor *= 10;
  }
    
  return count;
}



方法一就是从1开始遍历到N,将其中的每一个数中含有“1”的个数加起来,比较好想。

方法二比较有意思,核心思路是这样的:统计每一位上可能出现1的次数。

比如123:

个位出现1的数字:1,11,13,21,31,...,91,101,111,121

十位出现1的数字:10~19,110~119

百位出现1的数字:100~123

总结其中每位上1出现的规律即可得到方法二。其时间复杂度为O(Len),Len为数字长度

整数的二进制表示中 1 的个数
题目:整数的二进制表示中 1 的个数

要求:

输入一个整数,求该整数的二进制表达中有多少个 1。

例如输入 10,由于其二进制表示为 1010,有两个 1,因此输出 2。

分析:

解法一是普通处理方式,通过除二余二统计1的个数;

解法二与解法一类似,通过向右位移依次处理,每次与1按位与统计1的个数

解法三比较奇妙,每次将数字的最后一位处理成0,统计处理的次数,进而统计1的个数

代码实现(GCC编译通过):

#include <stdio.h>
#include <stdlib.h>
  
int count1(int x);
int count2(int x);
int count3(int x);
  
int main(void)
{
  int x;
  printf("输入一个数:\n");
  setbuf(stdin,NULL);
  scanf("%d",&x);
  printf("%d转二进制中1的个数是:",x);
  printf("\n解法一:%d",count1(x));
  printf("\n解法二:%d",count2(x));
  printf("\n解法三:%d",count3(x));
  printf("\n");
  return 0;
}
  
//除二、余二依次统计每位
int count1(int x)
{
  int c=0;
  while(x)
  {
    if(x%2==1)
      c++;
    x/=2;
  }
  return c;
}
  
//向右移位,与1按位与统计每位
int count2(int x)
{
  int c=0;
  while(x)
  {
    c+=x & 0x1;
    x>>=1;
  }
  return c;
}
  
//每次将最后一个1处理成0,统计处理次数
int count3(int x)
{
  int c=0;
  while(x)
  {
    x&=(x-1);
    c++;
  }
  return c;
}


<think>好的,用户问为什么冒泡排序的外层循环次数是n-1。我需要仔细分析这个问题。 首先,冒泡排序的基本原理是通过相邻元素的比较和交换,将较大的元素逐步移动到数组的末尾。每一次外层循环会把当前未排序部分的最大元素“冒泡”到正确的位置。 假设数组有n个元素。在第一次外层循环后,最大的元素已经排到了最后的位置,此时剩下的未排序元素是n-1个。接下来,第二次外层循环处理剩下的n-1个元素,把第二大的元素放到倒数第二的位置。依此类推,每完成一次外层循环,未排序的元素就减少一个。 那么,当进行到第n-1次外层循环时,剩下的未排序元素应该是2个,这时候只需要一次比较和可能的交换就能确定它们的顺序。此时,所有元素已经排好序了。因此,总共需要n-1次外层循环。 举个例子,比如当n=5时,外层循环次数是4次。第一次处理5个元素,剩下4个;第二次处理4个,剩下3个;第三次处理3个,剩下2个;第四次处理2个,排序完成。这时候所有元素已经有序,不需要第五次循环了。 另外,考虑到如果有n个元素,最多需要n-1次循环来确保所有元素归位。如果某一轮没有发生交换,说明已经有序,可以提前终止循环,但最坏情况下仍需n-1次。参考文献中提到的冒泡排序实现也使用了外层循环次数为n-1的情况,比如引用[4]中的Java代码,外层循环变量i的范围是0到nums.length-2,即循环n-1次[^4]。 因此,结论是:外层循环次数为n-1次,因为每次循环确保一个元素归位,而最后一个元素无需单独处理,自然已在正确位置。</think>### 冒泡排序外层循环次数为$n-1$的原因 #### 核心逻辑分析 1. **元素归位机制** 冒泡排序每一轮外层循环会将一个最大元素移动到最终位置。例如: - 第1轮:将第1大的元素移动到倒数第1位 - 第2轮:将第2大的元素移动到倒数第2位 - ... - 第$n-1$轮:将第$n-1$大的元素移动到正数第2位 此时最后一个元素(第$n$大)无需比较,自然已在正确位置[^4]。 2. **数学归纳法验证** 对于长度为$n$的数组: - 当$n=2$时,需要1次外层循环($2-1=1$) - 当$n=3$时,需要2次外层循环($3-1=2$) - 推广到一般情况,$n$个元素需要$n-1$次外层循环 推导公式: $$\sum_{i=1}^{n-1}(n-i) = \frac{n(n-1)}{2}$$ 这正是冒泡排序的比较次数公式[^3]。 #### 具体执行过程 ```java // 示例代码片段(引用自文献[4]) for (int i = 0; i < nums.length - 1; i++) { // 外层循环n-1次 for (int j = 0; j < nums.length - i - 1; j++) { // 比较相邻元素 } } ``` #### 优化情况补充 尽管标准实现需要$n-1$次循环,但通过设置标志位(如引用[3]中的`flag`变量),可以在数组提前有序时终止循环,此时实际循环次数可能小于$n-1$[^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值