Beherrschen der Array-Manipulation in DSA mit JavaScript: Von den Grundlagen bis zu Fortgeschrittenen

Beherrschen der Array-Manipulation in JavaScript für DSA

Arrays sind grundlegende Datenstrukturen in der Informatik und werden häufig in verschiedenen Algorithmen und Problemlösungsszenarien verwendet. Dieser umfassende Leitfaden führt Sie durch die Grundlagen der Array-Manipulation in JavaScript und deckt Themen von der Grundstufe bis zur Fortgeschrittenenstufe ab. Wir werden Traversal, Einfügen, Löschen, Suchen und mehr sowie deren zeitliche Komplexität und praktische Beispiele untersuchen.

Inhaltsverzeichnis

1. Einführung in Arrays
2. Array-Traversierung
3. Einfügung in Arrays
4. Löschen in Arrays
5. Suchen in Arrays
6. Erweiterte Array-Manipulationstechniken
7. Übungsprobleme
8. Links zu LeetCode-Problemen

1. Einführung in Arrays

Ein Array ist eine Sammlung von Elementen, die an zusammenhängenden Speicherorten gespeichert sind. In JavaScript sind Arrays dynamisch und können Elemente unterschiedlichen Typs enthalten.

Grundlegende Array-Operationen:

// 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

Zeitkomplexität:

• Zugriff auf Elemente: O(1)
• Modifizierende Elemente: O(1)
• Array-Länge abrufen: O(1)

2. Array-Durchquerung

Traversal bedeutet, jedes Element des Arrays einmal zu besuchen. Es gibt mehrere Möglichkeiten, ein Array in JavaScript zu durchlaufen.

2.1 Verwendung einer for-Schleife

let arr = [1, 2, 3, 4, 5];
for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]);
}

Zeitkomplexität: O(n), wobei n die Anzahl der Elemente im Array ist.

2.2 Verwendung von forEach

let arr = [1, 2, 3, 4, 5];
arr.forEach(element => console.log(element));

Zeitkomplexität: O(n)

2.3 Verwendung der for...of-Schleife

let arr = [1, 2, 3, 4, 5];
for (let element of arr) {
    console.log(element);
}

Zeitkomplexität: O(n)

3. Einfügen in Arrays

Das Einfügen in Arrays kann am Anfang, am Ende oder an einer bestimmten Position erfolgen.

3.1 Einfügung am Ende

let arr = [1, 2, 3];
arr.push(4);
console.log(arr); // Output: [1, 2, 3, 4]

Zeitkomplexität: O(1) (amortisiert)

3.2 Einfügung am Anfang

let arr = [1, 2, 3];
arr.unshift(0);
console.log(arr); // Output: [0, 1, 2, 3]

Zeitkomplexität: O(n), da alle vorhandenen Elemente verschoben werden müssen

3.3 Einfügen an einer bestimmten Position

let arr = [1, 2, 4, 5];
arr.splice(2, 0, 3);
console.log(arr); // Output: [1, 2, 3, 4, 5]

Zeitkomplexität: O(n), da Elemente nach dem Einfügepunkt verschoben werden müssen

4. Löschen in Arrays

Ähnlich wie beim Einfügen kann das Löschen am Anfang, am Ende oder an einer bestimmten Position durchgeführt werden.

4.1 Löschung vom Ende

let arr = [1, 2, 3, 4];
arr.pop();
console.log(arr); // Output: [1, 2, 3]

Zeitkomplexität: O(1)

4.2 Löschung von Anfang an

let arr = [1, 2, 3, 4];
arr.shift();
console.log(arr); // Output: [2, 3, 4]

Zeitkomplexität: O(n), da alle verbleibenden Elemente verschoben werden müssen

4.3 Löschung an einer bestimmten Position

let arr = [1, 2, 3, 4, 5];
arr.splice(2, 1);
console.log(arr); // Output: [1, 2, 4, 5]

Zeitkomplexität: O(n), da Elemente nach dem Löschpunkt verschoben werden müssen

5. Suchen in Arrays

Suchen ist ein häufiger Vorgang, der an Arrays durchgeführt wird. Schauen wir uns einige Suchtechniken an.

5.1 Lineare Suche

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

Zeitkomplexität: O(n)

5.2 Binäre Suche (für sortierte Arrays)

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

Zeitkomplexität: O(log n)

6. Fortgeschrittene Array-Manipulationstechniken

