其他分享
首页 > 其他分享> > 272,只出现一次的数字 II

272,只出现一次的数字 II

作者:互联网

给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现了三次。找出那个只出现了一次的元素。

 

示例 1:

输入: [2,2,3,2]
输出: 3

示例 2:

输入: [0,1,0,1,0,1,99]
输出: 99

答案:

1public int singleNumber(int[] nums) {
2    int a = 0, b = 0;
3    for (int i = 0; i < nums.length; ++i) {
4        b = (b ^ nums[i]) & ~a;
5        a = (a ^ nums[i]) & ~b;
6    }
7    return b;
8}

解析:

有没有能看得懂的,是不是一脸懵逼,如果一眼能看懂的我觉得也算是高手了。如果看不懂我就继续让你懵逼

 1public int singleNumber(int[] nums) {
2    int x1 = 0, x2 = 0, mask = 0;
3    for (int i : nums) {
4        x2 ^= x1 & i;
5        x1 ^= i;
6        mask = ~(x1 & x2);
7        x2 &= mask;
8        x1 &= mask;
9    }
10    return x1;
11}

what,还看不懂,那我再给你写一个

 1public int singleNumber(int[] nums) {
2    int a = 0;
3    int b = 0;
4    for (int c : nums) {
5        int ta = (~a & b & c) | (a & ~b & ~c);
6        b = (~a & ~b & c) | (~a & b & ~c);
7        a = ta;
8    }
9    return a | b;
10}

看不懂没关系,我们最后再讲,现在我先给大家介绍两个能看懂的,增强一下信心。一种是使用HashMap来存储,key存储数组的值,value存储的是key值出现的次数,最后找出value等于1的即可。原理很简单,代码就不再写了。还一种方式是使用位来存储,我们来先看下代码

 1public int singleNumber(int[] nums) {
2    int ans = 0;
3    for (int i = 0; i < 32; i++) {
4        int sum = 0;
5        for (int j = 0; j < nums.length; j++) {
6            if (((nums[j] >> i) & 1) == 1) {
7                sum++;
8                sum %= 3;
9            }
10        }
11        if (sum != 0) {
12            ans |= sum << i;
13        }
14    }
15    return ans;
16}

或者

 1public int singleNumber(int[] nums) {
2    int bitLength = 32;
3    int bits[] = new int[bitLength];
4    for (int i = 0; i < bitLength; i++) {
5        for (int j = 0; j < nums.length; j++) {
6            bits[i] += ((nums[j] >> i) & 1);
7        }
8    }
9    int result = 0;
10    for (int j = 0; j < bitLength; j++)
11        if (bits[j] % 3 != 0)
12            result += (1 << j);
13    return result;
14}

这种代码很容易理解,因为int是32位,所以只需要累加每一位上的和,看他是否能被3整除,如果不能整除,说明那个只出现一次的数字在这个位置上是有值的。举个例子,假如数组[5,5,5,6]那么他们的二进制分别是

101

101

101

110

——

所以相加的结果第一位是(从左往右)1+1+1+1=4,不能被3整除,所以结果为1,第二位0+0+0+1也不能被3整除,所以结果也为1,第三位1+1+1+0=3能被3整除,所以结果为0,所以我们要查找的那个数的二进制是110,换成十进制也就是6。代码很容易理解,

下面再看最重要的部分,也就是上面遗留的问题,最上面3种解法的原理是什么。其实他的原理非常简单,就是一个数如果出现3次,通过一些运算我们让他变为0,也就是说他的周期是3,前面我们讲过140,只出现一次的数字,通过异或运算即可。这种想法很容易想到,但怎么让他出现3次的时候让他变为0,就不那么简单了。

比如一个数x第一次出现的时候让他保存在b中,第二次出现的时候让他保存在a中,第3次出现的时候让他等于0,所以对于第一种解法我们很容易写出b=(b^x)&~a;   a=(a^x)&~b;

