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

题目：

输入一个整数n，求从1 到n 这n 个整数的十进制表示中1 出现的次数。
例如输入12，从1 到12 这些整数中包含1 的数字有1，10，11 和12，1 一共出现了5 次。
注：这是一道广为流传的google 面试题。

 

思路一：

我们每次判断整数的个位数字是不是1。如果这个数字大于10，除以10 之后再判断个位数字是不是1。（对每一个数x，x先与10取余，然后判断x/10之后，是否为0，不为0则继续上述操作 复杂度为o(n) ）

 

代码如下：

[cpp]  view plain copy

1. /*-------------------------------- 
2. Copyright by yuucyf.    2011.08.18 
3. ----------------------------------*/  
4. #include "stdafx.h"  
5. #include <iostream>  
6. using namespace std;  
7.   
8. int ItemContain1Count(int nValue)  
9. {  
10.     int nNum = 0;  
11.     while (nValue)  
12.     {  
13.         if ((nValue % 10) == 0x1)  
14.         {  
15.             nNum++;  
16.         }  
17.   
18.         nValue /= 10;  
19.     }  
20.   
21.     return nNum;  
22. }  
23.   
24. int Sum(int n)  
25. {  
26.     if (n <= 0)  
27.         return 0;  
28.   
29.     int nSum = 0;  
30.     for (int i32I = 1; i32I <= n; i32I++)  
31.     {  
32.         nSum += ItemContain1Count(i32I);  
33.     }  
34.   
35.     return nSum;  
36. }  
37.   
38. int _tmain(int argc, _TCHAR* argv[])  
39. {  
40.     int i32N = 0, i32Num = 0;;  
41.     cout << "请输入整数N=";  
42.     cin >> i32N;  
43.     cout << "从1~" << i32N << "之间含有1的个数为：" << Sum(i32N) << endl;     
44.       
45.     return 0;  
46. }  

思路二：

思路一有一个非常明显的缺点就是每个数字都要计算1 在该数字中出现的次数，因此时间复杂度是O(n)。当输入的n 非常大的时候，需要大量的计算，运算效率很低。

我们用一个稍微大一点的数字21345作为例子来分析。我们把从1到21345的所有数字分成两段，即1-1235和1346-21345。先来看1346-21345中1出现的次数。1的出现分为两种情况：一种情况是1出现在最高位（万位）。从1到21345的数字中，1出现在10000-19999这10000个数字的万位中，一共出现了10000（10的4次方）次；另外一种情况是1出现在除了最高位之外的其他位中。例子中1346-21345，这20000个数字中后面四位中1出现的次数是2000次（2*1000，其中2的第一位的数值，1000是因为数字的后四位数字其中一位为1，其余的三位数字可以在0到9这10个数字任意选择，由排列组合可以得出总次数是2*1000）。

至于从1到1345的所有数字中1出现的次数，我们就可以用递归地求得了。这也是我们为什么要把1-21345分为1-1235和1346-21345两段的原因。因为把21345的最高位去掉就得到1345，便于我们采用递归的思路。

分析到这里还有一种特殊情况需要注意：前面我们举例子是最高位是一个比1大的数字，此时最高位1出现的次数10000（对五位数而言）。但如果最高位是1呢？比如输入12345，从10000到12345这些数字中，1在万位出现的次数就不是10000次，而是2346次了，也就是除去最高位数字之后剩下的数字再加上1。

使用递归21345 ，则需要对21345的每一个10进制位，进行递归计算。对万位，千位，百位，十位，个位 
       即首位不为0，则可以分别计算21345 1345 345 45 5     
      (1) 当首位最高位为1时，含有1的个数为 10000
       首位可以为0 ， 1 ，则后四位其中有1位为1的个数为 ，2* 10(3)*4 = 8000  合计18000       
        
     (2) 下面计算1345 
        首位为1，则为  346
        其余位为 （首位可以为0） 3 * 10(2) = 30  合计376    
     
     (3)下面计算345
         首位为1  10的2次方
         首位可以为(0 1 2) 等于3的情况，  3 * 2 *10  合计160
         剩下的循环即求300- 345 
         
     (4)下面计算45     
         首位为1， 10的1次方
         首位不计，首位可以取(0 1 2 3) 4 * 1  合计 14
      （5）下面计算5
         判断长度小于1，直接返回

 求1到n中任意进制的数的个数，递归公式如下：     
 总结对于任意的1到n，求所给定的字符c的个数   
  str = abcdefgh , len = strlen(abcdefgh)      
        (1)当首位等于*str = c时 ，Q(abcdefgh) = abcdefgh + 1 + (*str -'0')*(len -1)*10^(len -2) + Q(bcdefgh)
        (2)当首位为 *str > c 时 ，Q(abcdefgh) = 10^(m-1) + (*str - '0') * (len 1) *10^(len -2) + Q(bcdefgh)
        (3)当首位为 *str < c时，   Q(abcdefgh) =  (*str - '0') * (len -1) *10^(len -2) + Q(bcdefgh)

 

代码如下：

[cpp]  view plain copy

1. int NumberOf1(char * pStr, char* c) //c表示查找pStr中含有c字符的数字的个数   
2.  {  
3.     if(!pStr)  
4.         return 0 ;  
5.   
6.     int nLen = strlen(pStr) ;  
7.     if (nLen == 1)  
8.     {  
9.         if(*pStr >= *c)  
10.             return 1 ;  
11.         else  
12.             return 0 ;  
13.     }  
14.   
15.     if (*pStr == *c)    //当首位为c的时候    
16.     {  
17.         return strtoul(pStr+1, NULL, 10) + 1 + (*pStr - '0') * (nLen - 1) * (int)pow(10.0, (double)(nLen - 2)) + NumberOf1(pStr + 1, c);  
18.     }   
19.     else if (*pStr > *c)      
20.     {  
21.         return (int)pow(10.0, (double)nLen-1) + (nLen - 1) * (*pStr - '0') * (int)pow(10.0, (double)(nLen - 2))  + NumberOf1(pStr+1, c) ;   
22.     }  
23.     else  
24.     {  
25.         return (nLen - 1) * (*pStr - '0') * (int)pow(10.0, (double)(nLen - 2)) + NumberOf1(pStr+1, c) ;  
26.     }  
27.  }  

第二种算法的时间复杂度为：O(k), 其中K为常数，是pstr的长度.

http://blog.csdn.net/yuucyf/article/details/6698077