算法题 字符串中的第一个唯一字符

387. 字符串中的第一个唯一字符

问题描述

给定一个字符串 s ，找到它的第一个不重复字符，并返回它的索引。如果不存在，则返回 -1。

示例：

输入: s = "leetcode"
输出: 0
解释: 'l' 是第一个不重复字符，索引为 0

输入: s = "loveleetcode"
输出: 2
解释: 'v' 是第一个不重复字符，索引为 2

输入: s = "aabb"
输出: -1
解释: 所有字符都重复出现，没有不重复字符

算法思路

两次遍历法：

1. 第一次遍历：统计每个字符的出现频次
2. 第二次遍历：按顺序查找第一个频次为1的字符，返回其索引
3. 如果没找到，返回-1

核心思想：

• 使用数组或哈希表记录字符频次
• 保持字符出现的原始顺序，在第二次遍历时找到第一个唯一字符
• 时间复杂度O(n)，空间复杂度O(1)（固定大小数组）

代码实现

方法一：数组频次统计（推荐）

class Solution {
    /**
     * 找到字符串中第一个不重复字符的索引
     * 
     * @param s 输入字符串（只包含小写字母）
     * @return 第一个不重复字符的索引，不存在返回-1
     * 时间复杂度: O(n)
     * 空间复杂度: O(1) - 固定26大小数组
     */
    public int firstUniqChar(String s) {
        // 创建频次数组，假设只包含小写字母
        int[] charCount = new int[26];  // a-z对应索引0-25
        
        // 第一次遍历：统计每个字符的出现次数
        for (char c : s.toCharArray()) {
            charCount[c - 'a']++;  // 字符转索引并增加计数
        }
        
        // 第二次遍历：找到第一个频次为1的字符
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (charCount[c - 'a'] == 1) {
                return i;  // 返回第一个唯一字符的索引
            }
        }
        
        // 没有找到不重复字符
        return -1;
    }
}

方法二：HashMap频次统计（通用解法）

import java.util.*;

class Solution {
    /**
     * 使用HashMap的通用解法（适用于任意字符集）
     * 
     * @param s 输入字符串
     * @return 第一个不重复字符的索引，不存在返回-1
     * 时间复杂度: O(n)
     * 空间复杂度: O(k) - k为不同字符数
     */
    public int firstUniqChar(String s) {
        // 使用LinkedHashMap保持插入顺序（虽然这里不需要，因为第二次遍历用原字符串）
        Map<Character, Integer> charCount = new HashMap<>();
        
        // 第一次遍历：统计每个字符的出现次数
        for (char c : s.toCharArray()) {
            charCount.put(c, charCount.getOrDefault(c, 0) + 1);
        }
        
        // 第二次遍历：找到第一个频次为1的字符
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (charCount.get(c) == 1) {
                return i;
            }
        }
        
        return -1;
    }
}

方法三：一次遍历 + 索引记录

class Solution {
    /**
     * 一次遍历：记录每个字符第一次出现的位置
     * 
     * @param s 输入字符串
     * @return 第一个不重复字符的索引，不存在返回-1
     * 时间复杂度: O(n)
     * 空间复杂度: O(1) - 固定大小数组
     */
    public int firstUniqChar(String s) {
        // freq[i] 存储字符 'a'+i 的出现次数
        int[] freq = new int[26];
        // firstIndex[i] 存储字符 'a'+i 第一次出现的索引
        int[] firstIndex = new int[26];
        
        // 初始化firstIndex为-1
        Arrays.fill(firstIndex, -1);
        
        // 一次遍历：统计频次并记录第一次出现位置
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            int index = c - 'a';
            freq[index]++;
            if (firstIndex[index] == -1) {
                firstIndex[index] = i;  // 只记录第一次出现的位置
            }
        }
        
        // 查找最小索引的唯一字符
        int minIndex = s.length();  // 初始化为字符串长度（最大可能值+1）
        for (int i = 0; i < 26; i++) {
            if (freq[i] == 1 && firstIndex[i] != -1) {
                minIndex = Math.min(minIndex, firstIndex[i]);
            }
        }
        
        // 如果minIndex未更新，说明没有唯一字符
        return minIndex == s.length() ? -1 : minIndex;
    }
}

算法分析