对于第3种解法。我们看到3个相同的数每次执行完之后都会归0,也就是说他的周期是3,只要一个数出现3次就让他归0。那么他是怎么实现的呢,其实也很好理解,因为他的周期是3,那么他就具有3种状态。我们就拿0和1来说,如果用0和1来表示3种状态我们至少需要2位数,我们假如这3种状态是00,01,10。这里的3个数我们把它理解为三种状态,不要把它当成一个数,每次都会在这3种状态中循环,当出现3次的时候就让他回到初始状态。我们看一下

/**

 *

 * 3种状态

 * 存储    输入   结果

 * ab      c     ab

 * 00      1     01

 * 01      1     10

 * 10      1     00

 *

 * 00      0     00

 * 01      0     01

 * 10      0     10

 *

 * 所以可以列出下面公式

 * a=a&~b&~c | ~a&b&c

 * b= ~a&b&~c|~a&~b&c

 */

我们上面刚才说了,ab只是表示一种状态,那么假如我不选择ab为00,01,10这3种状态,我们选择ab为00,01,11三种状态可不可以,其实完全可以,不管怎么选只要我们保证他的周期是3就行,我们来分析一下如果选00,01,11这3种状态下是什么样的一种情况。

/**

 *

 * 3种状态

 * 存储    输入   结果

 * ab      c     ab

 * 00      1     01

 * 01      1     11

 * 11      1     00

 *

 * 00      0     00

 * 01      0     01

 * 11      0     11

 *

 * 所以可以列出下面公式

 * a=a&~b&~c | ~a&b&c|a&b&~c

 * b= ~a&b&~c|~a&~b&c|~a&b&c|a&b&~c

 */

 1public int singleNumber(int[] nums) {
2    int a = 0, b = 0, i = 0, length = nums.length;
3    while (i < length) {
4        int c = nums[i];
5        int ta = a & ~b & ~c | ~a & b & c | a & b & ~c;
6        b = ~a & b & ~c | ~a & ~b & c | ~a & b & c | a & b & ~c;
7        a = ta;
8        i++;
9    }
10    return b;
11}

写法上确实要复杂一点。确实有一定的难度,希望大家能收藏下来,或者发送给喜欢算法的同学一起来研究下。这里面有很多精髓的地方,并且写法也非常多,我没有一一列出,大家有兴趣的可以研究下。

这里顺便再出几道题,

1,从数组中找出只出现一次的两个数,数组中其他数都出现两次。(就是有2个数只出现一次,其他的数都出现了两次)

 1private static int[] findTwo(int[] array) {
2    if (array.length <= 2)
3        return array;
4    int res = 0;
5    for (int i = 0; i < array.length; i++) {
6        //计算只出现一次的两个数^的结果
7        res ^= array[i];
8    }
9    int index = 1;//从右往左找出第一次出现1的位置。
10    while (res != 0) {
11        if ((res & 1) == 0) {
12            res = res >> 1;
13            index = index << 1;
14        } else {
15            break;
16        }
17    }
18    /**
19     *index实际上是从0开始的,但初始化为1,因为如果初始化为0,
20     *无论怎么移还是0,所以相当于往左多移了一步,这里再往右移一步
21     */
22    index = index >>> 1;
23    int[] result = new int[2];
24    for (int i = 0; i < array.length; i++) {
25        if (((array[i] >> index) & 1) == 1)
26            result[0] ^= array[i];
27        else
28            result[1] ^= array[i];
29    }
30    return result;
31}

我只把结果写上,具体逻辑大家自己去分析

