[LeetCode] 字符串+ 字符串中的第一个唯一字符

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

案例:

s = "leetcode"
返回 0.

s = "loveleetcode",
返回 2.

 

注意事项：您可以假定该字符串只包含小写字母。

import java.util.Set;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ArrayList;
import java.lang.String;

class Solution {	
	/* 利用flag数组记录每个字符是否有重复，有则对应flag=1，否则flag=0
	 * 返回第一个flag=0的索引号，即字符串中第一个唯一字符的索引
	 * 时间复杂度o(26n)
	 * 空间复杂度o(n)
	 * 执行用时 : 64 ms, 在所有 Java 提交中击败了36.55%的用户
	 * 内存消耗 :47.8 MB, 在所有 Java 提交中击败了43.94%的用户
	 */
	public static int firstUniqueChar0(String word) {
		int[] flag=new int[word.length()];
		int index=-1;
		for(int i=0;i<word.length();i++) {
			if(flag[i]==0) {
				for(int j=i+1;j<word.length();j++) {
					if(word.charAt(i)==word.charAt(j)) {
						flag[i]=1;
						flag[j]=1;
					}
				}	
			}
		}
		for(int i=0;i<flag.length;i++) {
			if (flag[i]==0){
				index=i;
				return index;
			}
		}
		return index;
	}
	
	/* 建立一个长26的整数数组，a-z字符的索引为97-123，对其做减26的处理即可得在数组中的索引
	 * 计数a-z出现的次数，遍历字符串的字符对应数组的值，第一个取1的即为第一个唯一字符
	 * 时间复杂度o(n)
	 * 空间复杂度o(26)
	 * 执行用时 :26 ms, 在所有 Java 提交中击败了56.02%的用户
	 * 内存消耗 :48.6 MB, 在所有 Java 提交中击败了35.00%的用户
	 */
	public static int firstUniqueChar1(String word) {
		int[] nums=new int[26];
		int index=-1;
		for(int i=0;i<word.length();i++) {
			nums[word.charAt(i)-97]++;
		}
		for(int i=0;i<word.length();i++) {
			if(nums[word.charAt(i)-97]==1) {
				index=i;
				break;
			}
		}
		return index;
	}
	
	/* 遍历数组并建立一个哈希表，哈希表的键为字符，值为该字符出现的次数
	 * LinkedHashMap找第一个值为1的元素，即第一个非重复的字符
	 * LinkedHashMap维护的元素顺序与插入顺序一致，而我们遍历字符数组是从头遍历到尾
	 * 时间复杂度o(n)
	 * 空间复杂度o(26)
	 * 执行用时 :150 ms, 在所有 Java 提交中击败了5.01%的用户
	 * 内存消耗 :49.2 MB, 在所有 Java 提交中击败了31.82%的用户
	 */
	public static int firstUniqueChar2(String word) {
		LinkedHashMap<Character,Integer> map=new LinkedHashMap();
		int index=-1;
		for(int i=0;i<word.length();i++) {
			if(map.containsKey(word.charAt(i))){
				int count=map.get(word.charAt(i))+1;
				map.put(word.charAt(i),count);
			}
			else {
				map.put(word.charAt(i),1);
			}
		}
		for(Character key:map.keySet()) {
			int value=map.get(key);
			if(value==1) {
				index=word.indexOf(key);
				return index;
			}
		}
		return index;
	}
	
	/* 使用了两个存储空间来减少一次循环，是标准的空间-时间折衷
	 * 将重复和不重复的字符分开存放，存放不重复字符的列表中的第一个元素即所求
	 * 时间复杂度o(n)
	 * 空间复杂度o(26)
	 * 执行用时 :48 ms, 在所有 Java 提交中击败了40.00%的用户
	 * 内存消耗 :48.3 MB, 在所有 Java 提交中击败了36.77%的用户
	 */
	public static int firstUniqueChar3(String word) {
		Set<Character> repeating=new HashSet<Character>();
		List<Character> nonRepeating=new ArrayList<Character>();
		for (int i=0;i<word.length();i++) {
			char letter=word.charAt(i);//依次获得字符串中每个字符
			if(repeating.contains(letter)) {
				continue;
			}
			if(nonRepeating.contains(letter)) {
				nonRepeating.remove((Character) letter);
				repeating.add(letter);
			}else {
				nonRepeating.add(letter);
			}
			//System.out.println(nonRepeating);
			
		}
		int index=-1;
		if (null==nonRepeating || nonRepeating.size()==0) {
			return index;
		}
		else {
			index=word.indexOf(nonRepeating.get(0));
			return index;
		}
		
	}
	
public static void main(String[] args) {
    Solution pro=new Solution();
    String str="zhello";
    int c=pro.firstUniqueChar2(str);
    System.out.println("输入的字符串为："+str);
    System.out.println("字符串中第一个非重复的字符为："+c);	
}
}