剑指offer之31-35题解

剑指offer之31-35题解

---

目录

31. 整数中1出现的次数（从1到n整数中1出现的次数）
32. 把数组排成最小的数
33. 丑数
34. 第一个只出现一次的字符位置
35. 数组中的逆序对

---

31. 整数中1出现的次数（从1到n整数中1出现的次数）

（一）题目描述

求出1~ 13的整数中1出现的次数,并算出100~ 1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

（二）思路

1. 详解见博客：https://www.cnblogs.com/xuanxufeng/p/6854105.html

（三）代码实现

public class Solution {
   public static int NumberOf1Between1AndN_Solution(int n) {
        int cnt = 0;
        for (int m = 1; m <= n; m *= 10) {
           int a = n / m, b = n % m;
           cnt += (a + 8) / 10 * m + (a % 10 == 1 ? b + 1 : 0);
        }
        return cnt;
    }
}

---

32. 把数组排成最小的数

（一）题目描述

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

（二）思路

1. 可以看成一个排序问题，在比较两个字符串S1和S2的大小时，应该比较的是S1+S2和S2+S1的大小，S1+S2<S2+S1，那么应该把S1排在前面，否则应该把S2排在前面。

（三）代码实现

import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
    public String PrintMinNumber(int[] numbers) {
        if (numbers == null || numbers.length == 0)
            return "";
        int n = numbers.length;
        String[] nums = new String[n];
        for (int i = 0; i < n; i++)
            nums[i] = numbers[i] + "";
        Arrays.sort(nums, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));
        String ret = "";
        for (String str : nums)
            ret += str;
        return ret;
    }
}

---

33. 丑数

（一）题目描述

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

（二）思路

1. 利用2,3,5循环相乘得到最小，即为第n个最小丑数。

（三）代码实现

public class Solution {
    public int GetUglyNumber_Solution(int index) {
        if (index <= 6)
            return index;
        int i2 = 0, i3 = 0, i5 = 0;
        int[] dp = new int[index];
        dp[0] = 1;
        for (int i = 1; i < index; i++) {
            int next2 = dp[i2] * 2, next3 = dp[i3] * 3, next5 = dp[i5] * 5;
            dp[i] = Math.min(next2, Math.min(next3, next5));
            if (dp[i] == next2)
                i2++;
            if (dp[i] == next3)
                i3++;
            if (dp[i] == next5)
                i5++;
        }
        return dp[index - 1];
    }
}

---

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

（一）题目描述

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.

（二）思路

1. 创建容量为256的int数组
2. 遍历str，将它的字节加入int数组(比如字节a的int是97)
3. 遍历str，如果出现的次数=1，则返回。

（三）代码实现

public class Solution {
    public int FirstNotRepeatingChar(String str) {
        int[] cnt = new int[256];
        for (int i = 0; i < str.length(); i++) 
            cnt[str.charAt(i)]++;
        for (int i = 0; i < str.length(); i++) 
            if (cnt[str.charAt(i)]==1)
                return i;
        return -1;
    }
}

---

35. 数组中的逆序对

（一）题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007

（二）思路

1. 先把数组分隔成子数组，统计出子数组内部的逆序对的数目，然后再统计出两个相邻子数组之间的逆序对的数目。

2. 具体请参见博客：https://blog.csdn.net/qq_28081081/article/details/80804781，整体思路是一样的。

（三）代码实现

public class Solution {
    private long cnt = 0;
    private int[] tmp; //在这里声明辅助数组，而不是在merge()递归函数中声明

    public int InversePairs(int[] array) {
        tmp = new int[array.length];
        mergeSort(array, 0, array.length - 1);
        return (int) (cnt % 1000000007);
    }

    private void mergeSort(int[] array, int l, int h) {
        if (h - l < 1)
            return;
        int m = l + (h - l) / 2;
        mergeSort(array, l, m);
        mergeSort(array, m + 1, h);
        merge(array, l, m, h);

    }

    private void merge(int[] array, int l, int m, int h) {
        int i = l, j = m + 1, k = l;
        while (i <= m || j <= h) {
            if (i > m)
                tmp[k] = array[j++];
            else if (j > h)
                tmp[k] = array[i++];
            else if (array[i] <= array[j])
                tmp[k] = array[i++];
            else {
                tmp[k] = array[j++];
                this.cnt += m - i + 1;  //nums[i]>nums[j],说明nums[i...mid]都大于nums[j]
            }
            k++;
        }
        for (k = l; k <= h; k++) {
            array[k] = tmp[k];
        }
    }
}