算法问题解析：从基础到进阶算法问题解析：从基础到进阶在算法学习的道路上，我们经常会遇到各种有趣且富有挑战性的问题。本文

算法问题解析：从基础到进阶

在算法学习的道路上，我们经常会遇到各种有趣且富有挑战性的问题。本文将深入探讨三个经典算法问题：最长回文子串、三数之和、以及移除元素。我们将剖析每个问题的核心思想，并提供详细的解决方案。

1. 最长回文子串

问题描述

给定一个字符串 s，找到 s 中最长的回文子串。

核心思想

回文串具有对称性，可以从中心向两边扩展
需要考虑奇数和偶数长度的回文串

解决方案：中心扩展法

function longestPalindrome(s) {
    if (s.length < 2) return s;
    
    let start = 0;
    let maxLength = 1;
    
    function expandAroundCenter(left, right) {
        while (left >= 0 && right < s.length && s[left] === s[right]) {
            const currentLength = right - left + 1;
            if (currentLength > maxLength) {
                start = left;
                maxLength = currentLength;
            }
            left--;
            right++;
        }
    }
    
    for (let i = 0; i < s.length; i++) {
        expandAroundCenter(i, i);     // 奇数长度
        expandAroundCenter(i, i + 1); // 偶数长度
    }
    
    return s.substring(start, start + maxLength);
}

算法分析

时间复杂度：O(n²)，其中 n 是字符串长度
空间复杂度：O(1)，只使用常数级别的额外空间

为什么不使用滑动窗口或 Map/Set？

回文串问题主要依赖于字符的对称性质
滑动窗口通常用于需要维护连续区间内状态的问题
Map/Set 通常用于需要快速查找或去重的场景

2. 三数之和

问题描述

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0？请找出所有和为 0 且不重复的三元组。

核心思想

排序 + 双指针
固定一个数，然后在剩余数组中寻找两数之和

解决方案

var threeSum = function(nums) {
    const result = [];
    if (nums.length < 3) return result;
    
    nums.sort((a, b) => a - b);
    
    for (let i = 0; i < nums.length - 2; i++) {
        if (i > 0 && nums[i] === nums[i - 1]) continue;
        
        let left = i + 1;
        let right = nums.length - 1;
        
        while (left < right) {
            const sum = nums[i] + nums[left] + nums[right];
            
            if (sum === 0) {
                result.push([nums[i], nums[left], nums[right]]);
                
                while (left < right && nums[left] === nums[left + 1]) left++;
                while (left < right && nums[right] === nums[right - 1]) right--;
                
                left++;
                right--;
            } else if (sum < 0) {
                left++;
            } else {
                right--;
            }
        }
    }
    
    return result;
};

算法分析

时间复杂度：O(n²)，其中 n 是数组长度
空间复杂度：O(1)，不考虑存储结果所需的空间

关键点解析

为什么使用 i < nums.length - 2？
- 确保在 i 之后还有至少两个数可供选择
- i 是第一个数，left 是第二个数（i+1），right 是第三个数（最后一个元素）
为什么需要多次跳过重复？
- 跳过重复的起始点(i)：避免产生重复的三元组
- 跳过重复的左指针(left)：避免使用重复的第二个数
- 跳过重复的右指针(right)：避免使用重复的第三个数
- 这些操作共同确保结果中不会出现重复的三元组

3. 移除元素

问题描述

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

核心思想

原地算法（不创建新数组）
双指针技巧

解决方案

var removeElement = function(nums, val) {
    let k = 0; // k 表示新数组的长度
    
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== val) {
            nums[k] = nums[i];
            k++;
        }
    }
    
    return k;
};

算法分析

时间复杂度：O(n)，其中 n 是数组长度
空间复杂度：O(1)，只使用了常数额外空间

关键点解析

原地修改：直接在原数组上操作，不创建新的数组
双指针技巧：
- k 作为慢指针，指向应该放置元素的位置
- i 作为快指针，遍历整个数组
返回值 k 代表新数组的长度，也是保留下来的元素个数

总结

这三个问题展示了不同的算法思想和技巧：

最长回文子串 - 利用字符串的对称性，使用中心扩展法
三数之和 - 排序后使用双指针，注重去重处理
移除元素 - 原地算法，使用双指针技巧

在解决算法问题时，关键是要理解问题的本质，选择合适的数据结构和算法思想。同时，要注意处理边界情况，优化时间和空间复杂度。希望这篇文章能够帮助你更好地理解这些经典算法问题，并在实际编码中灵活运用这些思想和技巧。