Java 如何加快第一个唯一字符的查找速度

我正在解决LeetCode问题，定义为：

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

示例：

s = "leetcode"
return 0.

s = "loveleetcode",
return 2.

注意：您可以假设字符串只包含小写字母

利用输入是完全小写的ASCII码，我创建了两个位向量来跟踪我们第一次和第二次遇到的字符

下面的代码可以进一步改进吗？LeetCode说下面的代码比94.33%的解决方案要好。最后5.67%的解决方案还能做些什么

class Solution {

  public int firstUniqChar(String s) {
    int firstSpot = 0;
    int secondSpot = 0;
    char[] chars = s.toCharArray();

    for (char c : chars) {
      int mask = 1 << c - 'a';
      if ((firstSpot & mask) == 0) {
        firstSpot |= mask;
      } else if ((secondSpot & mask) == 0) {
        secondSpot |= mask;
      }
    }

    int i = 0;
    for (char c : chars) {
      int mask = 1 << c - 'a';
      if ((secondSpot & mask) == 0) {
         return i;
      }
      i++;
    }
    return -1;
  }

}

类解决方案{
公共int firstUniqChar（字符串s）{
int firstSpot=0；
int第二点=0；
char[]chars=s.toCharArray（）；
for（char c:chars）{
int mask=198.58%-

public int firstUniqChar(String s) {
    int count[] = new int[122 - 96];
    final char[] chars = s.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        count[chars[i] - 97]++;
    }
    for (int i = 0; i < chars.length; i++) {
        if (count[chars[i] - 97] == 1)
            return i;
    }
    return -1;
}

public int firstUniqChar（字符串s）{
整数计数[]=新整数[122-96]；
最终字符[]字符=s.toCharArray（）；
for（int i=0；i

我得到了98.58%-

public int firstUniqChar(String s) {
    int count[] = new int[122 - 96];
    final char[] chars = s.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        count[chars[i] - 97]++;
    }
    for (int i = 0; i < chars.length; i++) {
        if (count[chars[i] - 97] == 1)
            return i;
    }
    return -1;
}

public int firstUniqChar（字符串s）{
整数计数[]=新整数[122-96]；
最终字符[]字符=s.toCharArray（）；
for（int i=0；i

正如@Ruakh在评论中所说，leetcode产生的精确计时会受到一定程度的随机性的影响，因此应该谨慎对待：

我的印象是LeetCode做的是一个不科学的微基准，可能取决于随机因素

尽管如此，通过取消测试，还是可以大大加快第一个循环的速度。以下循环在功能上是等效的；尽管它设置变量的频率更高，但更改局部整数变量的值比测试是否需要更改成本要低：

for (char c : chars) {
  int mask = 1 << c - 'a';
  secondSpot |= mask & firstSpot;
  firstSpot |= mask;
}

for（字符c:chars）{
int mask=1正如@Ruakh在一篇评论中所说，leetcode产生的精确计时会受到一定数量的随机性的影响，因此应该谨慎对待：

我的印象是LeetCode做的是一个不科学的微基准，可能取决于随机因素

尽管如此，通过取消测试，还是可以大大加快第一个循环的速度。以下循环在功能上是等效的；尽管它设置变量的频率更高，但更改局部整数变量的值比测试是否需要更改成本要低：

for (char c : chars) {
  int mask = 1 << c - 'a';
  secondSpot |= mask & firstSpot;
  firstSpot |= mask;
}

for（字符c:chars）{
int mask=1使用以下方法：

import java.util.Arrays;

class Solution {
    //  0x60 < 'a' < 'z' < 0x80
    private final byte[] bCounter = new byte[0x80];
    private final int[] iCounter = new int[0x80];

    public int firstUniqChar(String s) {
        int len = s.length();
        if ((len & 0xff) == len) {
            Arrays.fill(bCounter, 0x60, 0x80, (byte)-1);
            for (int i = 0; i < len; i++)
                bCounter[s.charAt(i)]++;
            for (int i = 0; i < len; i++)
                if (bCounter[s.charAt(i)] == 0)
                    return i;
        } else {
            Arrays.fill(iCounter, 0x60, 0x80, -1);
            for (int i = 0; i < len; i++)
                iCounter[s.charAt(i)]++;
            for (int i = 0; i < len; i++)
                if (iCounter[s.charAt(i)] == 0)
                    return i;
        }
        return -1;
    }
}

导入java.util.array；
类解决方案{
//0x60<'a'<'z'<0x80
私有最终字节[]b计数器=新字节[0x80]；
私有最终整数[]i计数器=新整数[0x80]；
公共int firstUniqChar（字符串s）{
int len=s.length（）；
如果（（len&0xff）=len）{
填充（b计数器，0x60，0x80，（字节）-1）；
对于（int i=0；i
使用以下方法：

import java.util.Arrays;

class Solution {
    //  0x60 < 'a' < 'z' < 0x80
    private final byte[] bCounter = new byte[0x80];
    private final int[] iCounter = new int[0x80];

    public int firstUniqChar(String s) {
        int len = s.length();
        if ((len & 0xff) == len) {
            Arrays.fill(bCounter, 0x60, 0x80, (byte)-1);
            for (int i = 0; i < len; i++)
                bCounter[s.charAt(i)]++;
            for (int i = 0; i < len; i++)
                if (bCounter[s.charAt(i)] == 0)
                    return i;
        } else {
            Arrays.fill(iCounter, 0x60, 0x80, -1);
            for (int i = 0; i < len; i++)
                iCounter[s.charAt(i)]++;
            for (int i = 0; i < len; i++)
                if (iCounter[s.charAt(i)] == 0)
                    return i;
        }
        return -1;
    }
}

导入java.util.array；
类解决方案{
//0x60<'a'<'z'<0x80
私有最终字节[]b计数器=新字节[0x80]；
私有最终整数[]i计数器=新整数[0x80]；
公共int firstUniqChar（字符串s）{
int len=s.length（）；
如果（（len&0xff）=len）{
填充（b计数器，0x60，0x80，（字节）-1）；
对于（int i=0；i
这个问题最好在你的帖子中提问，这样会在网站上获得更好的反响。Re:“LeetCode说下面的代码比94.33%的解决方案好”：我的印象是，LeetCode做的是一个不科学的微基准，可能取决于随机因素（例如提交时服务器上的其他负载）。所以我不确定这个数字是否应该被认真对待。这个问题最好在你的帖子上提出来，这样会在网站上获得更好的反响。回复：“LeetCode说下面的代码比94.33%的解决方案好”：我的印象是，LeetCode做的是一个不科学的微基准，可能取决于随机因素（例如提交时服务器上的其他负载）。因此我不确定这个数字是否应该被认真对待。通过添加
int setup=（[]{cin.tie（0）；ios_base:：sync_with_stdio（false）；返回0；}）（）java java C++的java语言，不需要C++。抱歉，你可以通过添加<代码> int Stuts=（[]{CIN，0（IOS:Base::SycSythOSSTIdio（false）；返回；0；}）），（100%）；（<）；<代码>代码。@ 0x499 602D2 Java相当的乐趣。这是java而不是C++。抱歉。