Java 在一个循环中使用hashmap的第一个非重复字符？

最近一位面试官让我实现字符串中的第一个非重复字符，我使用两个不同的循环使用hashmap实现。虽然时间复杂度为O（n）+O（n），但他让我在单个循环中求解。有人能告诉我怎么做吗

以下是我的实施：

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

public class firstnonrepeating {

    public static void main(String[] args) {

        String non = "nnjkljklhihis";

        Map<Character, Integer> m = new HashMap<Character, Integer>();

        for (int i = 0; i < non.length(); i++) {

            if (m.get(non.charAt(i)) != null) {
                m.put(non.charAt(i), m.get(non.charAt(i)) + 1);
            } else {
                m.put(non.charAt(i), 1);
            }
        }

        for (int i = 0; i < non.length(); i++) {

            if (m.get(non.charAt(i)) == 1) {
                System.out.println("First Non Reapeating Character is "
                        + non.charAt(i));
                break;
            } else {
                if (i == non.length() - 1)
                    System.out.println("No non repeating Character");
            }
        }

    }

}

import java.util.HashMap；
导入java.util.Map；
公共类优先非重复{
公共静态void main（字符串[]args）{
字符串non=“nnjkljklhis”；
Map m=新的HashMap（）；
对于（int i=0；i

以下是我的做法：

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

public class Main
{
    public static void main(String[] args)
    {
        String characters = "nnjkljklhihis";
        Character firstNonRepeatingChar = getFirstNonRepeatingCharacter(characters);
        if(firstNonRepeatingChar == null)
        {
            System.out.println("No non repeating characters in " + characters);
        }
        else
        {
            System.out.println("The first non repeating character is " + firstNonRepeatingChar);
        }
    }

    private static Character getFirstNonRepeatingCharacter(String characters)
    {
        Map<Integer, Character> m = new HashMap<Integer, Character>();
        for(int i = 0; i < characters.length(); i++)
        {
            Character currentChar = characters.charAt(i);
            if(i > 0)
            {
                Character previousChar = m.get(i-1);
                if(!previousChar.equals(currentChar))
                {
                    return currentChar;
                }
            }
            m.put(i, currentChar);
        }
        return null;//No non repeating character found
    }
}

import java.util.HashMap；
导入java.util.Map；
公共班机
{
公共静态void main（字符串[]args）
{
String characters=“nnjkljklhis”；
Character firstNonRepeatingChar=getFirstNonRepeatingCharacter（个字符）；
if（firstNonRepeatingChar==null）
{
System.out.println（“在“+字符中没有非重复字符”）；
}
其他的
{
System.out.println（“第一个非重复字符是”+firstNonRepeatingChar）；
}
}
私有静态字符getFirstNonRepeatingCharacter（字符串字符）
{
Map m=新的HashMap（）；
对于（int i=0；i0）
{
字符previousChar=m.get（i-1）；
如果（！previousChar.equals（currentChar））
{
返回当前字符；
}
}
m、 put（i，currentChar）；
}
返回null；//未找到非重复字符
}
}

String non=“nnnjkljklhis”；
Map m=新的HashMap（）；
m、 放置（“一”，新LinkedHashSet（））；
m、 put（“else”，newlinkedhashset（））；
m、 放置（“全部”，新LinkedHashSet（））；
对于（int i=0；i0）{
System.out.println（“第一个非重复项：”+m.get（“一”）.iterator（）.next（））；
}

这是与Osama相同的答案，以更现代的方式重新编写

public static Optional<Character> getFirstNonRepeatingCharacter(String characters) {
    HashMap<Character, Consumer<Character>> map = new HashMap<>();
    LinkedHashSet<Character> set = new LinkedHashSet<>();
    for(char c: characters.toCharArray()) {
        map.merge(c, set::add, (_1, _2) ->  set::remove).accept(c);
    }
    return set.stream().findFirst();
}

public静态可选getFirstNonRepeatingCharacter（字符串字符）{
HashMap=newHashMap（）；
LinkedHashSet=新LinkedHashSet（）；
for（char c:characters.toCharArray（））{
合并（c，set:：add，（_1，_2）->set:：remove）.accept（c）；
}
返回set.stream（）.findFirst（）；
}

还有一种可能的解决方案：

   public class FirstNonRepeatingCharacterInString {
    public static void main(String[] args) {
        Character character = firstNonRepeatingCharacter("nnjkljklhihis");
        System.out.println("First Non repeating character :  " + character != null ? character : null);
    }

    private static Character firstNonRepeatingCharacter(String arg) {
        char[] characters = arg.toCharArray();
        Map<Character, Character> set = new LinkedHashMap<>();
        // cost of the operation is O(n)
        for (char c : characters) {
            if (set.containsKey(c)) {
                set.remove(c);
            } else {
                set.put(c, c);
            }
        }
        //here we are just getting the first value from collection
        // not iterating the whole collection and the cost of this operation is O(1)
        Iterator<Character> iterator = set.keySet().iterator();
        if (iterator.hasNext()) {
            return iterator.next();
        } else {
            return null;
        }
    }
}

公共类第一个非重复字符字符串{
公共静态void main（字符串[]args）{
字符字符=第一个非重复字符（“nnjkljklhis”）；
System.out.println（“第一个非重复字符：“+字符！=null？字符：null”）；
}
私有静态字符FirstNoRepeatingCharacter（字符串arg）{
char[]characters=arg.toCharArray（）；
映射集=新建LinkedHashMap（）；
//操作成本为O（n）
for（字符c：字符）{
if（集合容器（c））{
设置。移除（c）；
}否则{
集合。放置（c，c）；
}
}
//这里我们只是从集合中获取第一个值
//不迭代整个集合，此操作的成本为O（1）
迭代器迭代器=set.keySet（）.Iterator（）；
if（iterator.hasNext（））{
返回iterator.next（）；
}否则{
返回null；
}
}
}

给定一个字符串，查找其第一个非重复字符：

public class Test5 {
public static void main(String[] args) {
    String a = "GiniSoudiptaGinaProtijayi";
    Map<Character, Long> map = a.chars().mapToObj(
            ch -> Character.valueOf((char)ch)
            ).collect(Collectors.groupingBy(Function.identity(),
                    LinkedHashMap:: new,
                    Collectors.counting()
                    ));


        System.out.println(map);
    //List<Character> list = map.entrySet().stream().filter( entry -> entry.getValue() == 1    )
        //.map(entry -> entry.getKey()).collect(Collectors.toList());

                //System.out.println(list);
        Character ch =  map.entrySet().stream()
                .filter( entry -> entry.getValue() == 1L    )
                .map(entry -> entry.getKey()).findFirst().get();
        System.out.println(ch);

}
}

公共类Test5{
公共静态void main（字符串[]args）{
字符串a=“GiniSoudiptaGinaProtijayi”；
Map Map=a.chars（）.mapToObj(
ch->Character.valueOf（（char）ch）
).collect（收集器.groupingBy（Function.identity（）），
LinkedHashMap:：新建，
3.计数（）
));
系统输出打印项次（map）；
//List List=map.entrySet（）.stream（）.filter（条目->条目.getValue（）==1）
//.map（entry->entry.getKey（））.collect（Collectors.toList（））；
//系统输出打印项次（列表）；
字符ch=map.entrySet（）.stream（）
.filter（条目->条目.getValue（）==1L）
.map（entry->entry.getKey（））.findFirst（）.get（）；
系统输出println（ch）；
}
}

