数组中只出现一次的两个数字

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型一维数组 
     * @return int整型一维数组
     */
    public int[] FindNumsAppearOnce (int[] nums) {
        // write code here

        // 核心思想：采用异或运算的方法，先求出这两个数字的异或值，再根据最低为1的位分别求出两个数值
        // 算法时间复杂度O(N)，额外空间复杂度O(1)

        // 1.先异或一轮，得到一个异或值，表示两个只出现了一次的数字的异或结果
        int n = nums.length;
        int xor = 0;
        for (int i = 0; i < n; i++) {
            xor ^= nums[i];
        }

        // 2.在此基础上，通过位运算得到一个01组成的二进制数，这个数只有一个1，其余位置均为0，且1的那个位置是异或结果的1的最低位
        xor = xor & (~xor + 1);

        // 此时，xor只有一位是1，意义是：两个只出现一次数字在这个位置上数字不同
        // 3.再遍历一轮nums数组，此时根据与xor的与结果分成两组，每一组分别异或出一个值，即为待求值
        int xor1 = 0;
        int xor2 = 0;
        for (int i = 0; i < n; i++) {
            if ((nums[i] & xor) == 0) {
                xor1 ^= nums[i];
            } else {
                xor2 ^= nums[i];
            }
        }

        // 4.按照题意输出结果
        int[] result = new int[2];
        result[0] = Math.min(xor1, xor2);
        result[1] = Math.max(xor1, xor2);
        return result;
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型一维数组
     * @return int整型一维数组
     */
    public int[] FindNumsAppearOnce (int[] nums) {
        // write code here
        HashSet<Integer> set = new HashSet<>();
        for (int num : nums) {
            if (set.contains(num)) {
                set.remove(num);
            } else {
                set.add(num);
            }
        }
        return set.stream().sorted().mapToInt(Integer::intValue).toArray();
    }
}

public int[] FindNumsAppearOnce (int[] nums) {
    // write code here
    int[] res = new int[2];
    if (nums == null || nums.length == 0) return res;

    Map<Integer, Integer> map = new HashMap<>();

    for(int i=0;i<nums.length;i++) {
        int key = nums[i];
        if(map.containsKey(key)) {
            map.put(key, map.get(key)+1);
        } else {
            map.put(key, 1);
        }
    }
    Set<Map.Entry<Integer, Integer>> et = map.entrySet();
    int idx = 0;
    for(Map.Entry<Integer, Integer> item : et) {
        if(item.getValue().equals(1)) {
            res[idx++] = item.getKey();
        }
        if (idx >= 2) break; 
    }
    
    return res;
}

public int[] FindNumsAppearOnce (int[] nums) {
    // write code here
    int[] res=new int[2];
    int index=0;
    HashMap<Integer ,Integer> map = new HashMap<>();
    for(int num:nums){
        map.put(num ,map.getOrDefault(num ,0)+1);
    }
    Iterator<Map.Entry<Integer ,Integer>> iter=map.entrySet().iterator();
    while(iter.hasNext()){
        Map.Entry<Integer ,Integer> entry=iter.next();
        if(entry.getValue()==1){
            res[index++]=entry.getKey();
        }
    }
    return res;
}

public int[] FindNumsAppearOnce (int[] nums) {
        // write code here
        int[] ret = new int[2];
        if (nums.length == 0) {
            return null;
        }
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                map.remove(nums[i]);
                continue;
            }
            map.put(nums[i], 1);
        }
        int i = 0;
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            ret[i++] = entry.getKey();
        }
        return ret;
    }

  Map<Integer, Integer> maps = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (maps.containsKey(nums[i])) {
                Integer a = maps.get(nums[i]);
                maps.put(nums[i], ++a);
            } else {
                maps.put(nums[i], 1);
            }
        }
        List<Integer> a = new ArrayList();
        maps.forEach((k, v)-> {if (k == 1) {
        a.add(v);
        }
                              });
       int b[]= Arrays.stream(a.stream().toArray(Integer[] ::new)).mapToInt(Integer::valueOf).toArray(); 
       Arrays.sort(b);       
       return b;            

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型一维数组 
     * @return int整型一维数组
     */
    public int[] FindNumsAppearOnce (int[] nums) {
        // 1. 参数校验
        if(nums == null || nums.length == 0) {
            return null;
        }

        // 2. 创建哈希表存储元素以及对应的出现次数
        HashMap<Integer,Integer> map = new HashMap<>();

        // 3. 遍历数组元素,存储元素以及出现次数
        for(int i = 0;i < nums.length;i++) {
            // 4. 如果哈希表中不存在此元素,那就添加此元素
            if(!map.containsKey(nums[i])) {
                map.put(nums[i],1);
            } else {
                // 5. 如果哈希表中存在此元素,那就让他的 value + 1
                map.put(nums[i],map.get(nums[i]) + 1);
            }
        }

        // 6. 创建答案数组,保存数组中只出现一次的两个数字
        int[] ans = new int[2];
        int count = 0;

        // 7. 再次遍历数组,找到频率为 1 的两个数
        for(int i = 0;i < nums.length;i++) {
            if(map.get(nums[i]) == 1) {
                ans[count++] = nums[i];
            }
        }
        
        // 8. 题目要求升序
        if(ans[0] > ans[1]) {
            int tmp = ans[0];
            ans[0] = ans[1];
            ans[1] = tmp;
        }

        return ans;
    }
}

public int[] FindNumsAppearOnce (int[] array) {
        // write code here
        Map<Integer, Integer> map = new LinkedHashMap<>();
        for (int arr : array) {
            if (map.containsKey(arr)) {
                map.remove(arr);
            } else {
                map.put(arr, arr);
            }
        }
        int[] ints = map.entrySet().stream().mapToInt(e -> e.getKey()).sorted().toArray();
        return  ints;
    }

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型一维数组 
     * @return int整型一维数组
     */
    public int[] FindNumsAppearOnce (int[] array) {
        int ans=0;
        for(int i=0;i<array.length;i++){
            ans=ans^array[i];
        }
        int h=1;
        while((h&ans)==0){
            h<<=1;
        }
        int group1=0;
        int group2=0;
        for(int i=0;i<array.length;i++){
            if((h&array[i])==0){
                group1=group1^array[i];
            }else{
                group2=group2^array[i];
            }
        }
        
        return new int[]{Math.min(group1,group2),Math.max(group1,group2)};

    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型一维数组 
     * @return int整型一维数组
     */
    public int[] FindNumsAppearOnce (int[] array) {
        // write code here
        if(array == null || array.length <= 0) {
            return null;
        }
        Set<Integer> set = new TreeSet<>();
        for(int a : array) {
            if (set.contains(a)) {
                set.remove(a);
            }else {
                set.add(a);
            }
        }
        //最后剩下的元素就是只出现一次的数字
        int[] result = new int[2];
        Iterator<Integer> it = set.iterator();
        int index = 0;
        while(it.hasNext()) {
            result[index++] = it.next();
        }
        return result;
    }
}

public class Solution {
    public int[] FindNumsAppearOnce (int[] array) {
        Map<Integer, Integer> map = new HashMap();
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < array.length; i++) {
            if (map.containsKey(array[i])) {
                map.put(array[i], map.get(array[i]) + 1);
            } else {
                map.put(array[i], 1);
            }
        }
        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
        for (Map.Entry<Integer, Integer> entry : entries) {
            if (entry.getValue() == 1) {
                list.add(entry.getKey());
            }
        }
        Collections.sort(list);
        return list.stream().mapToInt(Integer::intValue).toArray();
    }
}