《剑指offer》算法题第九天

今日题目：

1. 整数中1出现的次数
2. 把数组排成最小的数
3. 丑数
4. 第一个只出现一次的字符位置

今天的题目相对比较难，特别是第1题和第3题很考验数学功底，下面我们一题一题来看看。

1.整数中1出现的次数

题目描述：
输入一个整数n，求1~n这n个整数的十进制表示中1出现的次数。例如，输入12,1~12这些整数中包含1的数字有1,10,11,和12,1一共出现了5次。

思路：
这道题分别有递归和迭代两种解法，第一次看见这个题目比较难想到，可参考：
递归：http://blog.csdn.net/gatieme/article/details/51292339

代码如下：

 //递归
 public class Solution {
     public int NumberOf1Between1AndN_Solution(int n) {
         if(n == 0) return 0;
         else if(n > 0 && n < 10) return 1;
         else{
             int high = n;
             int weight = 1;
             while(high >= 10){
                 high /= 10;
                 weight *= 10;
             }

             if(high == 1){
                 return NumberOf1Between1AndN_Solution(weight-1)+
                     NumberOf1Between1AndN_Solution(n-weight)+
                     (n - weight + 1);
             }else{
                 return high*NumberOf1Between1AndN_Solution(weight-1)+
                     NumberOf1Between1AndN_Solution(n - high*weight)+
                     weight;
             }

         }
     }
 }

 //迭代
 public class Solution {
     int NumberOf1Between1AndN_Solution(int n){
         int ones = 0;
         for (int m = 1; m <= n; m *= 10) {
             int a = n/m, b = n%m;
             if(a%10 == 0)
                 ones += a / 10 * m;
             else if(a%10 == 1)
                 ones += (a/10*m) + (b+1);
             else
                 ones += (a/10+1)* m;
         }
         return ones;
     }
 }

2.把数组排成最小的数

题目描述:
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

思路：
重新定义一种比较方法，然后对数组进行排序，最后再输出，博主这边是维护了一个最小堆。

代码如下：

 public class Solution {
     public String PrintMinNumber(int [] numbers) {
         PriorityQueue<String> minHeap = new PriorityQueue(new Comparator<String>(){
             public int compare(String str1,String str2){
                 String str_12 = str1+str2;
                 String str_21 = str2+str1;
                 return str_12.compareTo(str_21);
             }
         });
         for(int n:numbers){
             minHeap.add(""+n);
         }
         StringBuffer sb = new StringBuffer();
         while(!minHeap.isEmpty()){
             sb.append(minHeap.poll());
         }
         return sb.toString();
     }
 }

3. 丑数

题目描述：
把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

思路：
由丑数的定义，每个丑数都是可以由比他小的丑数乘以2,3,或者5得到的，所以这边维护了一个数组和三个分别指向下一步将乘以2,3,或者5的数的指针，这样方便来求解下一个丑数，减小时间复杂度。

代码如下：

 public class Solution {
     public int GetUglyNumber_Solution(int index) {
         if(index <= 0) return 0;
         int[] ugly_nums = new int[index];
         ugly_nums[0] = 1;
         int next = 1;

         int p2 = 0,p3 = 0,p5 = 0;
         while(next < index){
             //找到下一个丑数
             int min = Min(ugly_nums[p2]*2,
                          ugly_nums[p3]*3,ugly_nums[p5]*5);
             ugly_nums[next] = min;
             //移动指针，将它们指向下一个该乘的数
             while(ugly_nums[p2]*2 <= ugly_nums[next])
                 p2++;
             while(ugly_nums[p3]*3 <= ugly_nums[next])
                 p3++;
             while(ugly_nums[p5]*5 <= ugly_nums[next])
                 p5++;

             next++;
         }
         return ugly_nums[next-1];
     }

     public int Min(int num1,int num2,int num3){
         int min = (num1 > num2)?num2:num1;
         return min<num3?min:num3;
     }
 }

4.第一个只出现一次的字符位置

题目描述：
在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置。

思路：
比较简单，维护一个hashmap，将字符和出现的次数放入表中。

代码如下：

 import java.util.*;
 public class Solution {
     public int FirstNotRepeatingChar(String str) {
         if(str.length() <= 0) return -1;
         HashMap<Character,Integer> map = new HashMap();
         for(int i = 0; i < str.length(); i++){
             char c = str.charAt(i);
             if(!map.containsKey(c)){
                 map.put(c,1);
             }else{
                 int val = map.get(c);
                 map.put(c,val+1);
             }
         }
         for(int i = 0; i < str.length(); i++){
             if(map.get(str.charAt(i)) == 1)
                 return i;
         }
         return -1;

     }
 }