我认为这是一个更适合的问题。他说他需要使用HashMap的可能重复。我假设重复意味着它是连续重复的。也许我误解了。在这个解决方案中，如果containsKey（c）返回true，即字符在前面已经被看到，那么您不应该只是将其从LinkedHashMap中删除。删除它之后，您应该再次将其放回原处，以便它以迭代顺序结束。否则，当您第二次看到该角色时，它将不在LinkedHashMap中，因此您会将其放回。例如，迭代，比如说，“abbaac”：例如添加了

“abbaac”

：

a

<代码>b已添加<代码>b<

public class Test5 {
public static void main(String[] args) {
    String a = "GiniSoudiptaGinaProtijayi";
    Map<Character, Long> map = a.chars().mapToObj(
            ch -> Character.valueOf((char)ch)
            ).collect(Collectors.groupingBy(Function.identity(),
                    LinkedHashMap:: new,
                    Collectors.counting()
                    ));


        System.out.println(map);
    //List<Character> list = map.entrySet().stream().filter( entry -> entry.getValue() == 1    )
        //.map(entry -> entry.getKey()).collect(Collectors.toList());

                //System.out.println(list);
        Character ch =  map.entrySet().stream()
                .filter( entry -> entry.getValue() == 1L    )
                .map(entry -> entry.getKey()).findFirst().get();
        System.out.println(ch);

}
}