關於最長遞增子序列時間複雜度O（n^2）的實現方法在部落格http://blog.csdn.net/iniegang/article/details/47379873（最長遞增子序列 Java實現）中已經做了實現，但是這種方法時間複雜度太高，查閱相關資料後我發現有人提出的演算法可以將時間複雜度降低為O(nlogn)，這種演算法的核心思想就是替換（二分法替換），以下為我對這中演算法的理解：
假設隨機生成的一個具有10個元素的陣列arrayIn[1-10]如[2, 3, 3, 4, 7, 3, 1, 6, 6, 4]，求這個陣列的最長遞增子序列。
首先定義一個數組arrayOut[1-10]來逐個尋找arrayIn[1-10]中以第i個元素結尾的最長遞增子序列的長度。
定義len來計算相應的長度
（1）將arrayIn[1]放入arrayOut，此時arrayOut[1]=arrayIn[1]=2，此時len=1；
（2）將arrayIn[2]放入arrayOut，此時要先尋找arrayIn[2]應該放入的位置，由於arrayIn[2]=3>arrayOut[1]=2，那麼arrayIn[2]應該放入的位置為arrayOut[2]，這時arrayOut[2]=arrayIn[2]=3，此時len=2;
（3）將arrayIn[3]放入arrayOut，此時要先尋找arrayIn[3]應該放入的位置，由於arrayIn[3]=3=arrayOut[2]=3，那麼arrayIn[3]應該放入的位置為arrayOut[2]，這時arrayOut[2]=arrayIn[3]=3，即此時進來的arrayIn[3]替換掉了arrayOut[2]，此時len仍然為2;
（4）對陣列arrayIn的後續元素執行以上類似的操作即
如果arrayIn要放入的元素比arrayOut最後一個元素大的話就放在其後；
否則尋找一個替換的位置
這樣以來arrayIn元素放入的位置即為len的值，然後判斷這次得到的len值與上次的len值的大小，向大的方向更新即可。
使用二分法來查詢arrayIn元素應該放入的位置即可將時間複雜度降為O(nlogn)。
以下為具體的實現程式碼（java）

import java.util.Arrays;
import java.util.Random;

public class LISUpdate {

    public static void main(String[] args){

        System.out.println("Generating a random array...");
        LISUpdate lisUpdate=new LISUpdate();
        int[] oldArray=new int[10];
        oldArray=lisUpdate.randomArray();
        System.out
 
.println(Arrays.toString(oldArray)); //輸出生成的隨機陣列
        System.out.println("each LIS array:"); //輸出每次計算時arrayOut陣列的內容，便於觀察
        System.out.println("LIS length nlogn is:"+lisUpdate.getLength(oldArray)); //輸出最長遞增子序列的長度
    }

    public int[] randomArray(){ //生成一個10以內的陣列，長度為10
        Random random=new Random();
        int
 
[] randomArray=new int[10];
        for (int i = 0; i < 10; i++) {
            randomArray[i]=random.nextInt(10);
        }

        return randomArray;
    }

    public int BinarySearchPosition(int arrayOut[],int left,int right,int key){ //二分查詢要替換的位置

        int mid;

        if (arrayOut[right]<key) {
            return right+1;
        }else {
            while(left<right){
                mid=(left+right)/2;
                if (arrayOut[mid]<key) {
                    left=mid+1;
                }else {
                    right=mid;
                }       
            }
                return left;
        }

    }

    public int getLength(int[] arrayIn){ //獲取最長遞增子序列的長度

        int position;
        int len=1;

        int[] arrayOut=new int[arrayIn.length+1];//arrayOut[0]沒有存放資料
        arrayOut[1]=arrayIn[0]; //初始化，長度為1的LIS末尾為arrayIn[0]
        for (int i = 1; i < arrayIn.length; i++) {
            position=BinarySearchPosition(arrayOut, 1, len, arrayIn[i]);
            arrayOut[position]=arrayIn[i];
            System.out.println(Arrays.toString(arrayOut));
            if (len<position) {
                len=position;
            }
        }

        return len;
    }

}

需要注意的是：上面程式碼中輸出的arrayOut陣列並不是最長遞增子序列，我這裡選擇將其輸出只是為了驗證演算法的執行過程。

對於求最長遞減子序列，則可以直接將原陣列進行“反轉”操作，然後求出反轉之後的陣列的最長遞增子序列的長度即為最長遞減子序列的長度。

標記為原創的博文均為本人辛苦碼字所得，謝絕抄襲，轉載請註明出處，新浪微博私信艾特：物聯網工程_Niegang。