学习异或运算和相关题目

02 异或运算、进一步认识对数器的重要性

内容：

• 异或运算的性质

• 异或运算的题目

题目：

不用额外变量交换两个数的值

a ^= b
b ^= a
a ^= b

可以使用异或运算符来实现。

假设我们有两个变量a和b，它们的值分别为x和y。

我们可以使用以下代码将它们的值交换：
在这个代码片段中，我们首先将a与b进行异或运算，并将结果存储在a中。这将使a包含`x ^ y`的值。
然后，我们将b与a进行异或运算，并将结果存储在b中。这将使b包含`(x ^ y) ^ y`的值，即x的值。
最后，我们将a与b进行异或运算，并将结果存储在a中。这将使a包含`x ^ (x ^ y)`的值，即y的值。

即:
a = x^y
b = (x^y)^y = x
a = (x^y)^x = y

在这个过程中，我们没有使用任何额外的变量，而是只使用了两个变量a和b。这种方法可以用于交换任何类型的变量，包括整数、浮点数、字符串等。

不用额外变量交换数组中两个数的值

arr[i] ^= arr[j]
arr[j] ^= arr[i]
arr[i] ^= arr[j]

一个数组中有一种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这种数

任何数和自己异或运算都得到0，因为每一位都相同，异或结果是0

//偶数次的数最异或的结果eor都是0，奇数次的数和0异或就是奇数自己了
public static void printOddTimesNum1(int[] arr) {
    int eor = 0;
    for (int i = 0; i < arr.length; i++) {
        eor ^= arr[i];
    }
    System.out.println(eor);
}

怎么把一个int类型的数，提取出二进制中最右侧的1来

a&(!a+1)

一个数组中有两种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这两种数

public static void printOddTimesNum2(int[] arr) {
    int eor = 0;
    for (int i = 0; i < arr.length; i++) {
        eor ^= arr[i];
    }
    // a 和 b是两种数
    // eor != 0
    // eor最右侧的1，提取出来
    // eor :     00110010110111000
    // rightOne :00000000000001000
    int rightOne = eor & (-eor); // 提取出最右的1
    
    
    int onlyOne = 0; // eor'
    for (int i = 0 ; i < arr.length;i++) {
        //  arr[1] =  111100011110000
        // rightOne=  000000000010000
        if ((arr[i] & rightOne) != 0) {
            onlyOne ^= arr[i];
        }
    }
    System.out.println(onlyOne + " " + (eor ^ onlyOne));
}

一个数组中有一种数出现K次，其他数都出现了M次，
已知M > 1，K < M，找到出现了K次的数
要求额外空间复杂度O(1)，时间复杂度O(N)

public static int test(int[] arr, int k, int m) {
    HashMap<Integer, Integer> map = new HashMap<>();
    for (int num : arr) {
        if (map.containsKey(num)) {
            map.put(num, map.get(num) + 1);
        } else {
            map.put(num, 1);
        }
    }
    int ans = 0;
    for (int num : map.keySet()) {
        if (map.get(num) == k) {
            ans = num;
            break;
        }
    }
    return ans;
}

public static HashMap<Integer, Integer> map = new HashMap<>();

// 请保证arr中，只有一种数出现了K次，其他数都出现了M次
public static int onlyKTimes(int[] arr, int k, int m) {
    if (map.size() == 0) {
        mapCreater(map);
    }
    int[] t = new int[32];
    // t[0] 0位置的1出现了几个
    // t[i] i位置的1出现了几个
    for (int num : arr) {
        while (num != 0) {
            int rightOne = num & (-num);
            t[map.get(rightOne)]++;
            num ^= rightOne;
        }
    }
    int ans = 0;
    // 如果这个出现了K次的数，就是0
    // 那么下面代码中的 : ans |= (1 << i);
    // 就不会发生
    // 那么ans就会一直维持0，最后返回0，也是对的！
    for (int i = 0; i < 32; i++) {
        if (t[i] % m != 0) {
            ans |= (1 << i);
        }
    }
    return ans;
}

public static void mapCreater(HashMap<Integer, Integer> map) {
    int value = 1;
    for (int i = 0; i < 32; i++) {
        map.put(value, i);
        value <<= 1;
    }
}

// 更简洁的写法
public static int km(int[] arr, int k, int m) {
    int[] help = new int[32];
    for (int num : arr) {
        for (int i = 0; i < 32; i++) {
            help[i] += (num >> i) & 1;
        }
    }
    int ans = 0;
    for (int i = 0; i < 32; i++) {
        help[i] %= m;
        if (help[i] != 0) {
            ans |= 1 << i;
        }
    }
    return ans;
}

// 为了测试
public static int[] randomArray(int maxKinds, int range, int k, int m) {
    int ktimeNum = randomNumber(range);
    // 真命天子出现的次数
    int times = k;
    // 2
    int numKinds = (int) (Math.random() * maxKinds) + 2;
    // k * 1 + (numKinds - 1) * m
    int[] arr = new int[times + (numKinds - 1) * m];
    int index = 0;
    for (; index < times; index++) {
        arr[index] = ktimeNum;
    }
    numKinds--;
    HashSet<Integer> set = new HashSet<>();
    set.add(ktimeNum);
    while (numKinds != 0) {
        int curNum = 0;
        do {
            curNum = randomNumber(range);
        } while (set.contains(curNum));
        set.add(curNum);
        numKinds--;
        for (int i = 0; i < m; i++) {
            arr[index++] = curNum;
        }
    }
    // arr 填好了
    for (int i = 0; i < arr.length; i++) {
        // i 位置的数，我想随机和j位置的数做交换
        int j = (int) (Math.random() * arr.length);// 0 ~ N-1
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    return arr;
}

// 为了测试
// [-range, +range]
public static int randomNumber(int range) {
    return (int) (Math.random() * (range + 1)) - (int) (Math.random() * (range + 1));
}

// 为了测试
public static void main(String[] args) {
    int kinds = 5;
    int range = 30;
    int testTime = 100000;
    int max = 9;
    System.out.println("测试开始");
    for (int i = 0; i < testTime; i++) {
        int a = (int) (Math.random() * max) + 1; // a 1 ~ 9
        int b = (int) (Math.random() * max) + 1; // b 1 ~ 9
        int k = Math.min(a, b);
        int m = Math.max(a, b);
        // k < m
        if (k == m) {
            m++;
        }
        int[] arr = randomArray(kinds, range, k, m);
        int ans1 = test(arr, k, m);
        int ans2 = onlyKTimes(arr, k, m);
        int ans3 = km(arr, k, m);
        if (ans1 != ans2 || ans1 != ans3) {
            System.out.println(ans1);
            System.out.println(ans3);
            System.out.println("出错了！");
        }
    }
    System.out.println("测试结束");
}