比較數組中的相鄰元素並選擇每對中較小的

Question

我正在做一個 JS 算法課程。 以下是教師針對一個問題的解決方案，該解決方案運行成功：

 function arrayPreviousLess(items) { const lessThanList = [] for (let i = items.length - 1; i >= 0; i--) { for (let j = i; j >= 0; j--) { if (items[i] > items[j]) { lessThanList.unshift(items[j]) break } else if (j === 0) { lessThanList.unshift(-1) } } } return lessThanList } console.log(arrayPreviousLess([3, 5, 2, 4, 5]))

此代碼比較相鄰的數組項。 如果前一項小於下一項，則返回較小的。 由於 false，它必須返回 -1，如下例所示：

輸入：

[3,5,2,4,5] 

輸出：

[-1,3,-1,2,4]

我理解一切，除了在循環中break的目的是什么？ 當我刪除此break它的工作方式相同。

Answer 1

鑒於相鄰對的問題描述，您展示的算法沒有多大意義。 除了break之外，沒有理由使用嵌套循環，除非意圖是將每個元素與其先前的所有元素進行比較，在這種情況下它是正確的。 無論哪種方式， unshift都比push慢得多，而且無論算法如何，我都沒有理由求助於這個函數，我也沒有看到反向外循環背后的推理。

我會使用map為相鄰對編寫函數。 我們可以在一次迭代中做到這一點。

 const arrayPreviousLess = a => a.map((e, i) => a[i-1] < e ? a[i-1] : -1); [ [3, 5, 2, 4, 5], [1], [1, 2], [2, 1], [1, 2, 3], [3, 2, 1], [3, 2, 3], [3, 1, 6, 4, 5], ].forEach(e => console.log(`[${e}] => [${arrayPreviousLess(e)}]`));

另一方面，如果問題是將每個元素與其左側的所有元素進行比較，我會修改講師的解決方案，以至少避免unshift並從前到后遍歷參數數組。

 const arrayPreviousLess = a => a.map((e, i) => { while (i--) { if (a[i] < e) return a[i]; } return -1; }); [ [3, 5, 2, 4, 5], [1], [1, 2], [2, 1], [1, 2, 3], [3, 2, 1], [3, 2, 3], [3, 1, 6, 4, 5], ].forEach(e => console.log(`[${e}] => [${arrayPreviousLess(e)}]`));

該算法仍然是二次的，但有一個使用堆棧的線性算法。 對於每個元素，當堆棧不為空且當前元素小於堆棧頂部時，彈出堆棧。 最終，堆棧要么變空，要么其頂部將包含前一個較小的元素。 如果堆棧變空，則將元素映射到 -1，否則將元素映射到前一個較小的元素。 最后，將當前元素壓入堆棧。

 const arrayPreviousLess = a => { const stack = []; return a.map(e => { while (stack.length && e < stack[stack.length-1]) { stack.pop(); } return stack.push(e) > 1 ? stack[stack.length-2] : -1; }); }; [ [3, 5, 2, 4, 5], [1], [1, 2], [2, 1], [1, 2, 3], [3, 2, 1], [3, 2, 3], [3, 1, 6, 4, 5], ].forEach(e => console.log(`[${e}] => [${arrayPreviousLess(e)}]`));

這背后的直覺是，當前元素后面的任何大於它的先前元素永遠不會是先前最小的候選元素。 我們可以丟棄它們。 從本質上講，我們會保留最小元素候選的歷史記錄，一旦我們能保證在它之前有一些更小的元素，就會立即刪除任何候選元素。