最长上升子序列

题目描述：
给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。
进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?
时间复杂度为O(n2)算法：
思路：d[i]表示以i结尾的序列中最长的长度，则最后只要找出d[i]中的最大值

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] d = new int[nums.length];
        int len = 0;
        for(int i = 0; i < nums.length; i++){
            d[i] = 1;
            for(int j = 0; j < i; j++){
                if(nums[i] > nums[j] && (d[j] + 1) > d[i]){
                    d[i] = d[j] + 1;
                }
            }
            if(d[i] > len)
                    len = d[i];
        }
        return len;
    }
}   

时间复杂度是O(nlogn)。具体的方法是：采用b[]数组用来存放上升子序列（上面的方法是用来存放当前数的最大上升子序列），还是a[]={1,7,3,5,9,4,8}，想要找出最长的子序列，那么每一个值都要尽可能小，比如说{1,3}一定比{1,7}好，那么，在遍历到7的时候，b[]={1,7}，这时遍历3,3比7小（3的潜力更大），应该用3代替7，也就是在数组b[]={1,7}中找到3的位置，采用二分法（时间 复杂度O(logn)）。

#include <iostream>
using namespace std;
int BinSeach(int &item, int *a, int left, int right)
{
    while (left<right)
    {
        int mid = (left + right) / 2;
        if (item > a[mid] && item <= a[mid + 1])
            return mid;
        else if (item < a[mid])
            right = mid - 1;
        else
            left = mid + 1;
    }   
}
int main()
{
    int a[] = { 1, 7, 3, 5, 9, 4, 8 };
    int n = sizeof(a) / sizeof(int);
    int b[sizeof(a) / sizeof(int)];
    b[0] = a[0];
    int len = 1;
    int j = 0;
    for (int i = 1; i < n;i++)
    {
        if (a[i]>b[len - 1])
            j = len++;
        else
            j = BinSeach(a[i], b, 0, len - 1)+1;
        b[j] = a[i];
    }
    cout << len << endl;
    for (int i = 0; i < len;i++)
    {
        cout << b[i] << " ";
    }
    return 0;
}