[编程题]第一个只出现一次的字符
• 热度指数：348912 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M
• 算法知识视频讲解

```public static int solution(String str){
int[] words = new int[58];
for(int i = 0;i<str.length();i++){
words[((int)str.charAt(i))-65] += 1;
}
for(int i=0;i<str.length();i++){
if(words[((int)str.charAt(i))-65]==1)
return i;
}
return -1;
}```

```class Solution {
public:
int FirstNotRepeatingChar(string str) {
map<char, int> mp;
for(int i = 0; i < str.size(); ++i)
mp[str[i]]++;
for(int i = 0; i < str.size(); ++i){
if(mp[str[i]]==1)
return i;
}
return -1;
}
};```

```import java.util.LinkedHashMap;
// use linkedhashmap to keep the order
public class Solution {
public int FirstNotRepeatingChar(String str) {
for(int i=0;i<str.length();i++){
if(map.containsKey(str.charAt(i))){
int time = map.get(str.charAt(i));
map.put(str.charAt(i), ++time);
}
else {
map.put(str.charAt(i), 1);
}
}
int pos = -1;
int i=0;
for(;i<str.length();i++){
char c = str.charAt(i);
if (map.get(c) == 1) {
return i;
}
}
return pos;
}
}```

```import java.util.HashMap;
public class Solution {
HashMap<Character, Integer> map = new HashMap<>();

public int FirstNotRepeatingChar(String str) {
if (str==null)return -1;
int length = str.length();
for(int i = 0;i<length;i++) {

if(map.containsKey(str.charAt(i))){
int value = map.get(str.charAt(i));
map.remove(str.charAt(i));
map.put(str.charAt(i),value+1);
}else{
map.put(str.charAt(i),1);
}
}
for(int i = 0;i<length;i++){
if(map.get(str.charAt(i))==1)
return i;
}
return -1;
}
}```

```public int FirstNotRepeatingChar(String str)
{
char[] c = str.toCharArray();
int[] a = new int['z'];
for (char d : c)
a[(int) d]++;
for (int i = 0; i < c.length; i++)
if (a[(int) c[i]] == 1)
return i;
return -1;
}```

# python一行就够了：

``````
class Solution:
def FirstNotRepeatingChar(self, s):
return s.index(list(filter(lambda c:s.count(c)==1,s))[0]) if s else -1
``````

```    int FirstNotRepeatingChar(string str) {
if ( str.length() == 0)
return -1;

unsigned int hashTime[256] = {0};
for(int i =0;i<str.length();++i)
hashTime[str[i]]++;

for(int i =0;i<str.length();++i)
{
if(hashTime[str[i]] == 1)
return i;
}
return -1;
}```

```# -*- coding:utf-8 -*-
class Solution:
def FirstNotRepeatingChar(self, s):
# write code here
#判断输入条件
if len(s)<=0 or len(s)>10000:
return -1
#count用于统计字符串中某个字符的出现个数
#index为计算字符串中某个字符的位置
for i in s:
if s.count(i)==1:
return s.index(i)
break
```
Python:开始想用字典,但是字典是无序的,所以无法找到第一个出现次数为1的位置

#建立哈希表,字符长度为8的数据类型,共有256种可能,于是创建一个长度为256的列表
ls=[0]*256
#遍历字符串,下标为ASCII值,值为次数
for i in s:
ls[ord(i)]+=1
#遍历列表,找到出现次数为1的字符并输出位置
for j in s:
if ls[ord(j)]==1:
return s.index(j)
break

```题目各种坑...
class Solution {
public:
int FirstNotRepeatingChar(string str) {
if(str.length()==0)
return -1;
int hash[256]={0};
int i=0;
while(str[i]!='\0'){
hash[str[i]]++;
++i;
}
i=0;
while(str[i]!='\0'){
if(1==hash[str[i]]){
return i;
}
i++;
}
return -1;
}
};```

python简单方法：
```class Solution:
def FirstNotRepeatingChar(self, s):
# write code here
if len(s)<0:
return -1
for i in s:
if s.count(i)==1:
return s.index(i)
break
return -1
```

```#建立哈希表,字符长度为8的数据类型,共有256种可能,于是创建一个长度为256的列表
ls=[0]*256
#遍历字符串,下标为ASCII值,值为次数
for i in s:
ls[ord(i)]+=1
#遍历列表,找到出现次数为1的字符并输出位置
for j in s:
if ls[ord(j)]==1:
return s.index(j)
break
return -1
```

``````class Solution {
public:
int ha[256];
int FirstNotRepeatingChar(string str){
memset(ha, 0, sizeof(ha));
for(int i=0;i<str.length();i++) ha[int(str[i])]++;
for(int i=0;i<str.length();i++) if(ha[int(str[i])] == 1) return i;
return -1;
}
};
``````

1.题目表述不清楚：到底返回神马东西？字符位置还是字符的ASCII值？
3.返回值没有说明，字符串空串为什么返回是-1？
OL：出题目不带的这样让写代码的乱猜的