Lassen Sie uns nun einige fortgeschrittenere Techniken zur Array-Manipulation erkunden.

6.1 Zwei-Zeiger-Technik

Die Zwei-Zeiger-Technik wird häufig verwendet, um Array-Probleme effizient zu lösen. Hier ist ein Beispiel für die Verwendung von zwei Zeigern zum direkten Umkehren eines Arrays:

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]

Zeitkomplexität: O(n)

6.2 Schiebefenstertechnik

Die Schiebefenstertechnik ist nützlich zum Lösen von Subarray-Problemen. Hier ist ein Beispiel, um das maximale Summen-Subarray der Größe k zu finden:

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

Zeitkomplexität: O(n)

6.3 Kadanes Algorithmus

Kadanes Algorithmus wird verwendet, um die maximale Subarray-Summe in einem Array zu ermitteln. Es ist ein Beispiel für dynamische Programmierung:

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

Zeitkomplexität: O(n)

6.4 Niederländischer Nationalflaggen-Algorithmus

Dieser Algorithmus wird verwendet, um ein Array zu sortieren, das nur Nullen, Einsen und Zweien enthält:

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]

Zeitkomplexität: O(n)

7. Übungsprobleme

Hier sind 50 Übungsaufgaben von leicht bis fortgeschritten. Einige davon stammen von LeetCode, während andere gängige Array-Manipulationsszenarien sind:

1. 对数组中的所有元素求和
2. 查找数组中的最大元素
3. 就地反转数组
4. 从排序数组中删除重复项
5. 将数组旋转 k 步
6. 查找数组中第二大的元素
7. 合并两个排序数组
8. 在 1 到 n 的数组中查找缺失的数字
9. 将所有零移至数组末尾
10. 求两个数组的交集
11. 求两个数组的并集
12. 检查一个数组是否是另一个数组的子集
13. 查找数组中的平衡索引
14. 重新排列数组中的正数和负数
15. 查找数组中的多数元素
16. 查找数组中的峰值元素
17. 实现圆形数组
18. 查找数组中最小的正缺失数
19. 收集雨水问题
20. 使用数组实现堆栈
21. 使用数组实现队列
22. 找到最长的递增子序列
23. 在旋转排序数组中实现二分查找
24. 求大小为 k 的子数组的最大和
25. 实现 Kadane 算法
26. 求火车站所需的最少站台数量
27. 找到 0 和 1 数量相等的最长子数组
28. 实现荷兰国旗算法
29. 找到总和大于给定值的最小子数组
30. 实施 Boyer-Moore 多数投票算法
31. 找到最大乘积子数组
32. 实现跳跃游戏算法
33. 为数组中的每个元素查找下一个更大的元素
34. 实现滑动窗口最大值算法
35. 找到最长的没有重复字符的子串
36. 实现合并间隔算法
37. 找到到达数组末尾的最小跳转次数
38. 实施股票买入卖出以最大化利润算法
39. 找到最长的回文子串
40. 实现最长公共子序列算法
41. 找到最短的未排序连续子数组
42. 实现水最多的容器算法
43. 查找数组中最长的连续序列
44. 实现三数最大乘积算法
45. 查找数组中第 K 个最大的元素
46. 实现查找数组中的所有重复项算法
47. 求最小子数组和
48. 实现除自身之外的数组的乘积算法
49. 查找排序数组中的最大间隙
50. 实现两个排序数组的中值算法

8.LeetCode问题链接

这里有 20 道 LeetCode 问题来测试你的数组操作技能：

1. 两和
2. 买卖股票的最佳时机
3. 包含重复
4. 除自身之外的数组的乘积
5. 最大子数组
6. 合并间隔
7. 3Sum
8. 装最多水的容器
9. 旋转数组
10. 在旋转排序数组中搜索
11. 查找旋转排序数组中的最小值
12. 下一个排列
13. 子数组和等于 K
14. 螺旋矩阵
15. 跳跃游戏
16. 最长连续序列
17. 查找数组中的所有重复项
18. 数组中的第 K 个最大元素
19. 收集雨水
20. 两个排序数组的中值

通过解决这些问题并理解基本概念，您将显着提高 JavaScript 中数据结构和算法的数组操作技能。

请记住，掌握这些技术的关键是持续练习并理解解决方案的时间和空间复杂性。

编码愉快！

Das obige ist der detaillierte Inhalt vonBeherrschen der Array-Manipulation in DSA mit JavaScript: Von den Grundlagen bis zu Fortgeschrittenen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!