• 时间复杂度：
  • 所有方法：O(N)，N为字符串长度
  • 方法一和二：两次遍历，2N = O(N)
  • 方法三：一次遍历+N（查找最小索引），N+26 = O(N)
• 空间复杂度：
  • 方法一：O(1)，固定26大小数组
  • 方法二：O(K)，K为不同字符数
  • 方法三：O(1)，两个固定26大小数组
• 方法对比：
  • 方法一：最简洁高效，推荐使用
  • 方法二：通用性强，适用于任意字符集
  • 方法三：理论上一次遍历，但实际性能提升有限

算法过程

输入：s = "loveleetcode"

执行过程（方法一）：

1. 统计频次：
   • l: 2, o: 2, v: 1, e: 4, t: 1, c: 1, d: 1
   • charCount = [0,0,1,1,4,0,0,0,0,0,0,2,0,0,2,0,0,0,0,1,0,1,0,0,0,0]
   • （索引对应：c:2, d:3, e:4, l:11, o:14, t:19, v:21）
2. 第二次遍历：
   • i=0, ‘l’ → charCount[11]=2 ≠ 1
   • i=1, ‘o’ → charCount[14]=2 ≠ 1
   • i=2, ‘v’ → charCount[21]=1 → 返回2

测试用例

public static void main(String[] args) {
    Solution solution = new Solution();
    
    // 测试用例1：标准示例
    System.out.println("Test 1: " + solution.firstUniqChar("leetcode")); 
    // 输出: 0
    
    // 测试用例2：中间位置
    System.out.println("Test 2: " + solution.firstUniqChar("loveleetcode")); 
    // 输出: 2
    
    // 测试用例3：无唯一字符
    System.out.println("Test 3: " + solution.firstUniqChar("aabb")); 
    // 输出: -1
    
    // 测试用例4：单字符
    System.out.println("Test 4: " + solution.firstUniqChar("a")); 
    // 输出: 0
    
    // 测试用例5：所有字符唯一
    System.out.println("Test 5: " + solution.firstUniqChar("abcdef")); 
    // 输出: 0
    
    // 测试用例6：最后一个字符唯一
    System.out.println("Test 6: " + solution.firstUniqChar("aabbccde")); 
    // 输出: 6（'d'的索引）
    
    // 测试用例7：空字符串
    System.out.println("Test 7: " + solution.firstUniqChar("")); 
    // 输出: -1
    
    // 测试用例8：长字符串
    System.out.println("Test 8: " + solution.firstUniqChar("thequickbrownfoxjumpsoverthelazydog")); 
    // 输出: 3（'q'的索引）
    
    // 测试用例9：重复字符但有唯一字符
    System.out.println("Test 9: " + solution.firstUniqChar("aaabbbcccdef")); 
    // 输出: 9（'d'的索引）
    
    // 测试用例10：只有唯一字符在末尾
    System.out.println("Test 10: " + solution.firstUniqChar("aabbccd")); 
    // 输出: 6
}

关键点

1. 唯一字符定义：

   • 在整个字符串中只出现一次的字符
   • 不是局部唯一，而是全局唯一

2. 第一个的含义：

   • 按字符串从左到右的顺序
   • 即使后面有更"小"的字符，也要返回最左边的唯一字符

3. 频次统计：

   • 必须先完整统计所有字符频次
   • 不能在第一次遍历时就判断，因为后面可能还会出现相同字符

4. 字符集假设：

   • 题目说明"字符串只包含小写字母"，所以26大小数组足够
   • 如果字符集更大，可以扩展数组大小或使用HashMap

常见问题

1. 为什么不能在第一次遍历时就返回结果？

   • 因为在遍历过程中无法知道后面是否还会出现相同字符。例如在"abba"中，当遍历到第一个’a’时，不能确定它是否唯一，因为后面可能还有’a’。

2. 方法三相比方法一有什么优势？

   • 理论上减少了一次字符串遍历，但增加了查找最小索引的步骤
   • 实际性能差异很小，方法一更简洁易懂

3. 如果要求返回字符而不是索引怎么办？

   • 只需在找到索引后返回s.charAt(index)，如果没找到返回特殊字符或null

4. 如何处理大写字母或特殊字符？

   • 可以使用大小为128的数组（ASCII字符集）
   • 或使用HashMap支持任意字符集
   • 修改索引计算方式：对于ASCII，直接使用c作为索引（不需要减’a’）