5.优化算法之位运算

0.常见位运算

1.基础位运算 

2.给一个数 n，确定它的二进制表示中的第x位是0还是 1 

 3.将一个数 n 的二进制表示的第 x位修改成 1

4.将一个数 n 的二进制表示的第x位修改成 0 

5.位图的思想

用整型变量某一个byte位的0，1来表示信息 

6. 提取一个数(n)二进制表示中最右侧的 1

-n===按位取反再加1 

7.干掉一个数(n)二进制表示中最右侧的 1

（1）位1的个数

191. 位1的个数 - 力扣（LeetCode）

public class Solution {
    public int hammingWeight(int n) {
        int ret = 0;
        while (n != 0) {
            n &= n - 1;
            ret++;
        }//干掉最右侧的1
        return ret;
    }
}

（2）比特位计数 

338. 比特位计数 - 力扣（LeetCode）

class Solution {
    public int[] countBits(int n) {
        int[] bits=new int[n+1];
        for(int i=0;i<=n;i++){
            bits[i]=countOnes(i);
        }
        return bits;
    }

    public int countOnes(int x) {
        int ones = 0;
        while (x > 0) {
            x &= (x - 1);
            ones++;
        }
        return ones;
    }
}

（3）汉明距离 

461. 汉明距离 - 力扣（LeetCode）

两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。

给你两个整数 x 和 y，计算并返回它们之间的汉明距离。

（不同的数进行异或，就会得到有1的数）

class Solution {
    public int hammingDistance(int x, int y) {
        int s = x ^ y, ret = 0;
        while (s != 0) {
            s &= s - 1;
            ret++;
        }
        return ret;
    }
}

8.位运算的优先级

能加括号就加括号 

9.异或(^)运算的运算律

（1）只出现一次的数字

给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

class Solution {
    public int singleNumber(int[] nums) {
        int single = 0;
        for (int num : nums) {
            single ^= num;
        }
        return single;
    }
}

（2）只出现一次的数字3（重点）

给你一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。你可以按 任意顺序 返回答案。

你必须设计并实现线性时间复杂度的算法且仅使用常量额外空间来解决此问题。

260. 只出现一次的数字 III - 力扣（LeetCode）

class Solution {
    public int[] singleNumber(int[] nums) {
        int xorsum = 0;
        for (int num : nums) {
            xorsum ^= num;//就是最终的x:x=x1^x2
        }
        // 防止溢出
        int lsb = (xorsum == Integer.MIN_VALUE ? xorsum : xorsum & (-xorsum));
        //表示最低位的1，此时的位置是是最右侧的第l位为1，而另一个则是第l位为0
        int type1 = 0, type2 = 0;
        for (int num : nums) {
            if ((num & lsb) != 0) {//基于此分为两类
                type1 ^= num;
            } else {
                type2 ^= num;
            }
        }
        return new int[]{type1, type2};
    }
}

1.判断字符是否唯一

面试题 01.01. 判定字符是否唯一 - 力扣（LeetCode）

实现一个算法，确定一个字符串 s 的所有字符是否全都不同。

示例 1：

输入: s = "leetcode"
输出: false 

示例 2：

输入: s = "abc"
输出: true

解法一：借助哈希表

解法二：位图

 

优化点 

class Solution {
    public boolean isUnique(String astr) {
        //1.利用鸽巢原理进行优化
        if(astr.length()>26){
            return false;
        }
        int bitMap=0;
        for(int i=0;i<astr.length();i++){
            int x=astr.charAt(i)-'a';
            //给一个数 n，确定它的二进制表示中的第x位是0还是 1 
            //(n>>x)&1->结果为0就是0，结果为1就说明此时字符不唯一
            if(((bitMap>>x)&1)==1){
                return false;
            }else{
                //将一个数 n 的二进制表示的第 x位修改成 1
                bitMap=bitMap|(1<<x);
            }
        }
        return true;
    }
}

 2.丢失的数字

 268. 丢失的数字 - 力扣（LeetCode）

解法一：哈希表

解法二：高斯求和 

 

解法三：位运算 

 

class Solution {
    public int missingNumber(int[] nums) {
        int ret=0;
        for(int num:nums){
            ret=ret^num;
        }
        for(int i=0;i<=nums.length;i++){
            ret=ret^i;
        }
        return ret;
    }
}

 3.两整数之和

371. 两整数之和 - 力扣（LeetCode）

class Solution {
    public int getSum(int a, int b) {
        while(b!=0){
            int x=a^b;//计算出无进位相加的结果
            int carry=(a&b)<<1;//计算进位
            a=x;
            b=carry;
        }
        return a;
    }
}

 4.只出现一次的数字2

137. 只出现一次的数字 II - 力扣（LeetCode）

给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法且使用常数级空间来解决此问题。

class Solution {
    public int singleNumber(int[] nums) {
        int ret=0;
        for(int i=0;i<32;i++){//依次修改ret中的每一个比特位
            int sum=0;
            for(int x:nums){//统计nums中所有数的第i位和
                if(((x>>i)&1)==1){//看第i位是否为1
                    sum++;
                }
            }
            sum=sum%3;
            if(sum==1){
                ret=ret|(1<<i);//把第i位设置为1
            }
        }
        return ret;
    }
}

5.消失的两个数字 

面试题 17.19. 消失的两个数字 - 力扣（LeetCode）

class Solution {
    public int[] missingTwo(int[] nums) {
        //1.先把所有的数异或在一起
        int tmp=0;
        for(int x:nums){
            tmp=tmp^x;
        }
        for(int i=1;i<=nums.length+2;i++){
            tmp=tmp^i;
        }
        //找出a,b两个数比特位不同的那一位
        int diff=0;
        while(true){
            if((tmp>>diff)==1){
                break;
            }else{
                diff++;
            }
        }
        //将所有的数按照diff位不同分为两类
        int[] ret=new int[2];
        for(int x:nums){
            if(((x>>diff)&1)==1){
                ret[1]=ret[1]^x;
            }else{
                ret[0]=ret[0]^x;
            }
        }
        for(int i=1;i<=nums.length+2;i++){
            if(((i>>diff)&1)==1){
                ret[1]=ret[1]^i;
            }else{
                ret[0]=ret[0]^i;
            }
        }
        return ret;
    }
}