最长递增子序列

描述：给定数组arr，设长度为n，输出arr的最长递增子序列
示例1
输入：[2,1,5,3,6,4,8,9,7]
返回值：[1,3,4,8,9]
示例2
输入：[1,2,8,6,4]
返回值：[1,2,4]

public class T8 {
    public static void main(String args[]){
        int[] arr = {2,1,5,3,6,4,8,9,7};
//        System.out.println(fun(arr));
        System.out.println(Arrays.toString(fun(arr)));
    }

    public static int[] fun(int[] arr){
        if(arr==null || arr.length<2){
            return arr;
        }
        int len = arr.length;
        // dp[i]表示以下标i元素结尾的最长递增子序列的长度
        int[] dp = new int[len];
        dp[0] = 1;
        // list中存储长度为k的子序列的尾元素的最小值， 例如list[k-1]存放长度为k的子序列的尾元素的最小值，当前的最长序列长度为list.size()
        List<Integer> list = new ArrayList<>();
        list.add(arr[0]);
        for(int i=1;i<len;i++){
            // L = list.size()
            if(arr[i]>list.get(list.size()-1)){
                // 若arr[i] > list.get(L-1) (尾元素)，dp[i] = L + 1, 将arr[i]插入list最后
                dp[i] = list.size() + 1;
                list.add(arr[i]);
            }else{
                // 在list中查找第一个比它大（或相等）的元素，将该值变更为dp[i]
                int index = search(0, list.size()-1, arr[i], list);
                list.set(index, arr[i]);
                dp[i] = index + 1;
            }
        }
        int L = list.size();
        int[] result = new int[L];
        for(int i=dp.length-1;i>=0;i--){
            if(dp[i]==L){
                result[L-1] = arr[i];
                L--;
            }
        }
        return result;
    }

    // 为什么可以在list中进行二分查找？
    // 设 list[k-1]< dp[i] < list[k]，那么dp[i]可以接在以list[k-1]为尾元素的序列之后，构成长度等于以list[k]为尾元素的序列,维护list的定义list[k]变为dp[i]
    // 所以list为递增序列，因此采用二分查找
    public static int search(int i, int j, int num, List<Integer> list){
        // 在list中查找第一个比num大（或相等）的元素
        while(i<j){
            int mid = i + (j-i) / 2;
            if(list.get(mid)<=num){
                i = mid+1;
            }else{
                j = mid;
            }
        }
        return i;
    }

}