前端面試題（七）經常使用算法篇
時間複雜度
一般使用最差的時間複雜度來衡量一個算法的好壞。node
常數時間 O(1) 表明這個操做和數據量不要緊，是一個固定時間的操做，好比說四則運算。git
對於一個算法來講，可能會計算出以下操做次數 aN + 1，N 表明數據量。那麼該算法的時間複雜度就是 O(N)。由於咱們在計算時間複雜度的時候，數據量一般是很是大的，這時候低階項和常數項能夠忽略不計。github
固然可能會出現兩個算法都是 O(N) 的時間複雜度，那麼對比兩個算法的好壞就要經過對比低階項和常數項了。面試
位運算
位運算在算法中頗有用，速度能夠比四則運算快不少。算法
在學習位運算以前應該知道十進制如何轉二進制，二進制如何轉十進制。這裏說明下簡單的計算方式api
- 十進制
33能夠當作是32 + 1，而且33應該是六位二進制的（由於33近似32，而32是 2 的五次方，因此是六位），那麼 十進制33就是100001，只要是 2 的次方，那麼就是 1不然都爲 0 - 那麼二進制
100001同理，首位是2^5，末位是2^0，相加得出 33
左移 <<
10 << 1 // -> 20
複製代碼
左移就是將二進制所有往左移動，10 在二進制中表示爲 1010 ，左移一位後變成 10100 ，轉換爲十進制也就是 20，因此基本能夠把左移當作如下公式 a * (2 ^ b)數組
算數右移 >>
10 >> 1 // -> 5
複製代碼
算數右移就是將二進制所有往右移動並去除多餘的右邊，10 在二進制中表示爲 1010 ，右移一位後變成 101 ，轉換爲十進制也就是 5，因此基本能夠把右移當作如下公式 int v = a / (2 ^ b)安全
右移很好用，好比能夠用在二分算法中取中間值less
13 >> 1 // -> 6
複製代碼
按位操做
按位與dom
每一位都爲 1，結果才爲 1
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 || array.length <= 2) return
}
function swap(array, left, right) {
let rightValue = array[right]
array[right] = array[left]
array[left] = rightValue
}
複製代碼
冒泡排序
冒泡排序的原理以下，從第一個元素開始，把當前元素和下一個索引元素進行比較。若是當前元素大，那麼就交換位置，重複操做直到比較到最後一個元素，那麼此時最後一個元素就是該數組中最大的數。下一輪重複以上操做，可是此時最後一個元素已是最大數了，因此不須要再比較最後一個元素，只須要比較到 length - 1 的位置。
如下是實現該算法的代碼
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)
快排
快排的原理以下。隨機選取一個數組中的值做爲基準值，從左至右取值與基準值對比大小。比基準值小的放數組左邊，大的放右邊，對比完成後將基準值和第一個比基準值大的值交換位置。而後將數組以基準值的位置分爲兩部分，繼續遞歸以上操做。
如下是實現該算法的代碼
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揹包問題
該問題能夠描述爲：給定一組物品，每種物品都有本身的重量和價格，在限定的總重量內，咱們如何選擇，才能使得物品的總價格最高。每一個問題只能放入至多一次。
假設咱們有如下物品
| 物品 ID / 重量 | 價值 |
|---|---|
| 1 | 3 |
| 2 | 7 |
| 3 | 12 |
對於一個總容量爲 5 的揹包來講，咱們能夠放入重量 2 和 3 的物品來達到揹包內的物品總價值最高。
對於這個問題來講，子問題就兩個，分別是放物品和不放物品，能夠經過如下表格來理解子問題
| 物品 ID / 剩餘容量 | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 1 | 0 | 3 | 3 | 3 | 3 | 3 |
| 2 | 0 | 3 | 7 | 10 | 10 | 10 |
| 3 | 0 | 3 | 7 | 12 | 15 | 19 |
直接來分析能放三種物品的狀況，也就是最後一行
- 當容量少於 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，能夠經過如下表格更清晰的理解
| 數字 | 0 | 3 | 4 | 17 | 2 | 8 | 6 | 10 |
|---|---|---|---|---|---|---|---|---|
| 長度 | 1 | 2 | 3 | 4 | 2 | 4 | 4 | 5 |
經過以上表格能夠很清晰的發現一個規律，找出恰好比當前數字小的數，而且在小的數組成的長度基礎上加一。
這個問題的動態思路解法很簡單，直接上代碼
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
}
複製代碼
字符串相關
在字符串相關算法中，Trie 樹能夠解決解決不少問題，同時具有良好的空間和時間複雜度，好比如下問題
- 詞頻統計
- 前綴匹配
若是你對於 Trie 樹還不怎麼了解，能夠前往 這裏 閱讀
- 1. 96道前端面試題+前端經常使用算法
- 2. 經常使用算法面試題一
- 3. 前端常見算法面試題
- 4. JavaScript數組經常使用算法操做~前端面試(二)
- 5. 前端面試算法題
- 6. 前端面試題--算法
- 7. 前端面試——算法題
- 8. 前端常見的面試題(七)
- 9. 前端（七）算法篇
- 10. 前端開發面試常用算法
- 更多相關文章...
- • 使用UDP協議掃描端口 - TCP/IP教程
- • MySQL常用運算符詳解 - MySQL教程
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
- • 使用Rxjava計算圓周率
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Duang!超快Wi-Fi來襲
- 2. 機器學習-補充03 神經網絡之**函數(Activation Function)
- 3. git上開源maven項目部署 多module maven項目（多module maven+redis+tomcat+mysql）後臺部署流程學習記錄
- 4. ecliple-tomcat部署maven項目方式之一
- 5. eclipse新導入的項目經常可以看到「XX cannot be resolved to a type」的報錯信息
- 6. Spark RDD的依賴於DAG的工作原理
- 7. VMware安裝CentOS-8教程詳解
- 8. YDOOK：Java 項目 Spring 項目導入基本四大 jar 包 導入依賴，怎樣在 IDEA 的項目結構中導入 jar 包 導入依賴
- 9. 簡單方法使得putty（windows10上）可以免密登錄樹莓派
- 10. idea怎麼用本地maven
- 1. 96道前端面試題+前端經常使用算法
- 2. 經常使用算法面試題一
- 3. 前端常見算法面試題
- 4. JavaScript數組經常使用算法操做~前端面試(二)
- 5. 前端面試算法題
- 6. 前端面試題--算法
- 7. 前端面試——算法題
- 8. 前端常見的面試題(七)
- 9. 前端（七）算法篇
- 10. 前端開發面試常用算法