```public class Solution {
public int FirstNotRepeatingChar(String str) {
if (str.length() == 0) {
return  -1;
}
char c = 'A';
if(str.charAt(0) >= 'a'){
c = 'a';
}
int[] counts = new int[26];
for (int i = 0; i < str.length(); i++) {
counts[str.charAt(i) - c]++;
}
for (int i = 0; i < str.length(); i++) {
if (counts[str.charAt(i) - c] == 1){
return i;
}
}
return -1;
}
}
```

```    def FirstNotRepeatingChar(self, s):
if s == "":
return -1
else:
counts = {}
for i in s:
if i not in counts:
counts[i] = 1
else:
counts[i] += 1
for index,i in enumerate(s):
if counts[i] == 1:
return index```

```class Solution {
public:
//坑爹啊，说长度在1<=length<=1000的，结果放了个空，返回-1.
int FirstNotRepeatingChar(string str) {
unsigned int ch[256]={0};
if(str.length()<=0) return -1;
for(int i=0;i<str.length();i++)
{
ch[(int)str[i]]++;
}
for(int i=0;i<str.length();i++)
{
if(ch[(int)str[i]]==1)
return i;
}
return -1;
}
};```

```public class Solution {
public int FirstNotRepeatingChar(String str) {
char[] chars = str.toCharArray();
int[] map = new int[256];
for (int i = 0; i < chars.length; i++) {
map[chars[i]]++;
}
for (int i = 0; i < chars.length; i++) {
if (map[chars[i]] == 1) return i;
}
return -1;
}
}```

python
```#方法一：利用数组自己建立个哈希表
class Solution:
def FirstNotRepeatingChar(self, s):
# write code here
if s==' ':
return -1
hashtable=[0]*256
for i in s:
hashtable[ord(i)] += 1
for i in s:
if hashtable[ord(i)]==1:
return s.index(i)
return -1

#方法二：利用python自带的字典
class Solution:
def FirstNotRepeatingChar(self, s):
# write code here
if s==' ':
return -1
d=dict()
#第一次遍历字符串，将每个字符的次数存入字典
for i in s:
d[i]=d.get(i,0)+1
#第二次遍历字符串，检查每个字符出现的次数
for i in s:
if d[i]==1:   #O(1)
return s.index(i)
return -1
```

import java.util.HashMap;
import java.util.Map;

/**

*
* 方法一 : 用hashmap的性质,因为containsKey是O(1)
*
*
* 方法二: 桶排序,用两个桶保存,一个保存index,一个保存出现次数
*/
public class FirstNotRepeatingChar {

public int firstNotRepeatingChar(String str) {
if (str == null || str.length() == 0 ) {
return -1;
}
`        Map<Character, Integer> map = new HashMap<>();`
char[] arr = str.toCharArray();
for (int i = 0; i < arr.length; i++) {
if(!map.containsKey(arr[i])) {
map.put(arr[i], i);
} else {
map.put(arr[i], 10001);
}
}
int index =  10001;
for (Map.Entry<Character, Integer> entry : map.entrySet()) {
if (entry.getValue() < index) {
index = entry.getValue();
}
}
return index == 10001 ? -1 : index;
}

//方法二,桶排序,假设只存在大小写字母
public int firstNotRepeatingChar2(String str) {
if (str == null || str.length() == 0 ) {
return -1;
}
int [] arr = new int[200];
int [] arr2 = new int[200];
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
arr[chars[i]] ++;
arr2[chars[i]] = i;
}
int index = 10001;
for (int i = 0; i < arr.length; i++) {
if(arr[i] == 1 && arr2[i] < index) {
index = arr2[i];
}
}
return index == 10001 ? -1 : index;
}
}

```//java直接有判断字符是否存在的函数
//我们只要判断在这个字符之前的字符和之后字符是否存在就可以判断字符是否唯一

public class Solution {
public int FirstNotRepeatingChar(String str) {
char[] a = str.toCharArray();
for (int i=0;i<a.length;i++){
if (!str.substring(0,i).contains(a[i]+"")&&!str.substring(i+1).contains(a[i]+""))
return i;
}
return -1;
}
}

```

C++
```class Solution {
public:
int FirstNotRepeatingChar(string str) {
int size = str.size();
if (size<1 || size>10000)
return -1;
set<char> s1;
set<char> s2;
for (int i = 0; i < size; i++)
{
if (!s1.insert(str[i]).second)
s2.insert(str[i]);
}
if (s1.empty())
return -1;
for (int j = 0; j < size; j++)
{
if (s2.insert(str[j]).second)
return j;
}
return -1;
}
};```

1330条回答 117184浏览

# 通过挑战的用户

• 2019-12-07 02:17:57
• 2019-12-07 00:48:02
• 2019-12-06 23:17:43
• 2019-12-06 22:17:04
• 2019-12-06 21:32:43

# 相关试题

• 扫描二维码，关注牛客网

• 下载牛客APP，随时随地刷题