丑数

把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
动态规划问题，主要解法是把之前的计算出的丑数保存起来，作为求得下一个丑数的条件。
假设当前最后一个丑数为M，前面第一个丑数乘以2以后大于M的结果记为m2,同样得出m3,m5。下一个丑数应该为m2,m3,m5中最小的值。

处理过程大致如上图 每次当min==list.get(i2)*2或者list.get(i3)*3或者list.get(i5)*5时，对i2/i3/i5++，即更新了下一次可以加入丑数队列的值。i2,i3,i5始终指向下一个可以加入队列的下标。

     public int GetUglyNumber_Solution(int n) {
            if(n<=0)
                return 0;
            ArrayList<Integer> list=new ArrayList<>();
            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);
     }

数组中的逆序对

一个合并递归的过程。比如7564，先分解成75，64，再7，5，6，4，两两合并同时排序，统计对数。57，46有两个逆序对。两个指针指向尾部，7大于6时，7大于6之前组内所有数，7进入temp数组，逆序对+2，指针前移，5小于6，6进入temp，比较54，5大于4，逆序对+1，5进入temp，最后4进入temp，一共5个逆序对。

    int inverse(int[] data,int[] copy,int start,int end){
        if(start==end){
            copy[start]=data[start];
            return 0;
        }
        int len=(end-start)/2;
        int left=inverse(copy,data,start,start+len);
        int right=inverse(copy,data,start+len+1,end);
        //i初始化为前半段最后一个数字下标
        int i=start+len;
        //j初始化为后半段最后一个数字下标
        int j=end;
        int indexCopy=end;
        int count=0;
        while(i>=start&&j>=start+len+1){
            if(data[i]>data[j]){
                copy[indexCopy--]=data[i--];
                count+=j-start-len;
            }else{
                copy[indexCopy--]=data[j--];
            }
        }
        while(i>=start)
            copy[indexCopy--]=data[i--];
        while(j>=start+len+1)
            copy[indexCopy--]=data[j--];
        return left+right+count;        
    }

数字在排序数组中出现的次数

利用二分查找 两个函数分别使用了递归和非递归二分查找

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        int length=array.length;
        if(length==0)
            return 0;
        int firstK=getFirstK(array,k,0,length-1);
        int lastK=getLastK(array,k,0,length-1);
        if(firstK!=-1&&lastK!=-1)
            return lastK-firstK+1;
        return 0;
    }
    


    int getFirstK(int[] array,int k,int start,int end){
        if(start>end)
            return -1;
        int mid=(start+end)>>1;
        if(array[mid]>k)
            return getFirstK(array, k, start, mid-1);
        else if(array[mid]<k)
            return getFirstK(array, k, mid+1, end);
        else if(mid-1>=0&&array[mid-1]==k)
            return getFirstK(array, k, start, mid-1);
        else
            return mid;
    }
    
    private int getLastK(int []array,int k,int start,int end){
        int length=array.length;
        int mid=(start+end)>>1;
        while(start<=end){
            if(array[mid]>k)
                end=mid-1;
            else if(array[mid]<k)
                start=mid+1;
            else if(mid+1<length&&array[mid+1]==k)
                start=mid+1;
            else
                return mid;
            mid=(start+end)>>1;
        }
        return -1;
    }
}