数据结构-位运算笔记

基础

【位运算】------揭秘位运算：高效解题的关键技巧_常见位运算-CSDN博客

位1的个数

java 复制代码

class Solution {
    // 定义一个公共方法hammingWeight，它接受一个整数n作为参数，并返回一个整数。
    public int hammingWeight(int n) {
        // 初始化一个变量ret，用来存储汉明权重的结果，初始值为0。
        int ret = 0;

        // 循环32次，因为一个整数（int类型）在Java中是32位的。
        for (int i = 0; i < 32; i++) {
            // 使用位运算符"&"和左移操作"<<"来检查n的第i位是否为1。
            // (n & (1 << i)) != 0 这个表达式的意思是，将1左移i位后与n进行按位与操作。
            // 如果结果不为0，说明n的第i位是1。
            if ((n & (1 << i)) != 0) {
                // 如果第i位是1，那么将ret加1，因为汉明权重就是1的个数。
                ret++;
            }
        }

        // 循环结束后，返回计算得到的汉明权重。
        return ret;
    }
}

Pow(x, n)

java 复制代码

class Solution {
    // 计算x的n次幂
    // x: 底数
    // n: 指数，可以是正数或负数
    public double myPow(double x, int n) {
        // 将n转换为长整型，以处理大整数
        long N = n;
        
        // 如果N是非负数，直接计算x的N次幂
        // 如果N是负数，计算x的(-N)次幂，然后取倒数
        return N >= 0 ? pow(x, N) : 1.0 / pow(x, -1 * N);
    }

    // 递归方法，用于计算x的N次幂
    // x: 底数
    // N: 指数，长整型，用于处理大整数
    double pow(double x, long N) {
        // 如果指数N为0，任何数的0次幂都是1
        if (N == 0) {
            return 1.0;
        }

        // 递归计算x的N/2次幂
        double y = pow(x, N / 2);

        // 如果N是偶数，那么x^N = (x^(N/2))^2
        // 如果N是奇数，那么x^N = x * (x^(N/2))^2
        return N % 2 == 0 ? y * y : y * y * x;
    }
}

撞色搭配

java 复制代码

class Solution {
    public int[] sockCollocation(int[] sockets) {
        // 初始化变量
        // n 用于存储所有插座的异或结果
        int n = 0;
        // m 用于找到 n 中最低位的 1
        int m = 1;
        // p 和 q 分别用于存储与 m 位为 1 和 0 的插座的异或结果
        int p = 0;
        int q = 0;

        // 计算所有插座的异或结果
        for(int socket : sockets){
            n ^= socket;
        }

        // 找到 n 中最低位的 1
        while((n & m) == 0){
            m <<= 1; // 将 m 左移一位，直到找到 n 的最低位 1
        }

        // 根据 m 的最低位 1，将插座分为两组，并计算每组的异或结果
        for(int socket : sockets){
            if((socket & m) != 0){ // 如果插座的 m 位为 1
                p ^= socket; // 将该插座加入到 p 的异或计算中
            }else{ // 如果插座的 m 位为 0
                q ^= socket; // 将该插座加入到 q 的异或计算中
            }
        }
        // 返回两种不同插座的二进制表示
        return new int[]{p, q};
    }
}

训练计划 VI

java 复制代码

class Solution {
    public int trainingPlan(int[] actions) {
        // 创建一个长度为32的数组，用于统计每个位上1的个数
        int demo[] = new int[32];
        
        // 遍历actions数组中的每个整数
        for(int action : actions){
            // 从最低位开始，逐位检查action中的每个位
            for(int i = 0 ; i < 32; i++){
                // 如果当前位是1，则在demo数组对应的位置上加1
                demo[i] += action & 1;
                // 将action右移一位，准备检查下一位
                action >>= 1;
            }
        }

        // 初始化变量m为3，表示每个位上1的最大个数
        int m = 3;
        // 初始化返回值ret为0
        int ret = 0;
        // 从最高位开始，逆序遍历demo数组
        for(int i = 31; i >= 0; i--){
            // 将ret左移一位，为新的位腾出空间
            ret <<= 1;
            // 将demo[i]除以m的余数作为新的位加到ret上
            ret |= demo[i] % m;
        }

        // 返回构造好的整数
        return ret;
    }
}

加密运算

java 复制代码

class Solution {
    /**
     * 进行加密计算的方法。
     * 这个方法使用异或运算和位移运算来加密两个整数。
     * @param dataA 第一个整数数据。
     * @param dataB 第二个整数数据。
     * @return 加密后的结果。
     */
    public int encryptionCalculate(int dataA, int dataB) {
        // 进位
        int nextPoi; // 用于存储进位值
        // 本位
        int localPoi; // 这个变量实际上没有在代码中使用，可能是一个遗留的变量

        // 使用while循环，直到dataA变为0
        while(dataA != 0){
            // 计算进位值，即dataA和dataB按位与的结果左移1位
            nextPoi = (dataA & dataB) << 1;
            // 将dataB和dataA进行异或运算，更新dataB的值
            dataB ^= dataA;
            // 将进位值赋给dataA，用于下一次循环
            dataA = nextPoi;
        }

        // 当dataA为0时，循环结束，返回dataB，即加密后的结果
        return dataB;
    }
}