常考算法題解析
這一章節依託於數據結構的內容，畢竟瞭解了數據結構我們才能寫出更好的算法。
對於大部分公司的面試來說，排序的內容已經足以應付了，由此爲了更好的符合大衆需求，排序的內容是最多的。當然如果你還想衝擊更好的公司，那麼整一個章節的內容都是需要掌握的。對於字節跳動這類十分看重算法的公司來說，這一章節是遠遠不夠的，劍指Offer應該是你更好的選擇。
有一個可視化界面會相對減少點學習的難度，具體可以閱讀 algorithm-visualizer 這個倉庫。
位運算
在進入正題之前，我們先來學習一下位運算的內容。因爲位運算在算法中很有用，速度可以比四則運算快很多。
在學習位運算之前應該知道十進制如何轉二進制，二進制如何轉十進制。這裏說明下簡單的計算方式
- 十進制
33可以看成是32 + 1，並且33應該是六位二進制的（因爲33近似32，而32是 2 的五次方，所以是六位），那麼 十進制33就是100001，只要是2的次方，那麼就是1否則都爲0
2^1 = 2, 2^2 = 4, 2^3 = 8, 2^4 = 16, 2^5 = 32, 2^6 = 64, 2^7 = 128
- 那麼二進制
100001同理，首位是2^5，末位是2^0，相加得出 33
算數左移 <<
10 << 1 // -> 20
左移就是將二進制全部往左移動，10 在二進制中表示爲 1010 ，左移一位後變成 10100 ，轉換爲十進制也就是 20，所以基本可以把左移看成以下公式 a * (2 ^ b)
算數右移 >>
10 >> 1 // -> 5
算數右移就是將二進制全部往右移動並去除多餘的右邊，10 在二進制中表示爲 1010 ，右移一位後變成 101 ，轉換爲十進制也就是 5，所以基本可以把右移看成以下公式 a / (2 ^ b)
條件
右移很好用，比如可以用在二分算法中取中間值
13 >> 1 // -> 6
按位操作
按位與
每一位都爲 1，結果才爲 1，否則爲0
8 & 7 // -> 0
// 1000 & 0111 -> 0000 -> 0
按位或
其中一位爲 1，結果就是 1
8 | 7 // -> 15
// 1000 | 0111 -> 1111 -> 15
按位異或
每一位都不同，結果才爲 1
8 ^ 7 // -> 15
8 ^ 8 // -> 0
// 1000 ^ 0111 -> 1111 -> 15
// 1000 ^ 1000 -> 0000 -> 0
從以上代碼中可以發現按位異或就是不進位加法
面試題：兩個數不使用四則運算得出和
這道題中可以按位異或，因爲按位異或就是不進位加法，8 ^ 8 = 0 如果進位了，就是 16 了，所以我們只需要將兩個數進行異或操作，然後進位。那麼也就是說兩個二進制都是 1 的位置，左邊應該有一個進位 1，所以可以得出以下公式 a + b = (a ^ b) + ((a & b) << 1) ，然後通過迭代的方式模擬加法
function sum (a, b) {
if (a == 0) return b
if (b == 0) return a
let newA = a ^ b
let newB = (a & b) << 1
return sum(newA, newB)
}
排序
以下兩個函數是排序中會用到的通用函數，就不一一寫了
function checkArray(array) {
if (!array) return
}
function swap(array, left, right) {
let rightValue = array[right]
array[right] = array[left]
array[left] = rightValue
}
冒泡排序
冒泡排序的原理如下，從第一個元素開始，把當前元素和下一個索引元素進行比較。如果當前元素大，那麼就交換位置，重複操作直到比較到最後一個元素，那麼此時最後一個元素就是該數組中最大的數。下一輪重複以上操作，但是此時最後一個元素已經是最大數了，所以不需要再比較最後一個元素，只需要比較到 length - 2 的位置。
function bubble(array) {
checkArray(array);
for (let i = array.length - 1; i > 0; i--) {
// 從 0 到 `length - 1` 遍歷
for (let j = 0; j < i; j++) {
if (array[j] > array[j + 1]) swap(array, j, j + 1)
}
}
return array;
}
該算法的操作次數是一個等差數列 n + (n - 1) + (n - 2) + 1 ，去掉常數項以後得出時間複雜度是 O(n * n)
插入排序
插入排序的原理如下。第一個元素默認是已排序元素，取出下一個元素和當前元素比較，如果當前元素大就交換位置。那麼此時第一個元素就是當前的最小數，所以下次取出操作從第三個元素開始，向前對比，重複之前的操作。
以下是實現該算法的代碼
function insertion(array) {
checkArray(array);
for (let i = 1; i < array.length; i++) {
for (let j = i - 1; j >= 0 && array[j] > array[j + 1]; j--)
swap(array, j, j + 1);
}
return array;
}
該算法的操作次數是一個等差數列 n + (n - 1) + (n - 2) + 1 ，去掉常數項以後得出時間複雜度是 O(n * n)
選擇排序
選擇排序的原理如下。遍歷數組，設置最小值的索引爲 0，如果取出的值比當前最小值小，就替換最小值索引，遍歷完成後，將第一個元素和最小值索引上的值交換。如上操作後，第一個元素就是數組中的最小值，下次遍歷就可以從索引 1 開始重複上述操作。
以下是實現該算法的代碼
function selection(array) {
checkArray(array);
for (let i = 0; i < array.length - 1; i++) {
let minIndex = i;
for (let j = i + 1; j < array.length; j++) {
minIndex = array[j] < array[minIndex] ? j : minIndex;
}
swap(array, i, minIndex);
}
return array;
}
該算法的操作次數是一個等差數列 n + (n - 1) + (n - 2) + 1 ，去掉常數項以後得出時間複雜度是 O(n * n)
歸併排序
歸併排序的原理如下。遞歸的將數組兩兩分開直到最多包含兩個元素，然後將數組排序合併，最終合併爲排序好的數組。假設我有一組數組 [3, 1, 2, 8, 9, 7, 6]，中間數索引是 3，先排序數組 [3, 1, 2, 8] 。在這個左邊數組上，繼續拆分直到變成數組包含兩個元素（如果數組長度是奇數的話，會有一個拆分數組只包含一個元素）。然後排序數組 [3, 1] 和 [2, 8] ，然後再排序數組 [1, 3, 2, 8] ，這樣左邊數組就排序完成，然後按照以上思路排序右邊數組，最後將數組 [1, 2, 3, 8] 和 [6, 7, 9] 排序。
以下是實現該算法的代碼
function sort(array) {
checkArray(array);
mergeSort(array, 0, array.length - 1);
return array;
}
function mergeSort(array, left, right) {
// 左右索引相同說明已經只有一個數
if (left === right) return;
// 等同於 `left + (right - left) / 2`
// 相比 `(left + right) / 2` 來說更加安全，不會溢出
// 使用位運算是因爲位運算比四則運算快
let mid = parseInt(left + ((right - left) >> 1));
mergeSort(array, left, mid);
mergeSort(array, mid + 1, right);
let help = [];
let i = 0;
let p1 = left;
let p2 = mid + 1;
while (p1 <= mid && p2 <= right) {
help[i++] = array[p1] < array[p2] ? array[p1++] : array[p2++];
}
while (p1 <= mid) {
help[i++] = array[p1++];
}
while (p2 <= right) {
help[i++] = array[p2++];
}
for (let i = 0; i < help.length; i++) {
array[left + i] = help[i];
}
return array;
}
以上算法使用了遞歸的思想。遞歸的本質就是壓棧，每遞歸執行一次函數，就將該函數的信息（比如參數，內部的變量，執行到的行數）壓棧，直到遇到終止條件，然後出棧並繼續執行函數。對於以上遞歸函數的調用軌跡如下
mergeSort(data, 0, 6) // mid = 3
mergeSort(data, 0, 3) // mid = 1
mergeSort(data, 0, 1) // mid = 0
mergeSort(data, 0, 0) // 遇到終止，回退到上一步
mergeSort(data, 1, 1) // 遇到終止，回退到上一步
// 排序 p1 = 0, p2 = mid + 1 = 1
// 回退到 `mergeSort(data, 0, 3)` 執行下一個遞歸
mergeSort(2, 3) // mid = 2
mergeSort(3, 3) // 遇到終止，回退到上一步
// 排序 p1 = 2, p2 = mid + 1 = 3
// 回退到 `mergeSort(data, 0, 3)` 執行合併邏輯
// 排序 p1 = 0, p2 = mid + 1 = 2
// 執行完畢回退
// 左邊數組排序完畢，右邊也是如上軌跡
該算法的操作次數是可以這樣計算：遞歸了兩次，每次數據量是數組的一半，並且最後把整個數組迭代了一次，所以得出表達式 2T(N / 2) + T(N) （T 代表時間，N 代表數據量）。根據該表達式可以套用 該公式 得出時間複雜度爲 O(N * logN)
快排
快排的原理如下。隨機選取一個數組中的值作爲基準值，從左至右取值與基準值對比大小。比基準值小的放數組左邊，大的放右邊，對比完成後將基準值和第一個比基準值大的值交換位置。然後將數組以基準值的位置分爲兩部分，繼續遞歸以上操作。
圖解：https://my.oschina.net/albert2011/blog/785604
以下是實現該算法的代碼
function sort(array) {
checkArray(array);
quickSort(array, 0, array.length - 1);
return array;
}
function quickSort(array, left, right) {
if (left < right) {
swap(array, , right)
// 隨機取值，然後和末尾交換，這樣做比固定取一個位置的複雜度略低
let indexs = part(array, parseInt(Math.random() * (right - left + 1)) + left, right);
quickSort(array, left, indexs[0]);
quickSort(array, indexs[1] + 1, right);
}
}
function part(array, left, right) {
let less = left - 1;
let more = right;
while (left < more) {
if (array[left] < array[right]) {
// 當前值比基準值小，`less` 和 `left` 都加一
++less;
++left;
} else if (array[left] > array[right]) {
// 當前值比基準值大，將當前值和右邊的值交換
// 並且不改變 `left`，因爲當前換過來的值還沒有判斷過大小
swap(array, --more, left);
} else {
// 和基準值相同，只移動下標
left++;
}
}
// 將基準值和比基準值大的第一個值交換位置
// 這樣數組就變成 `[比基準值小, 基準值, 比基準值大]`
swap(array, right, more);
return [less, more];
}
該算法的複雜度和歸併排序是相同的，但是額外空間複雜度比歸併排序少，只需 O(logN)，並且相比歸併排序來說，所需的常數時間也更少。
面試題
Sort Colors：該題目來自 LeetCode，題目需要我們將 [2,0,2,1,1,0] 排序成 [0,0,1,1,2,2] ，這個問題就可以使用三路快排的思想。
var sortColors = function(nums) {
let left = -1;
let right = nums.length;
let i = 0;
// 下標如果遇到 right，說明已經排序完成
while (i < right) {
if (nums[i] == 0) {
swap(nums, i++, ++left);
} else if (nums[i] == 1) {
i++;
} else {
swap(nums, i, --right);
}
}
};
Kth Largest Element in an Array：該題目來自 LeetCode，題目需要找出數組中第 K 大的元素，這問題也可以使用快排的思路。並且因爲是找出第 K 大元素，所以在分離數組的過程中，可以找出需要的元素在哪邊，然後只需要排序相應的一邊數組就好。
var findKthLargest = function(nums, k) {
let l = 0
let r = nums.length - 1
// 得出第 K 大元素的索引位置
k = nums.length - k
while (l < r) {
// 分離數組後獲得比基準樹大的第一個元素索引
let index = part(nums, l, r)
// 判斷該索引和 k 的大小
if (index < k) {
l = index + 1
} else if (index > k) {
r = index - 1
} else {
break
}
}
return nums[k]
};
function part(array, left, right) {
let less = left - 1;
let more = right;
while (left < more) {
if (array[left] < array[right]) {
++less;
++left;
} else if (array[left] > array[right]) {
swap(array, --more, left);
} else {
left++;
}
}
swap(array, right, more);
return more;
}
堆排序
堆排序利用了二叉堆的特性來做，二叉堆通常用數組表示，並且二叉堆是一顆完全二叉樹（所有葉節點（最底層的節點）都是從左往右順序排序，並且其他層的節點都是滿的）。二叉堆又分爲大根堆與小根堆。
- 大根堆是某個節點的所有子節點的值都比他小
- 小根堆是某個節點的所有子節點的值都比他大
堆排序的原理就是組成一個大根堆或者小根堆。以小根堆爲例，某個節點的左邊子節點索引是 i * 2 + 1，右邊是 i * 2 + 2，父節點是 (i - 1) /2。
- 首先遍歷數組，判斷該節點的父節點是否比他小，如果小就交換位置並繼續判斷，直到他的父節點比他大
- 重新以上操作 1，直到數組首位是最大值
- 然後將首位和末尾交換位置並將數組長度減一，表示數組末尾已是最大值，不需要再比較大小
- 對比左右節點哪個大，然後記住大的節點的索引並且和父節點對比大小，如果子節點大就交換位置
- 重複以上操作 3 - 4 直到整個數組都是大根堆。
以下是實現該算法的代碼
function heap(array) {
checkArray(array);
// 將最大值交換到首位
for (let i = 0; i < array.length; i++) {
heapInsert(array, i);
}
let size = array.length;
// 交換首位和末尾
swap(array, 0, --size);
while (size > 0) {
heapify(array, 0, size);
swap(array, 0, --size);
}
return array;
}
function heapInsert(array, index) {
// 如果當前節點比父節點大，就交換
while (array[index] > array[parseInt((index - 1) / 2)]) {
swap(array, index, parseInt((index - 1) / 2));
// 將索引變成父節點
index = parseInt((index - 1) / 2);
}
}
function heapify(array, index, size) {
let left = index * 2 + 1;
while (left < size) {
// 判斷左右節點大小
let largest =
left + 1 < size && array[left] < array[left + 1] ? left + 1 : left;
// 判斷子節點和父節點大小
largest = array[index] < array[largest] ? largest : index;
if (largest === index) break;
swap(array, index, largest);
index = largest;
left = index * 2 + 1;
}
}
以上代碼實現了小根堆，如果需要實現大根堆，只需要把節點對比反一下就好。
該算法的複雜度是 O(logN)
系統自帶排序實現
每個語言的排序內部實現都是不同的。
對於 JS 來說，數組長度大於 10 會採用快排，否則使用插入排序 源碼實現 。選擇插入排序是因爲雖然時間複雜度很差，但是在數據量很小的情況下和 O(N * logN)相差無幾，然而插入排序需要的常數時間很小，所以相對別的排序來說更快。
對於 Java 來說，還會考慮內部的元素的類型。對於存儲對象的數組來說，會採用穩定性好的算法。穩定性的意思就是對於相同值來說，相對順序不能改變。
鏈表
反轉單向鏈表
該題目來自 LeetCode，題目需要將一個單向鏈表反轉。思路很簡單，使用三個變量分別表示當前節點和當前節點的前後節點，雖然這題很簡單，但是卻是一道面試常考題
以下是實現該算法的代碼
var reverseList = function(head) {
// 判斷下變量邊界問題
if (!head || !head.next) return head
// 初始設置爲空，因爲第一個節點反轉後就是尾部，尾部節點指向 null
let pre = null
let current = head
let next
// 判斷當前節點是否爲空
// 不爲空就先獲取當前節點的下一節點
// 然後把當前節點的 next 設爲上一個節點
// 然後把 current 設爲下一個節點，pre 設爲當前節點
while(current) {
next = current.next
current.next = pre
pre = current
current = next
}
return pre
};
樹
二叉樹的先序，中序，後序遍歷
先序遍歷表示先訪問根節點，然後訪問左節點，最後訪問右節點。
中序遍歷表示先訪問左節點，然後訪問根節點，最後訪問右節點。
後序遍歷表示先訪問左節點，然後訪問右節點，最後訪問根節點。
遞歸實現
遞歸實現相當簡單，代碼如下
function TreeNode(val) {
this.val = val;
this.left = this.right = null;
}
var traversal = function(root) {
if (root) {
// 先序
console.log(root);
traversal(root.left);
// 中序
// console.log(root);
traversal(root.right);
// 後序
// console.log(root);
}
};
對於遞歸的實現來說，只需要理解每個節點都會被訪問三次就明白爲什麼這樣實現了。
非遞歸實現
非遞歸實現使用了棧的結構，通過棧的先進後出模擬遞歸實現。
以下是先序遍歷代碼實現
function pre(root) {
if (root) {
let stack = [];
// 先將根節點 push
stack.push(root);
// 判斷棧中是否爲空
while (stack.length > 0) {
// 彈出棧頂元素
root = stack.pop();
console.log(root);
// 因爲先序遍歷是先左後右，棧是先進後出結構
// 所以先 push 右邊再 push 左邊
if (root.right) {
stack.push(root.right);
}
if (root.left) {
stack.push(root.left);
}
}
}
}
以下是中序遍歷代碼實現
function mid(root) {
if (root) {
let stack = [];
// 中序遍歷是先左再根最後右
// 所以首先應該先把最左邊節點遍歷到底依次 push 進棧
// 當左邊沒有節點時，就打印棧頂元素，然後尋找右節點
// 對於最左邊的葉節點來說，可以把它看成是兩個 null 節點的父節點
// 左邊打印不出東西就把父節點拿出來打印，然後再看右節點
while (stack.length > 0 || root) {
if (root) {
stack.push(root);
root = root.left;
} else {
root = stack.pop();
console.log(root);
root = root.right;
}
}
}
}
以下是後序遍歷代碼實現，該代碼使用了兩個棧來實現遍歷，相比一個棧的遍歷來說要容易理解很多
function pos(root) {
if (root) {
let stack1 = [];
let stack2 = [];
// 後序遍歷是先左再右最後根
// 所以對於一個棧來說，應該先 push 根節點
// 然後 push 右節點，最後 push 左節點
stack1.push(root);
while (stack1.length > 0) {
root = stack1.pop();
stack2.push(root);
if (root.left) {
stack1.push(root.left);
}
if (root.right) {
stack1.push(root.right);
}
}
while (stack2.length > 0) {
console.log(s2.pop());
}
}
}
中序遍歷的前驅後繼節點
實現這個算法的前提是節點有一個 parent 的指針指向父節點，根節點指向 null 。
如圖所示，該樹的中序遍歷結果是 4, 2, 5, 1, 6, 3, 7
前驅節點
對於節點 2 來說，他的前驅節點就是 4 ，按照中序遍歷原則，可以得出以下結論
- 如果選取的節點的左節點不爲空，就找該左節點最右的節點。對於節點
1來說，他有左節點2，那麼節點2的最右節點就是5 - 如果左節點爲空，且目標節點是父節點的右節點，那麼前驅節點爲父節點。對於節點
5來說，沒有左節點，且是節點2的右節點，所以節點2是前驅節點 - 如果左節點爲空，且目標節點是父節點的左節點，向上尋找到第一個是父節點的右節點的節點。對於節點
6來說，沒有左節點，且是節點3的左節點，所以向上尋找到節點1，發現節點3是節點1的右節點，所以節點1是節點6的前驅節點
以下是算法實現
function predecessor(node) {
if (!node) return
// 結論 1
if (node.left) {
return getRight(node.left)
} else {
let parent = node.parent
// 結論 2 3 的判斷
while(parent && parent.right === node) {
node = parent
parent = node.parent
}
return parent
}
}
function getRight(node) {
if (!node) return
node = node.right
while(node) node = node.right
return node
}
後繼節點
對於節點 2 來說，他的後繼節點就是 5 ，按照中序遍歷原則，可以得出以下結論
- 如果有右節點，就找到該右節點的最左節點。對於節點
1來說，他有右節點3，那麼節點3的最左節點就是6 - 如果沒有右節點，就向上遍歷直到找到一個節點是父節點的左節點。對於節點
5來說，沒有右節點，就向上尋找到節點2，該節點是父節點1的左節點，所以節點1是後繼節點
以下是算法實現
function successor(node) {
if (!node) return
// 結論 1
if (node.right) {
return getLeft(node.right)
} else {
// 結論 2
let parent = node.parent
// 判斷 parent 爲空
while(parent && parent.left === node) {
node = parent
parent = node.parent
}
return parent
}
}
function getLeft(node) {
if (!node) return
node = node.left
while(node) node = node.left
return node
}
樹的深度
樹的最大深度：該題目來自 Leetcode，題目需要求出一顆二叉樹的最大深度
以下是算法實現
var maxDepth = function(root) {
if (!root) return 0
return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1
};
對於該遞歸函數可以這樣理解：一旦沒有找到節點就會返回 0，每彈出一次遞歸函數就會加一，樹有三層就會得到3。
動態規劃
動態規劃背後的基本思想非常簡單。就是將一個問題拆分爲子問題，一般來說這些子問題都是非常相似的，那麼我們可以通過只解決一次每個子問題來達到減少計算量的目的。
一旦得出每個子問題的解，就存儲該結果以便下次使用。
斐波那契數列
斐波那契數列就是從 0 和 1 開始，後面的數都是前兩個數之和
0，1，1，2，3，5，8，13，21，34，55，89…
那麼顯然易見，我們可以通過遞歸的方式來完成求解斐波那契數列
function fib(n) {
if (n < 2 && n >= 0) return n
return fib(n - 1) + fib(n - 2)
}
fib(10)
以上代碼已經可以完美的解決問題。但是以上解法卻存在很嚴重的性能問題，當 n 越大的時候，需要的時間是指數增長的，這時候就可以通過動態規劃來解決這個問題。
動態規劃的本質其實就是兩點
- 自底向上分解子問題
- 通過變量存儲已經計算過的解
根據上面兩點，我們的斐波那契數列的動態規劃思路也就出來了
-
斐波那契數列從 0 和 1 開始，那麼這就是這個子問題的最底層
-
通過數組來存儲每一位所對應的斐波那契數列的值
function fib(n) {
let array = new Array(n + 1).fill(null)
array[0] = 0
array[1] = 1
for (let i = 2; i <= n; i++) {
array[i] = array[i - 1] + array[i - 2]
}
return array[n]
}
fib(10)
0 - 1揹包問題
該問題可以描述爲：給定一組物品，每種物品都有自己的重量和價格，在限定的總重量內，我們如何選擇，才能使得物品的總價格最高。每個問題只能放入至多一次。
假設我們有以下物品
對於一個總容量爲 5 的揹包來說，我們可以放入重量 2 和 3 的物品來達到揹包內的物品總價值最高。
對於這個問題來說，子問題就兩個，分別是放物品和不放物品，可以通過以下表格來理解子問題
直接來分析能放三種物品的情況，也就是最後一行
- 當容量少於 3 時，只取上一行對應的數據，因爲當前容量不能容納物品 3
- 當容量 爲 3 時，考慮兩種情況，分別爲放入物品 3 和不放物品 3
- 不放物品 3 的情況下，總價值爲 10
- 放入物品 3 的情況下，總價值爲 12，所以應該放入物品 3
- 當容量 爲 4 時，考慮兩種情況，分別爲放入物品 3 和不放物品 3
- 不放物品 3 的情況下，總價值爲 10
- 放入物品 3 的情況下，和放入物品 1 的價值相加，得出總價值爲 15，所以應該放入物品 3
- 當容量 爲 5 時，考慮兩種情況，分別爲放入物品 3 和不放物品 3
- 不放物品 3 的情況下，總價值爲 10
- 放入物品 3 的情況下，和放入物品 2 的價值相加，得出總價值爲 19，所以應該放入物品 3
/**
* @param {*} w 物品重量
* @param {*} v 物品價值
* @param {*} C 總容量
* @returns
*/
function knapsack(w, v, C) {
let length = w.length
if (length === 0) return 0
// 對照表格，生成的二維數組，第一維代表物品，第二維代表揹包剩餘容量
// 第二維中的元素代表揹包物品總價值
let array = new Array(length).fill(new Array(C + 1).fill(null))
// 完成底部子問題的解
for (let i = 0; i <= C; i++) {
// 對照表格第一行， array[0] 代表物品 1
// i 代表剩餘總容量
// 當剩餘總容量大於物品 1 的重量時，記錄下揹包物品總價值，否則價值爲 0
array[0][i] = i >= w[0] ? v[0] : 0
}
// 自底向上開始解決子問題，從物品 2 開始
for (let i = 1; i < length; i++) {
for (let j = 0; j <= C; j++) {
// 這裏求解子問題，分別爲不放當前物品和放當前物品
// 先求不放當前物品的揹包總價值，這裏的值也就是對應表格中上一行對應的值
array[i][j] = array[i - 1][j]
// 判斷當前剩餘容量是否可以放入當前物品
if (j >= w[i]) {
// 可以放入的話，就比大小
// 放入當前物品和不放入當前物品，哪個揹包總價值大
array[i][j] = Math.max(array[i][j], v[i] + array[i - 1][j - w[i]])
}
}
}
return array[length - 1][C]
}
最長遞增子序列
最長遞增子序列意思是在一組數字中，找出最長一串遞增的數字，比如
0, 3, 4, 17, 2, 8, 6, 10
對於以上這串數字來說，最長遞增子序列就是 0, 3, 4, 8, 10，可以通過以下表格更清晰的理解
通過以上表格可以很清晰的發現一個規律，找出剛好比當前數字小的數，並且在小的數組成的長度基礎上加一。
這個問題的動態思路解法很簡單，直接上代碼
function lis(n) {
if (n.length === 0) return 0
// 創建一個和參數相同大小的數組，並填充值爲 1
let array = new Array(n.length).fill(1)
// 從索引 1 開始遍歷，因爲數組已經所有都填充爲 1 了
for (let i = 1; i < n.length; i++) {
// 從索引 0 遍歷到 i
// 判斷索引 i 上的值是否大於之前的值
for (let j = 0; j < i; j++) {
if (n[i] > n[j]) {
array[i] = Math.max(array[i], 1 + array[j])
}
}
}
let res = 1
for (let i = 0; i < array.length; i++) {
res = Math.max(res, array[i])
}
return res
}