leetcode — 137. 只出现一次的数字 II（1+3）

（剑指 Offer II 004. 只出现一次的数字）

给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。

示例 1：

输入：nums = [2,2,3,2]
输出：3

示例 2：

输入：nums = [0,1,0,1,0,1,100]
输出：100

提示：

• 1 <= nums.length <= 3 * 104
• -231 <= nums[i] <= 231 - 1
• nums 中，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次

进阶：你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

---

常见方案：

1、双层循环找目标（O(n^2)）

2、先排序然后遍历找到目标（快排O(nlogn)）

3、使用哈希表统计每个数出现的次数（空间复杂度为O(n)）

import java.util.*;


// 除某个元素仅出现 一次 外，其余每个元素都恰出现 三次
public class ANumberAppearsOnlyOnceTWO {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(); // 数组长度
		int[] array = new int[n];
		for(int i = 0; i < n; i ++) {
			array[i] = sc.nextInt();
		}
		
		int ansFirst = twoCircleFind(array);
		int ansSecond = SortAndFind(array);
		int ansThird = HashSetFind(array);

		System.out.println(ansFirst);
		System.out.println(ansSecond);
		System.out.println(ansThird);
	}
	
	// 方法一：双层循环查找
	public static int twoCircleFind(int[] array) {
		
		// 记录内层循环是否执行到最后一位，代表未发现相同的元素
		int j;
		
		for(int i = 0; i < array.length; i ++) {
			for(j = 0; j < array.length; j ++) {
				// 同位置的不进行比较
				if(i == j) {
					continue;
				}
				// 发现相同元素
				if(array[i] == array[j]) {
					break;
				}
			}
			
			// 遍历到最后没有发现与当前元素相同的结果,直到发现就不需要再向后找
			if(j == array.length) {
				int ans = array[i];
				return ans;
			}
		}
		
		// 未找到
		return 0;
	}
	
	// 比较法
	public static int SortAndFind(int[] array) {
		// 对无序的数据进行排序
		Arrays.sort(array);
		// 查找非多次出现的数字
		for(int i = 0; i < array.length - 1; i = i + 3) {
			if(array[i] != array[i+2]) {
				return array[i];
			}
		}
		// 这个数组的长度肯定是奇数（目标数字只出现一次，其他所有数字出现两次）
		// 如果上述步骤没有找到不相等的一组数，那么肯定是数组的最后一个数字是单独出现的。
		return array[array.length - 1];
	}
	
	// 哈希表
	public static int HashSetFind(int[] array) {
		// map 记录每个数字出现的次数
		HashMap<Integer, Integer> map = new HashMap<> ();
		for(int i = 0; i < array.length; i ++) {
			int frequency = map.getOrDefault(array[i], 0) + 1;
			map.put(array[i], frequency);
		}
		
		// map 中存储的时每个字符出现的次数
		int ans = 0;
		for(int i = 0;i < array.length; i ++) {
			if(map.get(array[i]) == 1) {
				ans = array[i];
				break;
			}
		}
		
		return ans;
	}
	
}

/*
7
4 1 2 1 2 1 2
 */

---

方法一 ——「只出现了一次的元素」为「最终结果」。

        由于数组中的元素都在 int（即 32 位整数）范围内，因此可以依次计算答案的每一个二进制位是 0 还是 1。

具体地，考虑「最终结果」的第 i 个二进制位（i 从 0 开始编号），可能为 0 或 1。对于数组中非答案的元素，每一个元素都出现了 3 次，对应着第 i 个二进制位的 3 个 0 或 3 个 1，无论是哪一种情况，它们的和都是 3 的倍数（即和为 0 或 3）。因此：

• 「最终结果」的第 i 个二进制位就是数组中所有元素的第 i 个二进制位之和除以 3 的余数。
• 对于数组中的每一个元素 x，使用位运算 (x >> i) & 1 得到 x 的第 i 个二进制位，并将它们相加再对 3 取余，得到的结果一定为 0 或 1，即为答案的第 i 个二进制位。
• 需要注意的是，如果使用的语言对「有符号整数类型」和「无符号整数类型」没有区分，那么可能会得到错误的答案。这是因为「有符号整数类型」（即 int 类型）的第 31 个二进制位（即最高位）是补码意义下的符号位，对应着 −2^31，而「无符号整数类型」由于没有符号，第 31 个二进制位对应着 2^31 。因此在某些语言中需要对最高位进行特殊判断。

	// 对二进制数据进行分析，依次确定每一个二进制位
	public static int BitwiseFind(int[] array) {
		int ans = 0;
		for(int i = 0; i < 32; i ++) {
			// 统计数组中所有数字的二进制 在 i 位上 是 1 的个数
			int count = 0;
			// 对每个数字
			for(int j = 0; j < array.length; j ++) {
				// array[j] 二进制 i 位上是否是 1
				if((array[j] >> i & 1) == 1) {
					count ++;
				}
			}
			//i 位上 1 的个数不是 3 的倍数，因为只出现了 1 次的数贡献出了 1
			if(count % 3 != 0) {
				ans = ans | (1 << i);
			}
		}
		
		return ans;
	}

---

待补充