剑指offer 31~40

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

public class Solution {
    public int NumberOf1Between1AndN_Solution(int n) {
        if(n <= 0){
            return 0;
        }
        int count = 0;
        for(int i = 1; i <= n;i++){
            int t = i;
            while(t >= 10){
                if(t % 10 == 1){
                    count++;
                }
                t /= 10;
            }
            if(t == 1){
                count++;
            }
        }
        return count;
    }
}

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

import java.util.*;
public class Solution {
    public String PrintMinNumber(int [] numbers) {
        if(numbers.length == 0){
            return "";
        }
        if(numbers.length == 1){
            return ""+numbers[0];
        }
        String str = "";
        List<Integer> list = new ArrayList<>();
        for(int i = 0;i < numbers.length ;i++){
            list.add(numbers[i]);
        }
        Collections.sort(list,new Comparator<Integer>(){
            @Override
            public int compare(Integer s1,Integer s2){
                String c1 = s1 +""+ s2;
                String c2 = s2 +""+ s1;
                return c1.compareTo(c2);
            }
        });
        for(int i:list){
            str += i;
        }
        return str;
            
    }
}

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

public class Solution {
    public int GetUglyNumber_Solution(int index) {
        if(index <= 0){
            return 0;
        }
        int[] num = new int[index];
        num[0] = 1;
        int count = 0;
        int i = 0;
        int j = 0;
        int k = 0;
        while(count < index -1){
            int tmp = Math.min(num[i]*2,Math.min(num[j]*3,num[k]*5));
            if(tmp == num[i]*2) i++;
            if(tmp == num[j]*3) j++;
            if(tmp == num[k]*5) k++;
            num[++count] = tmp;
        }
        return num[index-1];
    }
}

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

import java.util.*;
class Solution {
    public int FirstNotRepeatingChar(String str) {
        if(str.length() == 0){
            return -1;
        }
        String tmp = str;
        List<Character> list = new ArrayList<>();
        for(int i = 0; i < str.length();i++){
            char ch = str.charAt(i);
            if(!list.contains(ch)){
                list.add(Character.valueOf(ch));
            }else{
                list.remove(Character.valueOf(ch));
                tmp = tmp.replaceAll(String.valueOf(ch),"");
            }
        }
        if(tmp.length() <= 0){
            return -1;
        }
        return str.indexOf(tmp.charAt(0));
    }
}

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

import java.util.*;
public class Solution {
    private int count = 0;
    public int InversePairs(int [] array) {
        mergeSort(0,array.length-1,array);
        return count;
    }
    public void mergeSort(int l,int r,int[] array){
        if(l >= r){
            return;
        }
        int mid = (l + r)/2;
        mergeSort(l,mid,array);
        mergeSort(mid+1,r,array);
        merge(l,mid,r,array);
    }
    public void merge(int l,int mid,int r,int[] array){
        int[] arr = new int[r-l+1];
        int ind = 0;
        int i = l;
        int j = mid+1;
        while(i <= mid && j <= r){
            if(array[i] <= array[j]){
                arr[ind++] = array[i++];
            }else{
                arr[ind++] = array[j++];
                count = (count + (mid - i+1))%1000000007;
            }
        }
        while (i <= mid){
            arr[ind++] = array[i++];
        }
        while(j <= r){
            arr[ind++] = array[j++];
        }
        for(int k = 0;k < ind;k++){
            array[l+k] = arr[k];
        }
    }
}

36.输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

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

37.统计一个数字在排序数组中出现的次数。

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        if(array.length == 0){
            return 0;
        }
        int count = 0;
        for(int i = 0;i < array.length;i++){
            if(array[i] == k){
                count ++;
            }
        }
        return count;
    }
}

38.输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root == null) return 0;
        return Math.max(1+TreeDepth(root.left),1+TreeDepth(root.right));
    }
}

39.输入一棵二叉树，判断该二叉树是否是平衡二叉树。

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        return isp(root) != -1;
    }
    public int isp(TreeNode root){
        if(root == null) return 0;
        int left = isp(root.left);
        if(left == -1) return -1;
        int right = isp(root.right);
        if(right == -1) return -1;
        return Math.abs(left-right)>1?-1:1+Math.max(left,right);
    }
}

40.一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
import java.util.*;
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        List<Integer> list = new ArrayList<>();
        for(int i = 0;i< array.length ;i++){
            int tmp = array[i];
            if(list.contains(tmp)){
                list.remove(Integer.valueOf(tmp));
            }else{
                list.add(tmp);
            }
        }
        num1[0] = list.get(0);
        num2[0] = list.get(1);
    }
}