滑动窗口与链表操作：算法实战解析

1. 无重复字符的最长子串问题解析

1.1 问题描述与核心思路

给定一个字符串s，找出其中不含有重复字符的最长子串的长度。这道题是字符串处理中的经典问题，考察对滑动窗口和哈希表的综合运用能力。

核心思路是维护一个滑动窗口，窗口内的字符都是不重复的。通过不断调整窗口的左右边界，找到最大的窗口大小。具体实现时，使用哈希表记录每个字符最后一次出现的位置，当遇到重复字符时，快速调整窗口左边界。

1.2 代码实现与详细解析

java复制public int lengthOfLongestSubstring(String s) {
    if(s.length()==0){
        return 0;
    }
    HashMap<Character,Integer> map=new HashMap<>();
    int max=0,left=0;
    for(int i=0;i<s.length();i++){
        if(map.containsKey(s.charAt(i))){
            left=Math.max(left,map.get(s.charAt(i))+1);
        }
        map.put(s.charAt(i),i);
        max=Math.max(max,i-left+1);
    }
    return max;
}

关键点解析：

1. left表示窗口的左边界，i表示窗口的右边界
2. 哈希表存储字符及其最后一次出现的索引
3. 当遇到重复字符时，left更新为重复字符上次出现位置的下一个位置
4. 每次迭代都计算当前窗口大小并更新最大值

注意：这里使用Math.max(left, map.get(s.charAt(i))+1)是为了确保left不会回退。比如字符串"abba"，当i=3时，如果不取最大值，left会从2回退到1。

1.3 时间复杂度与空间复杂度分析

时间复杂度：O(n)，其中n是字符串长度。每个字符最多被访问两次（一次放入哈希表，一次检查是否重复）。

空间复杂度：O(min(m, n))，其中m是字符集大小。最坏情况下需要存储所有不同字符。

1.4 常见变种与扩展

1. 返回最长子串本身而非长度
2. 允许最多k个重复字符的最长子串
3. 处理Unicode字符而非ASCII字符

2. 反转链表Ⅱ问题详解

2.1 问题描述与基本思路

给定单链表的头指针head和两个整数left和right（left ≤ right），反转从位置left到位置right的链表节点，返回反转后的链表。

基本思路是找到需要反转的子链表，进行反转，然后重新连接。使用虚拟头节点可以简化边界条件处理。

2.2 代码实现与逐步解析

java复制public ListNode reverseBetween(ListNode head, int left, int right) {
    ListNode dummy=new ListNode(-1);
    dummy.next=head;
    ListNode pre=dummy;
    for(int i=1;i<left;i++){
        pre=pre.next;
    }
    ListNode cur=pre.next;
    ListNode next;
    for(int i=0;i<right-left;i++){
        next =cur.next;
        cur.next=next.next;
        next.next=pre.next;
        pre.next=next;
    }
    return dummy.next;
}

关键步骤解析：

1. 创建虚拟头节点dummy，简化头节点处理
2. pre指针移动到反转区间的前一个节点
3. cur指针指向需要反转的第一个节点
4. 通过right-left次循环，每次将cur.next节点插入到pre之后
5. 最终返回dummy.next

2.3 图解反转过程

以链表1→2→3→4→5，left=2，right=4为例：

初始状态：
dummy→1→2→3→4→5
pre指向1，cur指向2

第一次循环：

• next=3
• 2.next=4
• 3.next=2
• pre.next=3
  结果：dummy→1→3→2→4→5

第二次循环：

• next=4
• 2.next=5
• 4.next=3
• pre.next=4
  结果：dummy→1→4→3→2→5

2.4 边界条件与注意事项

1. left=1时，需要反转从头部开始的子链表
2. right等于链表长度时，需要反转直到末尾
3. left=right时，不需要任何操作
4. 链表为空或只有一个节点时直接返回

提示：在实际面试中，建议先画出链表变化的示意图，再编写代码，可以大大减少出错概率。

3. 删除排序链表中的重复元素Ⅱ

3.1 问题描述与解决思路

给定一个已排序的链表，删除所有含有重复数字的节点，只保留原始链表中没有重复出现的数字。

解决思路：

