深入解析前端核心技术与算法实现

1dp[node] = node.val + min(dp[left], dp[right])

1function minPathSumOptimized(root) {
2    const memo = new Map();
3    
4    function dfs(node) {
5        if (!node) return Infinity;
6        if (!node.left && !node.right) return node.val;
7        if (memo.has(node)) return memo.get(node);
8        
9        const minSum = node.val + Math.min(dfs(node.left), dfs(node.right));
10        memo.set(node, minSum);
11        return minSum;
12    }
13    
14    return dfs(root);
15}

1function getChildrenIndex(idx) {
2    let nextLevel = 0;
3    while (tree[idx + nextLevel] === null) nextLevel++;
4    return [2*(idx+nextLevel)+1, 2*(idx+nextLevel)+2];
5}

1class MyPromise {
2    constructor(executor) {
3        // ...初始化状态
4        try {
5            executor(resolve.bind(this), reject.bind(this));
6        } catch (e) {
7            reject.call(this, e);
8        }
9    }
10
11    then(onFulfilled, onRejected) {
12        const newPromise = new MyPromise((resolve, reject) => {
13            const microTask = () => {
14                try {
15                    const x = (this.state === 'fulfilled') 
16                        ? (onFulfilled || (v => v))(this.value)
17                        : (onRejected || (e => { throw e }))(this.reason);
18                    resolvePromise(newPromise, x, resolve, reject);
19                } catch (e) {
20                    reject(e);
21                }
22            };
23            
24            if (this.state !== 'pending') {
25                queueMicrotask(microTask);
26            } else {
27                this.callbacks.push(microTask);
28            }
29        });
30        
31        return newPromise;
32    }
33}
34
35function resolvePromise(promise, x, resolve, reject) {
36    // 处理thenable对象和循环引用
37}

1function flat(arr, depth = 1) {
2    const stack = [...arr.map(item => [item, depth])];
3    const result = [];
4    
5    while (stack.length) {
6        const [item, currentDepth] = stack.pop();
7        if (Array.isArray(item) && currentDepth > 0) {
8            stack.push(...item.map(sub => [sub, currentDepth - 1]));
9        } else {
10            result.unshift(item); // 保持原顺序
11        }
12    }
13    
14    return result;
15}