JavaScript 面试备忘单 - 第 2 部分

常见 LeetCode 模式

// Two Pointers - In-place array modification
const modifyArray = (arr) => {
    let writePointer = 0;
    for (let readPointer = 0; readPointer  {
    let slow = head, fast = head;
    while (fast && fast.next) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow === fast) return true;
    }
    return false;
};

// Sliding Window - Fixed Size
const fixedSlidingWindow = (arr, k) => {
    let sum = 0;
    // Initialize first window
    for (let i = 0; i  {
    let start = 0, sum = 0, minLen = Infinity;

    for (let end = 0; end = target) {
            minLen = Math.min(minLen, end - start + 1);
            sum -= arr[start];
            start++;
        }
    }

    return minLen === Infinity ? 0 : minLen;
};

// BFS - Level Order Traversal
const levelOrder = (root) => {
    if (!root) return [];
    const result = [];
    const queue = [root];

    while (queue.length) {
        const levelSize = queue.length;
        const currentLevel = [];

        for (let i = 0; i  {
    const result = [];

    const traverse = (node) => {
        if (!node) return;

        // Pre-order
        result.push(node.val);

        traverse(node.left);
        // In-order would be here
        traverse(node.right);
        // Post-order would be here
    };

    traverse(root);
    return result;
};

// Backtracking Template
const backtrack = (nums) => {
    const result = [];

    const bt = (path, choices) => {
        if (/* ending condition */) {
            result.push([...path]);
            return;
        }

        for (let i = 0; i  {
    const dp = new Array(n + 1).fill(0);
    dp[0] = 1; // Base case

    for (let i = 1; i  {
    const memo = new Map();

    const dp = (n) => {
        if (n  {
    const stack = []; // [index, value]
    const result = new Array(arr.length).fill(-1);

    for (let i = 0; i  arr[i]) {
            const [prevIndex, _] = stack.pop();
            result[prevIndex] = i - prevIndex;
        }
        stack.push([i, arr[i]]);
    }
    return result;
};

// Prefix Sum
const prefixSum = (arr) => {
    const prefix = [0];
    for (let i = 0; i  {
    let left = 0, right = arr.length;
    while (left  {
    let left = 0, right = arr.length;
    while (left  i);
        this.rank = new Array(n).fill(0);
    }

    find(x) {
        if (this.parent[x] !== x) {
            this.parent[x] = this.find(this.parent[x]); // Path compression
        }
        return this.parent[x];
    }

    union(x, y) {
        let rootX = this.find(x);
        let rootY = this.find(y);

        if (rootX !== rootY) {
            if (this.rank[rootX] 



<h2>
  
  
  常见的时间/空间复杂度模式
</h2>



<pre class="brush:php;toolbar:false">// O(1) - Constant
Array.push(), Array.pop(), Map.set(), Map.get()

// O(log n) - Logarithmic
Binary Search, Balanced BST operations

// O(n) - Linear
Array traversal, Linear Search

// O(n log n) - Linearithmic
Efficient sorting (Array.sort())

// O(n²) - Quadratic
Nested loops, Simple sorting algorithms

// O(2ⁿ) - Exponential
Recursive solutions without memoization

以上是JavaScript 面试备忘单 - 第 2 部分的详细内容。更多信息请关注PHP中文网其他相关文章！