连续子数组的最大和
输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为 O(n).
示例1
输入：[1,-2,3,10,-4,7,2,-5]
返回值：18
说明：输入的数组为{1,-2,3,10,—4,7,2,一5}，和最大的子数组为{3,10,一4,7,2}，因此输出为该子数组的和 18。 

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        int max=array[0];
        int res=array[0];
        for(int i=1;i<array.length;i++)
        {
            max=Math.max(max+array[i],array[i]);
            res=Math.max(max,res);
        }
        return res;
    }
}

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

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

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

import java.util.ArrayList;
public class Solution {
    public String PrintMinNumber(int [] numbers) {
        String s="";
        for(int i=0;i<numbers.length;i++)
        {
            for(int j=i+1;j<numbers.length;j++)
            {
                int a=Integer.valueOf(numbers[i]+""+numbers[j]);
                int b=Integer.valueOf(numbers[j]+""+numbers[i]);
                if(b<a)
                {
                    int t;
                    t=numbers[i];
                    numbers[i]=numbers[j];
                    numbers[j]=t;
                }
            }
        }
        for(int i=0;i<numbers.length;i++)
        {
            s+=numbers[i];
        }
        return s;
    }
}

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

import java.util.ArrayList;
public class Solution {
    public int GetUglyNumber_Solution(int index) {
        if(index==0)
            return 0;
        ArrayList<Integer> a=new ArrayList<>();
        a.add(1);
        int i2=0,i3=0,i5=0;
        while(a.size()<index)
        {
            int n2=2*a.get(i2);
            int n3=3*a.get(i3);
            int n5=5*a.get(i5);
            int min=Math.min(Math.min(n2,n3),n5);
            if(min==n2)
                i2++;
            if(min==n3)
                i3++;
            if(min==n5)
                i5++;
            a.add(min);
        }
        return a.get(index-1);
    }
}

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

/*
public class ListNode {
    int val;
    ListNode next = null;
    ListNode(int val) {
        this.val = val;
    }
}*/
//辅助栈
import java.util.Stack;
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if(pHead2==null||pHead1==null)
            return null;
        Stack<ListNode> s1=new Stack<>();
        Stack<ListNode> s2=new Stack<>();
        while(pHead1!=null)
        {
            s1.add(pHead1);
            pHead1=pHead1.next;
        }
        while(pHead2!=null)
        {
            s2.add(pHead2);
            pHead2=pHead2.next;
        }
        ListNode l=null;
        while(!s1.isEmpty()&&!s2.isEmpty()&&s1.peek()==s2.peek())
        {
            l=s1.pop();
            s2.pop();
        }
        return l;

    }
}
//长度遍历
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if(pHead2==null||pHead1==null)
            return null;
        ListNode p1=pHead1;
        ListNode p2=pHead2;
        while(p2!=p1)
        {
            p2=p2.next;
            p1=p1.next;
            if(p1!=p2)
            {
                if(p1==null)
                    p1=pHead2;
                if(p2==null)
                    p2=pHead1;
            }
        }
        return p2;
    }
}