LeetCode之位运算

67. 二进制求和

class Solution {

    public String addBinary(String a, String b) {
        StringBuilder sb = new StringBuilder();

        int i = a.length() - 1;
        int j = b.length() - 1;
        int carry = 0;
        while (i >= 0 || j >= 0) {
            int sum = carry;

            sum += (i >= 0) ? a.charAt(i--) - '0' : 0;
            sum += (j >= 0) ? b.charAt(j--) - '0' : 0;

            sb.append(sum % 2);
            carry = (sum / 2);
        }
        if (carry > 0) {
            sb.append(carry);
        }
        return sb.reverse().toString();
    }

}

190. 颠倒二进制位

public class Solution {
    public int reverseBits(int n) {
        // 用于存储反转后的结果
        int rev = 0;
        // 循环 32 次，因为一个整数是 32 位
        for (int i = 0; i < 32 && n!= 0; ++i) {
            // 取出 n 的最低位
            int lowestBit = n & 1;
            // 将最低位左移到对应的反转位置并与 rev 进行或操作，实现将反转后的位添加到结果中
            rev |= lowestBit << (31 - i);
            // n 无符号右移一位，准备处理下一位
            n >>>= 1;
        }
        // 返回反转后的结果
        return rev;
    }
}

191. 位1的个数
 

public class Solution {
    // 方法用于计算给定无符号整数 n 的汉明重量，即二进制表示中 '1' 的数量
    public int hammingWeight(int n) {
        int ret = 0; // 用于记录 '1' 的数量
        
        // 通过循环从 0 到 31 (32 位整数)
        for (int i = 0; i < 32; i++) {
            // 使用位移操作检查 n 的第 i 位是否为 '1'
            if ((n & (1 << i)) != 0) {
                ret++; // 如果第 i 位为 '1'，则将计数器加 1
            }
        }
        
        // 返回 '1' 的数量
        return ret;
    }
}

136. 只出现一次的数字

public class Solution {
    // 方法用于找到在数组中只出现一次的数字
    public int singleNumber(int[] nums) {
        int single = 0; // 初始化一个变量，用于存储结果
        
        // 遍历数组中的每一个数字
        for (int num : nums) {
            // 使用异或运算符
            // 异或运算的特性是相同的数字相互抵消（num ^ num = 0），
            // 0 与任何数字异或都等于该数字 (0 ^ num = num)。
            single = single ^ num;
        }
        
        // 返回只出现一次的数字
        return single;
    }
}

137. 只出现一次的数字 II

public class Solution {
    // 方法用于找出在数组中只出现一次的数字（其他数字出现三次）
    public int singleNumber(int[] nums) {
        int ans = 0; // 用于存储最终结果，初始化为 0
        
        // 遍历二进制位，从 0 到 31（假设使用 32 位整数）
        for (int i = 0; i < 32; ++i) {
            int total = 0; // 初始化计数器，用于统计当前位的 '1' 的数量
            
            // 遍历数组中的每个数字
            for (int num : nums) {
                // 右移 num 的 i 位，并和 1 进行按位与操作
                total += ((num >> i) & 1); // 统计第 i 位 '1' 的总数
            }
            
            // 如果 '1' 的总数不是 3 的倍数，则说明在 '1' 的位置上是唯一出现一次的数字
            if (total % 3 != 0) {
                ans |= (1 << i); // 将 ans 的第 i 位设为 '1'
            }
        }
        
        // 返回只出现一次的数字
        return ans;
    }
}

201. 数字范围按位与

public class Solution {
    // 方法用于计算 m 和 n 之间所有数字的按位与
    public int rangeBitwiseAnd(int m, int n) {
        // 当 m 小于 n 时，继续循环
        while (m < n) {
            // 抹去 n 的最右边的 1 位
            n = n & (n - 1);
            // 此操作将 n 的最右边的 1 置为 0
            // 例如：
            // 如果 n = 6 (二进制为 110)，
            // n - 1 = 5 (二进制为 101)。
            // n & (n - 1) 结果为 4 (二进制为 100)，即将最右边的 1 去掉。
        }
        // 当 m >= n 时，返回 n，这时 n 和 m 之间的所有数的按位与的结果
        return n;
    }
}