1. 使用虚拟头节点简化操作
2. 维护前驱指针和当前指针
3. 当发现重复节点时，跳过所有重复节点
4. 需要特别注意连续多个重复的情况

3.2 代码实现与解析

java复制public ListNode deleteDuplicates(ListNode head) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode prev = dummy;
    ListNode curr = head;
    
    while (curr != null) {
        while (curr.next != null && curr.val == curr.next.val) {
            curr = curr.next;
        }
        if (prev.next == curr) {
            prev = prev.next;
        } else {
            prev.next = curr.next;
        }
        curr = curr.next;
    }
    return dummy.next;
}

关键点：

1. 外层循环遍历整个链表
2. 内层循环跳过所有重复节点
3. 如果prev.next等于curr，说明没有重复，移动prev
4. 否则，跳过重复节点

3.3 复杂度分析与优化

时间复杂度：O(n)，每个节点最多被访问两次
空间复杂度：O(1)，只使用了常数个额外指针

优化方向：

1. 可以提前判断链表是否有序，无序时直接返回
2. 对于特别长的链表，可以考虑并行处理

4. 重排链表问题解析

4.1 问题描述与基本思路

给定一个单链表L的头节点head，将其重新排列为：L0→Ln→L1→Ln-1→L2→Ln-2→...

解决思路：

1. 找到链表中点（快慢指针）
2. 反转后半部分链表
3. 合并前后两部分链表

4.2 代码实现与详细步骤

java复制public void reorderList(ListNode head) {
    if (head == null || head.next == null) return;
    
    // 1. 找到中点
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    
    // 2. 反转后半部分
    ListNode prev = null, curr = slow, tmp;
    while (curr != null) {
        tmp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = tmp;
    }
    
    // 3. 合并两个链表
    ListNode first = head, second = prev;
    while (second.next != null) {
        tmp = first.next;
        first.next = second;
        first = tmp;
        
        tmp = second.next;
        second.next = first;
        second = tmp;
    }
}

4.3 快慢指针找中点的技巧

快慢指针是链表问题中的常用技巧：

• 快指针每次走两步，慢指针每次走一步
• 当快指针到达末尾时，慢指针正好在中点
• 对于偶数长度链表，慢指针会停在中间偏右的位置

注意：不同的题目可能对中点的定义不同，比如要求偶数长度时返回第一个中点还是第二个中点，这会影响循环条件的设置。

4.4 链表反转的多种实现方式

链表反转是基本功，常见的实现方式有：

1. 迭代法（如上所示）
2. 递归法：

java复制public ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) return head;
    ListNode p = reverseList(head.next);
    head.next.next = head;
    head.next = null;
    return p;
}

3. 头插法：

java复制public ListNode reverseList(ListNode head) {
    ListNode dummy = new ListNode(-1);
    while (head != null) {
        ListNode next = head.next;
        head.next = dummy.next;
        dummy.next = head;
        head = next;
    }
    return dummy.next;
}

5. 最长公共前缀问题解析

5.1 问题描述与基本思路

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。

基本思路：

1. 先找出最短字符串的长度
2. 逐个字符比较所有字符串
3. 当发现不匹配时停止

5.2 代码实现与优化

java复制public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) return "";
    
    String prefix = strs[0];
    for (int i = 1; i < strs.length; i++) {
        while (strs[i].indexOf(prefix) != 0) {
            prefix = prefix.substring(0, prefix.length() - 1);
            if (prefix.isEmpty()) return "";
        }
    }
    return prefix;
}

优化方向：

1. 先排序数组，只需比较第一个和最后一个字符串
2. 使用二分查找法优化比较过程
3. 并行处理多个字符串的比较

5.3 边界条件与特殊处理

1. 空数组或空字符串的处理
2. 数组中只有一个字符串的情况
3. 所有字符串完全相同的情况
4. 完全没有公共前缀的情况

5.4 时间复杂度分析

最坏时间复杂度：O(S)，其中S是所有字符串中字符的总数
最好时间复杂度：O(minLen * n)，其中minLen是最短字符串长度，n是字符串数量

在实际面试中，建议先提出最直观的解法，然后讨论可能的优化方向，展示你的思考过程。