剑指offerJAVA版笔记（第六天、第三十一题至第三十六题）

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出现的次数）。
• 解题思路：将所有的数存在String中然后遍历String。

public int NumberOf1Between1AndN_Solution(int n) {
            int count=0;
            StringBuffer s=new StringBuffer();
            for(int i=1;i<n+1;i++){
                s.append(i);
            }
            String str=s.toString();
            for(int i=0;i<str.length();i++){
                if(str.charAt(i)=='1')
                    count++;
            }
            return count;
        }

32.把数组排成最小的数

• 题目描述：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
• 解题思路：将所有的数存入String,再用Comparator以及Arrays.sort做排序。

package day6;

import java.util.Arrays;
import java.util.Comparator;

public class PrintMinNumber {
    public String PrintMinNumber(int [] numbers) {
        if(numbers == null || numbers.length == 0) return "";
        int len = numbers.length;
        String[] str = new String[len];
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < len; i++){
            str[i] = String.valueOf(numbers[i]);
        }
        Arrays.sort(str,new Comparator<String>(){
            @Override
            public int compare(String s1, String s2) {
                String c1 = s1 + s2;
                String c2 = s2 + s1;
                return c1.compareTo(c2);
            }
        });
        for(int i = 0; i < len; i++){
            sb.append(str[i]);
        }
        return sb.toString();
    }
}

33.丑数

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

public int GetUglyNumber_Solution(int n) {
        if (n <= 0) {
            return 0;
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        int i2 = 0, i3 = 0, i5 = 0;
        while (list.size() < n)//循环的条件
        {
            int m2 = list.get(i2) * 2;
            int m3 = list.get(i3) * 3;
            int m5 = list.get(i5) * 5;
            int min = Math.min(m2, Math.min(m3, m5));
            list.add(min);
            if (min == m2) i2++;
            if (min == m3) i3++;
            if (min == m5) i5++;
        }
        return list.get(list.size() - 1);
    }

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

• 题目描述：在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
• 解题思路：使用HashMap存每个字母的次数。

 public int FirstNotRepeatingChar(String str) {
       char[] strChar = str.toCharArray();
        Map<Character,Integer> map = new HashMap<>();
        for (int i = 0; i < strChar.length ; i++) {
            if (map.containsKey(strChar[i])){
                map.put(strChar[i],-1);
            }else {
                map.put(strChar[i],1);
            }
        }
        for (int i = 0; i < strChar.length ; i++){
            if(map.get(strChar[i]) == 1){
                return i;
            }
        }
        return -1;
    }

35.数组中的逆序对

• 题目描述：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
• 输入描述:题目保证输入的数组中没有的相同的数字
• 数据范围：
• • 对于%50的数据,size<=10^4
• • 对于%75的数据,size<=10^5
• • 对于%100的数据,size<=2*10^5
• 解题思路：

 public int InversePairs(int [] array) {
        if(array==null||array.length==0)
        {
            return 0;
        }
        int[] copy = new int[array.length];
        for(int i=0;i<array.length;i++)
        {
            copy[i] = array[i];
        }
        int count = InversePairsCore(array,copy,0,array.length-1);//数值过大求余
        return count;
         
    }
    private int InversePairsCore(int[] array,int[] copy,int low,int high)
    {
        if(low==high)
        {
            return 0;
        }
        int mid = (low+high)>>1;
        int leftCount = InversePairsCore(array,copy,low,mid)%1000000007;
        int rightCount = InversePairsCore(array,copy,mid+1,high)%1000000007;
        int count = 0;
        int i=mid;
        int j=high;
        int locCopy = high;
        while(i>=low&&j>mid)
        {
            if(array[i]>array[j])
            {
                count += j-mid;
                copy[locCopy--] = array[i--];
                if(count>=1000000007)//数值过大求余
                {
                    count%=1000000007;
                }
            }
            else
            {
                copy[locCopy--] = array[j--];
            }
        }
        for(;i>=low;i--)
        {
            copy[locCopy--]=array[i];
        }
        for(;j>mid;j--)
        {
            copy[locCopy--]=array[j];
        }
        for(int s=low;s<=high;s++)
        {
            array[s] = copy[s];
        }
        return (leftCount+rightCount+count)%1000000007;
    }

36.两个链表的第一个公共结点

• 题目描述：输入两个链表，找出它们的第一个公共结点。
• 解题思路：找出2个链表的长度，然后让长的先走两个链表的长度差，然后再一起走（因为2个链表用公共的尾部）

public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        int num1 = findListNodeLength(p1);
        int num2 = findListNodeLength(p2);
        if (num1 > num2) {
            for (int i = 0; i < num1 - num2; i++) {
                p1 = p1.next;
            }
            while (p1 != null){
                if (p1 == p2){
                    return p1;
                }
                p1 = p1.next;
                p2 = p2.next;
            }
        }else{
            for (int i = 0; i < num2 - num1; i++) {
                p2 = p2.next;
            }
            while (p1 != null){
                if (p1 == p2){
                    return p1;
                }
                p1 = p1.next;
                p2 = p2.next;
            }
        }
        return null;    
    }

    private int findListNodeLength(ListNode p1) {
        ListNode p = p1;
        int num = 1;
        while (p != null) {
            p = p.next;
            num++;
        }
        return num;
    }