2,从数组中找出只出现一次的三个数,数组中其他数都出现两次。(就是有3个数只出现一次,其他的数都出现了两次)

 1private static int[] findThree(int[] array) {
2    return findThree(array, 1);
3}
4
5private static int[] findThree(int[] array, int index) {
6    int lastOneBit = index;
7    if (array.length <= 3)
8        return array;
9    int res = 0;
10    for (int i = 0; i < array.length; i++) {
11        //计算只出现一次的三个数^的结果
12        res ^= array[i];
13    }
14    while (res != 0) {
15        if ((res & 1) == 0) {
16            res = res >> 1;
17            lastOneBit = lastOneBit << 1;
18        } else {
19            break;
20        }
21    }
22    /**
23     * 如果第一次调用当res为0的时候,就表示res的二进制位中是没有1的,
24     * 那么这样再根据res上是否为1来判断就没有意义了,所以如果出现这种
25     * 情况他是根据最右边的0或1来划分的,如果不幸又分到一组了,那么继
26     * 续递归调用,同时++index,从最右边第二位开始,以此类推,直到这
27     * 3个数没有分到同一组为止。
28     */
29    /**
30     *这里lastOneBit往右移一位的原因是,应该是从最右边第一位开始判断的,
31     * index应该是0,但在第一次调用的时候传的是1,所以这里要往右移一位,
32     * 第一次调用的时候能不能传0,这个是不行的,因为在执行上面的while循环
33     * 的时候0无论往左移多少位都还是0,所以不能传0。
34     */
35    lastOneBit = lastOneBit >>> 1;
36    int[] result = new int[3];
37    List part1 = new ArrayList();//根据0和1分为两部分
38    List part2 = new ArrayList();
39    for (int i = 0; i < array.length; i++) {
40        if (((array[i] >> lastOneBit) & 1) == 1) {
41            part1.add(array[i]);
42            result[0] ^= array[i];
43        } else {
44            part2.add(array[i]);
45            result[1] ^= array[i];
46        }
47    }
48    /**
49     * 下面分4种情况讨论,当然0和1的顺序可以打乱
50     * 1,1^1^1==1
51     * 2,0^0^0==0
52     * 3,0^1^1==0
53     * 4,0^0^1==1
54     */
55    int[] temp;
56    if ((part1.size() & 1) == 1) { //有奇数个数,是上面的1,4
57        if (result[1] == 0) {//情况1
58            return findThree(listToArray(part1), ++index);
59        } else {//情况4
60            temp = findTwo(listToArray(part2));
61        }
62
63    } else {//有偶数个数,是上面的2,3
64        if (result[0] == 0) {//情况2
65            return findThree(listToArray(part2), ++index);
66        } else {//情况3
67            temp = findTwo(listToArray(part1));
68        }
69
70    }
71    result[1] = temp[0];
72    result[2] = temp[1];
73    return result;
74}
75
76private static int[] listToArray(List<Integer> mList) {
77    int[] array = new int[mList.size()];
78    for (int i = 0; i < mList.size(); i++) {
79        array[i] = mList.get(i);
80    }
81    return array;
82}

上面代码都有注释,我就不再分析。下面在分析一种解法

