字符流中第一个不重复的字符

Java，借助 LinkedHashSet 记录只出现了一次的元素，并且还能保存他们的先后出现顺序。

import java.util.*;
public class Solution {
    LinkedHashSet<Character> once = new LinkedHashSet<>();
    HashSet<Character> existed = new HashSet<>();
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        if (existed.contains(ch)) {
            return;
        }

        if (once.contains(ch)) {
            once.remove(ch);
            existed.add(ch);
        }
        else {
            once.add(ch);
        }
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        Object[] chars =  once.toArray();
        if (chars.length == 0) {
            return '#';
        }
        else {
            return (char) chars[0];
        }
    }
}

import java.util.*;
public class Solution {
    
    public Solution(){
        System.out.println("***泥马");
    }
    //Insert one char from stringstream
    private StringBuilder sb=new StringBuilder();
    private HashMap<Character,Integer> map=new HashMap<>();
    private int nowindex=0;
    public void Insert(char ch)
    {
        if(map.containsKey(ch)){
            map.put(ch,map.get(ch)+1);
        }else{
            map.put(ch,1);
        }
        sb.append(ch);
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        for(int i=nowindex;i<sb.length();i++){
            if(map.get(sb.charAt(i))==1){
                nowindex=i;
                return sb.charAt(i);
            }
        }
        return '#';
    }
}

public class Solution {
    
    //用来记录每个字符出现的次数，根据ASCII表可知，一共只有127个字符，固然定义数组长度为127
    int[] strs = new int[127];
    //用来判断优先级，即出现的早晚
    int[] priority = new int[127];
    int count = 0;
    
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        //记录ch字符的出现次数
        strs[ch]++;
        //保存ch第一次出现时对应的count值，count值越小，表示出现的越早
        if(priority[ch] == 0){
            
            //保存ch第一次出现时对应的count值
            priority[ch] = count;
            //自增
            count++;
        }
    }
    //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        //第一个不重复的字符
        char c = '#';
        //优先级
        int pri = 999;
        
        //计算第一个不重复的字符
        for(int i = 0 ; i < strs.length ; i++){
            //表示i字符只出现一次
            if(strs[i]==1){
                if(priority[i] < pri){
                    //i字符对应的优先级赋值给pri
                    pri = priority[i];
                    //当前第一个不重复的字符
                    c = (char)i;
                }
            }
        }
        
        return c;
    }
}

import java.util.*;

public class Solution {
    //Insert one char from stringstream
    public Queue<Character> queue=  new LinkedList<>();
   private int[] cnts = new int[128];
   
    public void Insert(char ch)
    {
        cnts[ch]++;
        queue.add(ch);
        while (!queue.isEmpty() && cnts[queue.peek()] > 1)
        queue.poll();
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
      return queue.isEmpty() ? '#' : queue.peek();
    }
}

public class SolutionJZ75{
        private HashMap<Character, Integer> map = new HashMap<>();
        private ArrayList<Character> list = new ArrayList<>();
        public void insert(char ch){
            if(!map.containsKey(ch)){
                map.put(ch, 1);
                list.add(ch);
            }else {
                int i = map.get(ch);
                if(i == 1){
                    map.replace(ch, 0);
                    list.remove((Character) ch); // remove必须是一个类型，不能是基本类型。如果是基本类型的话，就是index了
                }
            }
        }
        public char firstAppearingOnce(){
            if(list.size() == 0){
                return '#';
            }
            return list.get(0);
        }
    }

    int arr[] = new int[130];
    List<Character> list = new ArrayList<>();

    public void Insert(char ch) {
           
        //优化，只有不重复的ch才保存，减少循环次数
          if(arr[ch] == 0)
             list.add(ch);
        
            arr[ch]++;
         
        
    }

    //return the first appearence once char in current stringstream
    public char FirstAppearingOnce() {
        for (int i = 0; i < list.size(); i++) {
            char t = list.get(i);
            if (arr[t] == 1) {
                return t;
            }
        }
        return '#';
    }

import java.util.*;

public class Solution {
    
    private Map<Character, Integer> map;
    
    public Solution() {
        map = new LinkedHashMap<>();
    }
    
    //Insert one char from stringstream
    public void Insert(char ch) {
        map.put(ch, map.getOrDefault(ch, 0) + 1);
    }
    
    //return the first appearence once char in current stringstream
    public char FirstAppearingOnce() {
        for(Character c : map.keySet()) {
            if(map.get(c) == 1) {
                return c;
            }
        }
        return '#';
    }
}

import java.util.*;
public class Solution {
    private Deque<Character> deque = new ArrayDeque<>();
    private int[] count = new int[128];
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        if (count[ch] == 0) {
            deque.offer(ch);
        }
        count[ch]++;
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        while (!deque.isEmpty() && count[deque.peek()] > 1) {
            deque.poll();
        }
        return deque.peek() == null ? '#' : deque.peek();
    }
}

public class Solution {
    private int[] cnts = new int[256];
    private Queue<Character> queue = new LinkedList<>();
    public void Insert(char ch) {
       cnts[ch]++;
       queue.offer(ch);
       while (!queue.isEmpty() && cnts[queue.peek()] > 1) {
           queue.poll();
       }
    }

    public char FirstAppearingOnce() {
        return queue.isEmpty() ? '#' : queue.peek();
    }
}

import java.util.*;
public class Solution {
    /*
    读了半天，看了半天解析，然后再调试了半天才知道这个题目函数是用来干啥，
    题目意思是啥，我真的由瓦依！
    题目意思：就是 Insert 函数是用来接收每次的从字符流传递过来的一个字符举例：
    第一次：Insert 传递过来的一个字符： g
    就要在 FirstAppearingOnce 函数中去判断当前第一个只出现一次的字符(g) 显然是 g
    第二次：Insert 传递过来一个字符： o
    就要在 FirstAppearingOnce 函数中去判断当前第一个只出现一次的字符(go) 显然是还是 g
     第三次：Insert 传递过来一个字符： o
    就要在 FirstAppearingOnce 函数中去判断当前第一个只出现一次的字符(goo) 显然是还是 g
     第四次：Insert 传递过来一个字符： g
    就要在 FirstAppearingOnce 函数中去判断当前第一个只出现一次的字符(goog) 显然没有，则返回 #
     第五次：Insert 传递过来一个字符： l
    就要在 FirstAppearingOnce 函数中去判断当前第一个只出现一次的字符(googl) 显然是 l
     第六次：Insert 传递过来一个字符： e
    就要在 FirstAppearingOnce 函数中去判断当前第一个只出现一次的字符(google) 显然是还是 l
     
    所以就要走 Insert 函数中进行获取，然后在 FirstAppearingOnce 进行返回
    */
    Set<Character> set=new HashSet<>();
    ArrayList<Character> list=new ArrayList<>();
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        //java Set 加入时候重复就会返回 false,没有重复返回true
        if(set.add(ch))
        {
            list.add(ch);
        }else
        {
            //这一块判断因为可能会重复好几次
            if(list.contains(ch))
                list.remove(new Character(ch));
        }
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        if(list.size()>0)
            return list.get(0);
        else
            return '#';
    }
}