陣列是電腦科學中的基本資料結構，廣泛應用於各種演算法和問題解決場景。這份綜合指南將帶您了解 JavaScript 中陣列操作的基礎知識，涵蓋從基礎到進階的主題。我們將探索遍歷、插入、刪除、搜尋等，以及它們的時間複雜度和實際範例。
陣列是儲存在連續記憶體位置的元素的集合。在 JavaScript 中，陣列是動態的，可以保存不同類型的元素。
基本數組操作：
// Creating an array let arr = [1, 2, 3, 4, 5]; // Accessing elements console.log(arr[0]); // Output: 1 // Modifying elements arr[2] = 10; console.log(arr); // Output: [1, 2, 10, 4, 5] // Getting array length console.log(arr.length); // Output: 5
時間複雜度：
遍歷意味著存取陣列的每個元素一次。在 JavaScript 中，有許多方法可以遍歷陣列。
let arr = [1, 2, 3, 4, 5];
for (let i = 0; i < arr.length; i++) {
console.log(arr[i]);
}
時間複雜度：O(n)，其中 n 是數組中元素的數量。
let arr = [1, 2, 3, 4, 5]; arr.forEach(element => console.log(element));
時間複雜度：O(n)
let arr = [1, 2, 3, 4, 5];
for (let element of arr) {
console.log(element);
}
時間複雜度：O(n)
可以在陣列的開頭、結尾或特定位置插入。
let arr = [1, 2, 3]; arr.push(4); console.log(arr); // Output: [1, 2, 3, 4]
時間複雜度：O(1)（攤提）
let arr = [1, 2, 3]; arr.unshift(0); console.log(arr); // Output: [0, 1, 2, 3]
時間複雜度：O(n)，因為所有現有元素都需要移動
let arr = [1, 2, 4, 5]; arr.splice(2, 0, 3); console.log(arr); // Output: [1, 2, 3, 4, 5]
時間複雜度：O(n)，因為插入點之後的元素需要移動
與插入類似，刪除可以在開頭、結尾或特定位置進行。
let arr = [1, 2, 3, 4]; arr.pop(); console.log(arr); // Output: [1, 2, 3]
時間複雜度：O(1)
let arr = [1, 2, 3, 4]; arr.shift(); console.log(arr); // Output: [2, 3, 4]
時間複雜度：O(n)，因為所有剩餘元素都需要移位
let arr = [1, 2, 3, 4, 5]; arr.splice(2, 1); console.log(arr); // Output: [1, 2, 4, 5]
時間複雜度：O(n)，因為刪除點之後的元素需要移位
搜尋是對陣列執行的常見操作。讓我們看看一些搜尋技巧。
function linearSearch(arr, target) {
for (let i = 0; i < arr.length; i++) {
if (arr[i] === target) return i;
}
return -1;
}
let arr = [1, 3, 5, 7, 9];
console.log(linearSearch(arr, 5)); // Output: 2
console.log(linearSearch(arr, 6)); // Output: -1
時間複雜度：O(n)
function binarySearch(arr, target) {
let left = 0, right = arr.length - 1;
while (left <= right) {
let mid = Math.floor((left + right) / 2);
if (arr[mid] === target) return mid;
if (arr[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}
let arr = [1, 3, 5, 7, 9];
console.log(binarySearch(arr, 5)); // Output: 2
console.log(binarySearch(arr, 6)); // Output: -1
時間複雜度：O(log n)
現在讓我們來探索一些更進階的陣列操作技術。
兩指針技術經常被用來有效地解決數組問題。這是使用兩個指標就地反轉數組的範例：
function reverseArray(arr) {
let left = 0, right = arr.length - 1;
while (left < right) {
[arr[left], arr[right]] = [arr[right], arr[left]];
left++;
right--;
}
}
let arr = [1, 2, 3, 4, 5];
reverseArray(arr);
console.log(arr); // Output: [5, 4, 3, 2, 1]
時間複雜度：O(n)
滑動視窗技術對於解決子數組問題很有用。下面是一個尋找大小為 k 的最大和子數組的範例：
function maxSumSubarray(arr, k) {
let maxSum = 0;
let windowSum = 0;
// Calculate sum of first window
for (let i = 0; i < k; i++) {
windowSum += arr[i];
}
maxSum = windowSum;
// Slide the window
for (let i = k; i < arr.length; i++) {
windowSum = windowSum - arr[i - k] + arr[i];
maxSum = Math.max(maxSum, windowSum);
}
return maxSum;
}
let arr = [1, 4, 2, 10, 23, 3, 1, 0, 20];
console.log(maxSumSubarray(arr, 4)); // Output: 39
時間複雜度：O(n)
Kadane 演算法用於尋找數組中的最大子數組和。這是一個動態規劃的例子：
function kadane(arr) {
let maxSoFar = arr[0];
let maxEndingHere = arr[0];
for (let i = 1; i < arr.length; i++) {
maxEndingHere = Math.max(arr[i], maxEndingHere + arr[i]);
maxSoFar = Math.max(maxSoFar, maxEndingHere);
}
return maxSoFar;
}
let arr = [-2, -3, 4, -1, -2, 1, 5, -3];
console.log(kadane(arr)); // Output: 7
時間複雜度：O(n)
此演算法用於對僅包含 0、1 和 2 的陣列進行排序：
function dutchNationalFlag(arr) {
let low = 0, mid = 0, high = arr.length - 1;
while (mid <= high) {
if (arr[mid] === 0) {
[arr[low], arr[mid]] = [arr[mid], arr[low]];
low++;
mid++;
} else if (arr[mid] === 1) {
mid++;
} else {
[arr[mid], arr[high]] = [arr[high], arr[mid]];
high--;
}
}
}
let arr = [2, 0, 1, 2, 1, 0];
dutchNationalFlag(arr);
console.log(arr); // Output: [0, 0, 1, 1, 2, 2]
時間複雜度：O(n)
這裡有 50 個練習題，從簡單到進階。其中一些來自 LeetCode，而另一些則是常見的陣列操作場景：
這裡有 20 道 LeetCode 問題來測試你的陣列操作技能：
透過解決這些問題並理解基本概念，您將顯著提高 JavaScript 中資料結構和演算法的陣列操作技能。
請記住，掌握這些技術的關鍵是持續練習並理解解決方案的時間和空間複雜性。
編碼愉快！
以上是使用 JavaScript 掌握 DSA 中的陣列操作：從基礎到高級的詳細內容。更多資訊請關注PHP中文網其他相關文章！