这三个数中只要我们找到一个,其他两个就迎刃而解了,我们换个思路再来分析一下,假如这三个数是a,b,c,他们异或的结果为x,则x=a^b^c;进一步我们可以推算出a^x=b^c,b^x=a^c,c^x=a^b;我们令A=a^x,B=b^x,C=c^x,因为a,b,c都各不相同,所以A,B,C都不为0,我们令f(x)表示x从右边数遇到的第一个1不变,其他的全部置为0的值,比如f(6)=f(0110)=0010=2,f(11)=f(1011)=0001=1。我们令g=f(A)^f(B)^f(C);我们进一步可以得出g肯定是不为0的,因为A,B,C都不为0,所以f(A),f(B),f(C)也分别都不为0,所以他们二进制位有且仅有一个1,其他都是0,也可以说f(A),f(B),f(C)都是2的n次方。假如f(A)^f(B)等于0,那么0^f(C)肯定不等于0,因为f(C)不等于0,所以g不等于0。假如f(A)^f(B)不等于0,那么他们异或结果的二进制位肯定有两个1,然后再与f(C)异或结果肯定不为0,所以可以肯定的是g不为0。我们还可以进一步得出结论g转化为二进制的时候至少有1个1,至多3个1。我们假设g的二进制位从右边数第m位是1,那么f(A),f(B),f(C)从右边数第m位要么只有一个是1其他两个是0,要么3个都是1。假如3个都是1,那么我们可知x的第m位和a,b,c的第m位相反。假如x的第m位是1,那么a,b,c的第m位都为0,所以a^b^c运算结果的第m位不可能为1,所以不成立。假如x的第m位是0,那么a,b,c的第m位都为1,所以a^b^c运算结果的第m位不可能为0,所以可以得出结论f(A),f(B),f(C)的第m位不可能都是1,只能是一个为1,其他两个为0。所以我们的解决方式就有了,把所有值都异或一遍就得到x,x再与a,b,c分别异或求出A,B,C,然后在求出f(A),f(B),f(C)的值,最后在求出g,后面的就很简单了。

 1private static int[] findThree2(int[] array) {
2    int length = array.length;
3    int result[] = new int[3];
4    int temp[] = new int[length + 1];
5    int xorResult = 0;//所有数值异或的结果
6    int i, lastbit1 = 0;
7    for (i = 0; i < length; i++) {
8        //xorResult就是上面分析的x=a^b^c
9        xorResult ^= array[i];
10        temp[i] = array[i];
11    }
12    for (i = 0; i < length; i++) {
13        //lastbit1相当于上面分析的g=f(A)^f(B)^f(C),
14        // xorResult ^ array[i]相当于A,B,C
15        lastbit1 ^= lastBitOf1(xorResult ^ array[i]);
16    }
17    //上面分析的g从右边数第m为是1,其他置为0,因为上面分析的f(A),f(B)
18    // ,f(C)的第m位只有一个是1,其他两个是0,
19    lastbit1 = lastBitOf1(lastbit1);
20
21    for (i = 0; i < length; i++) {
22        // array[i] ^ xorResult相当于A,B,C,在f(A),f(B)f(C)中
23        //第m位为1的分为一组,进行异或运算求得值
24        if (lastBitOf1(array[i] ^ xorResult) == lastbit1)
25            result[0] ^= array[i];//找到第一个值
26    }
27    //第一个值找到后放到数组中让他的个数成为偶数,问题转化为求剩余两个的值
28    temp[length] = result[0];
29    //让xorResult成为剩余两个数异或的结果
30    xorResult ^= result[0];
31    //两个数的时候就可以根据右边第一次出现两个不同的值1和0的时候来划分。
32    lastbit1 = lastBitOf1(xorResult);
33    for (i = 0; i < length + 1; i++) {
34        if ((temp[i] & lastbit1) != 0)
35            result[1] ^= temp[i];//找到第二个值
36    }
37    result[2] = xorResult ^ result[1];//找出第三个
38    return result;
39}
40
41private static int lastBitOf1(int num) {
42    return num & (-num);
43}

3,从数组中找出只出现m次数,数组中其他数都出现n次(使用&运算符解答,并且m不等于n,也不能是n的倍数)

当然这种解法就比较多了,因为m和n都不确定,我们也没有一个万能的公式,我们需要根据具体的m和n来实现不同的算法,我们假如n等于4,有4个重复的,看下怎么写

/**

 *

 * 4种状态

 * 存储    输入   结果

 * ab      c     ab

 * 00      1     01

 * 01      1     10

 * 10      1     11

 * 11      1     00

 *

 * 00      0     00

 * 01      0     01

 * 10      0     10

 * 11      0     11

 *

 * 所以可以列出下面公式

 * a=~a&b&c|a&~b&c|a&~b&~c|a&b&~c

 * b= ~a&~b&c|a&~b&c|~a&b&~c|a&b&~c

 */

 1public static int findOnce4(int[] array) {
2    int a = 0, b = 0, i = 0, length = array.length;
3    while (i < length) {
4        int c = array[i];
5        int ta = ~a & b & c | a & ~b & c | a & ~b & ~c | a & b & ~c;
6        b = ~a & ~b & c | a & ~b & c | ~a & b & ~c | a & b & ~c;
7        a = ta;
8        i++;
9    }
10    return a | b;
11}

下面的几个只是列出了答案,具体问题大家可以自己分析。如果能研究透,基本上对二进制有关的算法会有一个很大的提升。也希望大家多看多想多练,思考非常重要。当然后面的推送可能要暂停一段时间,真的是希望大家能把这块研究透,如果实在不感兴趣在这段时间可以看看以前的题

标签:11,10,return,数字,int,II,272,result,array
来源: https://blog.51cto.com/u_4774266/2902515