Leetcode 题解 - 位运算(6-9) :不用额外变量交换两个整数

6.不用额外变量交换两个整数

程序员代码面试指南 ：P317

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

7 [LeetCode] Power of Two 判断2的次方数

 

Given an integer, write a function to determine if it is a power of two.

Example 1:

Input: 1
Output: true

Example 2:

Input: 16
Output: true

Example 3:

Input: 218
Output: false

 

这道题让我们判断一个数是否为2的次方数，而且要求时间和空间复杂度都为常数，那么对于这种玩数字的题，我们应该首先考虑位操作 Bit Operation。在LeetCode中，位操作的题有很多，比如比如 Repeated DNA Sequences，Single Number,  Single Number II， Grey Code， Reverse Bits，Bitwise AND of Numbers Range，Number of 1 Bits 和 Divide Two Integers 等等。那么我们来观察下2的次方数的二进制写法的特点：

1     2       4         8         16 　　....

1    10    100    1000    10000　....

那么我们很容易看出来2的次方数都只有一个1，剩下的都是0，所以我们的解题思路就有了，我们只要每次判断最低位是否为1，然后向右移位，最后统计1的个数即可判断是否是2的次方数，代码如下：

class Solution {
    public boolean isPowerOfTwo(int n) {
        if(n == 0)
            return false;
        int res = 0;
        while(n > 0){
            if((n & 1) == 1)
                res++;
            n = n >> 1;
        }
        return  res == 1;
    }
}

 

道题还有一个技巧，如果一个数是2的次方数的话，根据上面分析，那么它的二进数必然是最高位为1，其它都为0，那么如果此时我们减1的话，则最高位会降一位，其余为0的位现在都为变为1，那么我们把两数相与，就会得到0，用这个性质也能来解题，而且只需一行代码就可以搞定，如下所示：

public boolean isPowerOfTwo(int n) {
    return n > 0 && (n & (n - 1)) == 0;
}


public boolean isPowerOfTwo(int n) {
    return n > 0 && Integer.bitCount(n) == 1;
}

8 [LeetCode] Power of Four 判断4的次方数

 

Given an integer (signed 32 bits), write a function to check whether it is a power of 4.

Example:
Given num = 16, return true. Given num = 5, return false.

Follow up: Could you solve it without loops/recursion?

Credits:
Special thanks to @yukuairoy for adding this problem and creating all test cases.

 

这道题让我们判断一个数是否为4的次方数，那么最直接的方法就是不停的除以4，看最终结果是否为1，参见代码如下：

 

解法一：

class Solution {
    public boolean isPowerOfFour(int n) {
        if(n == 0)
            return false;
        while( n % 4 == 0)
            n = n >> 2;
        return n == 1;
    }
}

下面这种方法是网上比较流行的一种解法，思路很巧妙，首先根据Power of Two中的解法二，我们知道num & (num - 1)可以用来判断一个数是否为2的次方数，更进一步说，就是二进制表示下，只有最高位是1，那么由于是2的次方数，不一定是4的次方数，比如8，所以我们还要其他的限定条件，我们仔细观察可以发现，4的次方数的最高位的1都是计数位，那么我们只需与上一个数(0x55555555) <==> 1010101010101010101010101010101，如果得到的数还是其本身，则可以肯定其为4的次方数：

 

解法二：

class Solution {
    public boolean isPowerOfFour(int num) {
        if(num <= 0)
            return false;
        return ((num & (num - 1)) == 0) && ((num & 0x55555555) == num) ;
    }
}

或者我们在确定其是2的次方数了之后，发现只要是4的次方数，减1之后可以被3整除，所以可以写出代码如下：

 

解法三：

class Solution {
    public boolean isPowerOfFour(int num) {
        if(num <= 0)
            return false;
        return ((num & (num - 1)) == 0) && ((num-1) % 3 == 0) ;
    }
}

9 [LeetCode] Binary Number with Alternating Bits 有交替位的二进制数

 

Given a positive integer, check whether it has alternating bits: namely, if two adjacent bits will always have different values.

Example 1:

Input: 5
Output: True
Explanation:
The binary representation of 5 is: 101

 

Example 2:

Input: 7
Output: False
Explanation:
The binary representation of 7 is: 111.

 

Example 3:

Input: 11
Output: False
Explanation:
The binary representation of 11 is: 1011.

 

Example 4:

Input: 10
Output: True
Explanation:
The binary representation of 10 is: 1010.

下面这种解法写的更加简洁了，我们不需要用if条件来判断，而是可以通过‘亦或’1的方式来将0和1互换，当然我们也可以通过d = 1 - d 来达到同样的效果，但还是写成‘亦或’1比较叼，while循环的条件是最低位等于d，而d不停的在0和1之间切换，n每次也向右平移一位，这样能交替检测0和1，循环退出后，如果n为0，则返回true，反之则返回false，参见代码如下：

 

解法二：

class Solution {
public:
    bool hasAlternatingBits(int n) {
        int d = n & 1;
        while ((n & 1) == d) {
            d ^= 1;
            n >>= 1;
        }
        return n == 0;
    }
};

class Solution {
    public boolean hasAlternatingBits(int n) {
        int cp = n & 1;
        n = n >> 1;
        while(n > 0){
            int num = n & 1;
            if(num == cp)
                return false;
            cp = num;
            n = n >> 1;
        }
        return true;
    }
}

class Solution {
    public boolean hasAlternatingBits(int n) {
        int cp = n & 1;
        while((n & 1) == cp){
            cp ^= 1;
            n = n >> 1;
        }
        return n == 0;
    }
}

 

下面这种解法就十分的巧妙了，利用了0和1的交替的特性，进行错位相加，从而组成全1的二进制数，然后再用一个检测全1的二进制数的trick，就是‘与’上加1后的数，因为全1的二进制数加1，就会进一位，并且除了最高位，其余位都是0，跟原数相‘与’就会得0，所以我们可以这样判断。比如n是10101，那么n>>1就是1010，二者相加就是11111，再加1就是100000，二者相‘与’就是0，参见代码如下：

 

解法三：

class Solution {
public:
    bool hasAlternatingBits(int n) {
        return ((n + (n >> 1) + 1) & (n + (n >> 1))) == 0;
    }
};

 

下面这种解法也很巧妙，先将n右移两位，再和原来的n亦或，得到的新n其实就是除了最高位，其余都是0的数，然后再和自身减1的数相‘与’，如果是0就返回true，反之false。比如n是10101，那么n/4是101，二者相‘亦或’，得到10000，此时再减1，为1111，二者相‘与’得0，参见代码如下：

 

解法四：

class Solution {
public:
    bool hasAlternatingBits(int n) {
        return ((n ^= n / 4) & (n - 1)) == 0;
    }
};