算法：位运算

已于 2024-05-16 11:55:41 修改
阅读量127 收藏
点赞数
分类专栏： 算法 文章标签： 算法
于 2021-03-26 00:31:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40548136/article/details/115222611
版权

文章目录

1. 二进制基础

原码反码补码

原码：10进制转换成2进制是原码，只不过正数的原码是本身符号位为0，负数的原码符号位为1
10进制1的原码是 0000 0001
10进制-1的原码是 1000 0001

反码：正数的反码是原码，负数的反码是负数的原码按位取反。
-1的原码是 1000 0001
-1的反码就是 1111 1110（注意负数求反码时候的符号位不参与变换）。

补码： 正数的补码是原码，负数的补码就是负数的反码加1。
-1的原码是 1000 0001
-1的反码就是 1111 1110
-1的补码就是 1111 1111

如果是有符号的数据类型，规定最高位（符号位）正数为0，负数为1。

总结：正数的原码，反码 ，补码三值合一， 负数的原码，反码，补码不同。

补码的引入为计算机更好做减法，原码里-1+1=-2，补码里-1+1=0。

负数在计算机中怎样存储

补码表示的整数

可以看到，对于正数，补码与原码是相同的。以32位整数为例从
2147483647~0
从-1~-2147483648，则有不同，其补码从
1111 1111 1111 1111 1111 1111 1111 1111 ~
1000 0000 0000 0000 0000 0000 0000 0000

-2147483648的原码是1000 0000 0000 0000 0000 0000 0000 0000
-2147483648的反码是1111 1111 1111 1111 1111 1111 1111 1111
-2147483648的补码是1000 0000 0000 0000 0000 0000 0000 0000

-2147483647的原码为10000000000000000000000000000001
-2147483647的反码为11111111111111111111111111111110
-2147483647的补码为11111111111111111111111111111111

2.位运算

位运算在算法中占据重要一席，常见的位运算有

  • 取反 “~”
  • 并 “&”
  • 或 “|”
  • 异或 “^”
  • 左移 “<<”
  • 右移 “>>”（有符号右移）
  • 无符号右移 “>>>”（java）

常用位特性

x&(x-1)

该运算将 x 的二进制表示的最后一个1变成0。可以计算x二进制中1的个数。
题目1：
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中设置位的个数（也被称为汉明重量）。
191. 位1的个数

class Solution {
public:
    int hammingWeight(int n) {
        int ans = 0;
        while(n>0){
            n = n&(n-1);
            ans += 1;
        }
        return ans;
    }
};

题目2：
201. 数字范围按位与

a^b^a=b

给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。
136. 只出现一次的数字

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans =0;
        for(int i=0;i<nums.size();i++){
            ans ^= nums[i];
        }
        return ans;
    }
};

x=x&(-x)

该运算获取x二进制表示的最低位1表示的数字，可以用于树状数组的lowBit更新，也可用于遍历x二进制的1。
一个值b位运算的性质有

其他常见特性

  • b^0=b
  • b^1=~b
  • b&1=b (b为奇数)
  • b&0=0
  • b|0=b
  • b为偶数 b^1=b+1
  • b为奇数 b^1=b-1

3. 算法题目

3.1 位运算空间压缩

位运算做优化的几道题目，位运算即用作空间压缩，又加快检索。
LeetCode 37.解数独
LeetCode 36.有效数独

3.2 限制运算

最大数值

编写一个方法，找出两个数字a和b中最大的那一个。不得使用if-else或其他比较运算符。
面试题 16.07. 最大数值

class Solution:
    def maximum(self, a: int, b: int) -> int:
        asigned = int(bin(a)[0]=='-') # 1 表示负数
        bsigned = int(bin(b)[0]=='-')
        k = asigned ^ bsigned  # k=1异号; k=0同号
        sign = int(bin(a-(1-k)*b)[0]=='-')
        return (1-sign)*a + sign*b

面试题 17.01. 不用加号的加法

设计一个函数把两个数字相加。不得使用 + 或者其他算术运算符。

class Solution {
public:
    int add(int a, int b) {
        int c;
        while (b!=0){
            c = (a&b)<<1; //进位加法
            a = a^b; //非进位加法
            b = c;
        }
        return a;
    }
};

面试题 17.01. 不用加号的加法

面试题 16.09. 运算

这道题不能使用位运算，但需要对二进制足够熟悉。
请实现整数数字的乘法、减法和除法运算，运算结果均为整数数字，程序中只允许使用加法运算符和逻辑运算符，允许程序中出现正负常数，不允许使用位运算。
你的实现应该支持如下操作：
Operations() 构造函数
minus(a, b) 减法，返回a - b
multiply(a, b) 乘法，返回a * b
divide(a, b) 除法，返回a / b

面试题 16.09. 运算

class Operations {
private:
	using ll = long long;
	vector<ll> neg, pos;
	ll ne;
	ll Neg(int b) {
		if (!b) return b;
		ll ret = 0;
		if (b > 0) {
			int index = neg.size() + ne;
			while (b) {
				if (pos[index] > b) {
					index += ne;
				}
				else {
					b += neg[index];
					ret += neg[index];
				}
			}
		}
		else {
			int index = neg.size() + ne;
			while (b) {
				if (neg[index] < b) {
					index += ne;
				}
				else {
					b += pos[index];
					ret += pos[index];
				}
			}
		}
		return ret;
	}
public:
	Operations() {
		ll po = 1;
		ne = (int)((unsigned int)INT_MAX + INT_MAX + 1);
		ll neg_min = (int)((unsigned int)INT_MAX + 1);
		neg.push_back(ne);
		while (ne > neg_min) {
			ne += ne;
			neg.push_back(ne);
		}
		pos.push_back(po);
		while (po < INT_MAX) {
			po += po;
			pos.push_back(po);
		}
		ne = (int)((unsigned int)INT_MAX + INT_MAX + 1);
	}

	int minus(int a, int b) {
		return a + Neg(b);
	}

	int multiply(int a, int b) {
		if (a == 0 || b == 0) return 0;
		bool flag = false;
		if (a > 0 && b < 0 || (a < 0 && b>0)) {
			flag = true;
		}
		ll A = a < 0 ? Neg(a) : a, B = b < 0 ? Neg(b) : b;
		ll ret = 0;
		ll base = A;
		vector<bool> isOne(neg.size());//类似于快速幂的思想，可惜不能用位运算
		int index = neg.size() + ne;
		for (; index >= 0; index += ne) {
			if (pos[index] <= B) {
				isOne[index] = true;
				B += neg[index];
				if (!B) break;
			}
		}
		for (index = 0; index < neg.size(); index += 1) {
			if (isOne[index]) {
				ret += base;
			}
			base += base;
		}
		if (flag) ret = Neg(ret);
		return ret;
	}

	int divide(int a, int b) {
		if (a == 0) return 0;
		bool flag = false;
		if (a > 0 && b < 0 || (a < 0 && b>0)) {
			flag = true;
		}
		ll A = a < 0 ? Neg(a) : a, B = b < 0 ? Neg(b) : b;
		ll neg_B = Neg(B);
		ll base_B = B;
		ll ret = 0;
		vector<ll> base_pos;
		vector<ll> base_neg;
		while (A >= base_B) {
			base_pos.push_back(base_B);
			base_neg.push_back(neg_B);
			base_B += base_B;
			neg_B += neg_B;
		}
		ll index = base_pos.size() + ne;
		for (; index >= 0; index += ne) {
			if (base_pos[index] <= A) {
				ret += pos[index];
				A += base_neg[index];
				if (A == 0) break;
			}
		}
		if (flag) ret = Neg(ret);
		return ret;
	}
};

3.3 二进制位操作

面试题 05.01. 插入

给定两个整型数字 N 与 M，以及表示比特位置的 i 与 j（i <= j，且从 0 位开始计算）。

编写一种方法，使 M 对应的二进制数字插入 N 对应的二进制数字的第 i ~ j 位区域，不足之处用 0 补齐。具体插入过程如图所示。
面试题 05.01. 插入
在这里插入图片描述

class Solution:
    def insertBits(self, N: int, M: int, i: int, j: int) -> int:
        M = M<<i
        for x in range(i,j+1):
        	# 对应位数不相等
            if (M & 1<<x)^(N & 1<<x):
                N ^= 1<<x  # 取反
        return N

面试题 05.07. 配对交换

配对交换。编写程序，交换某个整数的奇数位和偶数位，尽量使用较少的指令（也就是说，位0与位1交换，位2与位3交换，以此类推）。
面试题 05.07. 配对交换

class Solution:
    def exchangeBits(self, num: int) -> int:
        x1 = num & 0x55555555
        x2 = num & 0xaaaaaaaa
        x1 = x1<<1
        x2 = x2>>1
        return x1|x2
# 法2
class Solution:
    def exchangeBits(self, num: int) -> int:
        for i in range(0,32,2):
            n1 = num & (1<<i)
            n1 = n1<<1
            n2 = num & (1<<(i+1))
            n2 = n2>>1
            if (num^n1)&(1<<(i+1)):
                num ^= 1<<i+1
            if (num^n2)&(1<<i):
                num ^=1<<i
        return num

面试题 05.04. 下一个数

下一个数。给定一个正整数，找出与其二进制表达式中1的个数相同且大小最接近的那两个数（一个略大，一个略小）。
这里采用最朴素解法，对于略大值，找到第一个01；对于略小值，找到第一个10。

class Solution:
    def findClosedNumbers(self, num: int) -> List[int]:
        cur = -1
        cur2 = -1
        pre = -1
        nex = -1
        # 0000 0111 1100
        for i in range(32):
            if num &(1<<i) == 0:
                if cur==-1:
                    pre = i
                if cur2 != -1 and nex == -1:
                    nex = i
            if num &(1<<i):
                if pre != -1 and cur == -1:
                    cur = i
                if nex == -1:
                    cur2 = i
        # print(cur, pre, cur2, nex)
        ans = []
        if nex != -1 and nex != 31:
            x = num ^ (1<<cur2)
            x |= 1<<nex
            
            left, right = cur2-1, 0
            while left > right:
                while right < left and x&(1<<right)>0:
                    right += 1
                if left <= right: break
                while left > right and x & (1<<left)==0:
                    left -= 1

                if left <= right: break
                x ^= 1<<left
                x |= 1<<right
            ans.append(x)
        else:
            ans.append(-1)
        if pre != -1 and cur > pre:
            x = num ^ (1<<cur)
            x |= 1<<pre
            left, right = pre-1,0
            while left > right:
                while left > right and x & (1<<left):
                    left -= 1
                if left <= right: break
                while right < left and x&(1<<right)==0:
                    right += 1
                if left <= right: break
                x |= 1<<left
                x ^= 1<<right

            ans.append(x)
        else:
            ans.append(-1)
        return ans

3.4 转换

整数转换

编写一个函数，确定需要改变几个位才能将整数A转成整数B。
整数转换

class Solution:
    def convertInteger(self, A: int, B: int) -> int:
        # bl = max(A.bit_length(), B.bit_length())
        # print(bl)
        C = A^B
        ans = 0
        for i in range(32):
            if C & (1<<i):
                # print(i)
                ans += 1
        return ans

面试题 05.02. 二进制数转字符串

二进制数转字符串。给定一个介于0和1之间的实数（如0.72），类型为double，打印它的二进制表达式。如果该数字无法精确地用32位以内的二进制表示，则打印“ERROR”。
二进制0.101表示 1 2 1 + 0 2 2 + 1 2 3 \frac{1}{2^1}+\frac{0}{2^2}+\frac{1}{2^3} 211​+220​+231​，十进制数字0.625

最基础的算法就是逐步判断:
0.625>0.5 第一位为1，剩余0.125
0.125<0.25，第二位为0
0.125>=0.125，第三位为1，剩余0.0

可以将上述运算转换为：
0.6252=1.25 第一位为1，剩余0.25
0.252=0.5 第二位为0，剩余0.5
0.5*2=1.0 第三位为1，剩余0

class Solution:
    def printBin(self, num: float) -> str:
        res = "0."
        while len(res)<32 and num !=0:
            num = num*2
            up = int(num)
            res += str(up)
            num = num - up
        return res if num==0 else "ERROR"

面试题 05.02. 二进制数转字符串

3.5 二进制的异或

面试题 17.04. 消失的数字

数组nums包含从0到n的所有整数，但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(n)时间内完成吗？

注意：本题相对书上原题稍作改动
面试题 17.04. 消失的数字

面试题 16.04. 井字游戏

设计一个算法，判断玩家是否赢了井字游戏。输入是一个 N x N 的数组棋盘，由字符" “，“X"和"O"组成，其中字符” “代表一个空位。
以下是井字游戏的规则：
玩家轮流将字符放入空位（” “）中。
第一个玩家总是放字符"O”，且第二个玩家总是放字符"X”。
"X"和"O"只允许放置在空位中，不允许对已放有字符的位置进行填充。
当有N个相同（且非空）的字符填充任何行、列或对角线时，游戏结束，对应该字符的玩家获胜。
当所有位置非空时，也算为游戏结束。
如果游戏结束，玩家不允许再放置字符。
如果游戏存在获胜者，就返回该游戏的获胜者使用的字符（“X"或"O”）；如果游戏以平局结束，则返回 “Draw”；如果仍会有行动（游戏未结束），则返回 “Pending”。
面试题 16.04. 井字游戏

class Solution {
public:
    string tictactoe(vector<string>& board) {
        int N = board.size();
        bool is_full = true;
        bool XDiaWin = false, ODiaWin = false;
        bool XiDiaWin = false, OiDiaWin = false;
        for(int i=0;i<N;++i)
        {
            bool XRowWin = false, XColWin = false;
            bool ORowWin = false, OColWin = false;
            for(int j=0;j<N;++j)
            {
                if(is_full && board[i][j] == ' ')
                {
                    is_full = false;
                }
                // 一点改进: 只需要异或判断是否：一直是'X' or 'O'
                if(!XRowWin) XRowWin = ('X' ^ board[i][j]);
                if(!ORowWin) ORowWin = ('O' ^ board[i][j]);
                if(!XColWin) XColWin = ('X' ^ board[j][i]);
                if(!OColWin) OColWin = ('O' ^ board[j][i]);
            }
            if(!XRowWin || !XColWin) return "X";
            if(!ORowWin || !OColWin) return "O";
            // diagonal
            if(!XDiaWin) XDiaWin = XDiaWin || ('X' ^ board[i][i]);
            if(!ODiaWin) ODiaWin = ODiaWin || ('O' ^ board[i][i]);
            if(!XiDiaWin) XiDiaWin = XiDiaWin || ('X' ^ board[i][N-1-i]);
            if(!OiDiaWin) OiDiaWin = OiDiaWin || ('O' ^ board[i][N-1-i]);
        }
        if(!XDiaWin || !XiDiaWin) return "X";
        if(!ODiaWin || !OiDiaWin) return "O";
        if(is_full) return "Draw";
        return "Pending";
    }
};

面试题 16.01. 交换数字

编写一个函数，不用临时变量，直接交换numbers = [a, b]中a与b的值。

面试题 16.01. 交换数字

得克特
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
matlab模糊算法：6 运算方法.zip
05-26
matlab模糊算法：6 运算方法.zip
位运算基本概念及简单运用
weixin_33851604的博客
06-09 799
C语言提供了六种位运算符： & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移，相当与*2 >> 右移，正数高位补0，负数由计算机决定 循环左移k次(x<<k) | (x >> (32-k)), 循环右移k次(x>...
位运算
天天向上
09-18 1001
1. 位运算 ​ 位运算起源于C语言的低级操作，Java的设计初衷是嵌入到电视机顶盒内，所以这种低级操作方式被保留下来。所谓的低级操作，是因为位运算的操作对象是二进制位，但是这种低级操作对计算机而言是非常简单直接，友好高效的。在简单的低成本处理器上，通常位运算比除法快得多，比乘法快几倍，有时比加法快得多。虽然由于较长的指令流水线和其他架构设计选择，现代处理器通常执行加法和乘法的速度与位运算一样快，但由于资源使用减少，位运算通常会使用较少的功率，所以在一些Java底层算法中，巧妙的使用位运算可以大
位运算<< >>介绍
萌萌的It人 www.itmmd.com
06-02 1055
左移： 左移就是把一个数的所有位都向左移动若干位,在C中用 int i = 1; i = i 也就是说,1的2进制是000...0001(这里1前面0的个数和int的位数有关,32位机器,gcc里有31个0), 左移2位之后变成 000...0100,也就是10进制的4,所以说左移1位相当于乘以2,那么左移n位就是乘以2的n次方了(有符号数不完全适用, 因为左移有可能导致符号变化
各种快速位运算算法 算法优化
01-07
各种快速位运算算法
《算法很美》python实现 （位运算）
12-20
位运算符号：&(位与)，|（位或），^（位异或） &：对应数位都是1，该位运算结果才为1 |：对应数位只要有1个为1，该位运算结果就为1 ^: 对应数位相同（同1 或 同0），该位运算结果为1 位运算基础运用： ① 判断奇偶数...
位运算实现贪吃蛇
10-30
本游戏采用位运算编写，虽然代码只有仅仅几行，但是却实现了游戏的各种功能。
分治算法：两个二（十）进制数据的乘法运算
09-02
分治算法：两个二（十）进制数据的乘法运算
（三）位运算
热门推荐
依稀_yixy的博客
08-30 1万+
位运算算法
位运算符（了解了解）
kevin的博客
12-04 1100
位运算符 一直都没专门理清楚位运算，这回专门看了视频捋清楚，作为一个笔记查看。 位运算符有：&、|、^、~ 、 >>、<<、>>>【一共七种】 如何区分逻辑运算符和位运算符： 逻辑运算符：左右连接的是布尔类型的操作数 位运算符：左右连接的是具体的数值 1.<< 左移 eg1.3<<2 = 12 这里的3是int类型，4个字节，1个字节8位，所以是32位，如下图 二进制 转 十进制的方式：从右往左看，每一位乘以2的位置数次幂（右边第一位
常用技巧 —— 位运算
Alex_McAvoy的博客
02-04 564
【概述】 在计算机中，数据都是以二进制形式存储的，因此位运算实质就是对整数在内存中的二进制位直接进行操作。 灵活使用位运算，不仅能有效的提高程序的效率，而且还能为代码提供亮点。 此外，在程序设计竞赛中，位运算，也是一种常考的要点，例如：树状数组中的 lowbit 函数的使用等，在 STL 容器中，bitset 也是一种常用的位运算工具。 关于 bitset：点击这里 【应用】 位运算基...
常用技巧 —— 位运算 —— 位运算基础
Alex_McAvoy的博客
02-04 974
【与运算】 与运算常用于二进制的取位操作，其用符号 & 表示，相同位的两个数字都为1，则为1，若有一个不为1，则为0。 例如：00101 & 11100 = 00100 其会将两个十进制数在二进制下进行与运算，然后返回其十进制下的值。 例如：3(11) & 2(10) = 2(10) 典型应用：任意一个数 &1 的结果就是取二进制的最末位，常用于判断数的奇...
算法: 字典序(二进制排序)
得克特
01-22 2272
遇到一道算法题的解法，比较难理解，这里记录一下 算法原题是给定正整数n和k，返回 1 … n 中所有可能的 k 个数的组合。 这道题可以采用回溯法来解决，但是这里我们看下第二种方法：字典序 (二进制排序) 组合，我们可以将这个组合看做一个二进制的排序，如下图，只要我们将k位的二进制排序完成，就能得到所有的组合。 这里的排序算法，有点难以理解，仔细研究，会发现很巧妙。 class Solution...
algorithm: 质数生成
得克特
04-01 797
编写hash函数需要判断质数，这里记录下~ 质数生成： 1.欧几里得筛法：要得到2-n的所有质数， 写下2-n的所有整数，nums for i 找到数列中最小的当前数x=nums[i]，删掉所有x的倍数 剩下的就是质数 2.试除法：依次检验2-n-1能否有整除n的数 对于n/2到n-1显然不能整除n，所以只需要2-n/2试除 进一步优化，假设n可以被m整除 n=l*m m<sqrt(n) l>sqrt(n)，那么是否不需要判断l了呢，l是大于sqrt(n)的数 def prime
algorithm: 基于C++和Python（一）
得克特
05-06 669
文章目录1.两数之和2.两数相加 代码 Python和C++ 1.两数之和 给定一个整数数组如[2,7,11,15]和一个目标值target=9，找出数组中和为目标值的两个数，返回结果索引[0,1]。 算法思想：遍历数组数组的字典保存需要的值也就是target - numbers，当后面遍历的数字存在于该字典时满足条件返回，只需遍历一次数组。 class Solution(object): ...
algorithm: 线段树-实现（递归和非递归）
得克特
03-28 444
线段树是一种二叉搜索树 线段树将一段区间[a,b]划分为一些单位区间，每个单位区间对应线段树的一个叶子节点。 对于线段树中的每一个非叶子节点[a,b]，它的左儿子区间[a,(a+b)/2]，右儿子区间[(a+b)/2+1,b] ...
算法：图
最新发布
得克特
04-26 419
面试题 16.19. 水域大小
医疗内窥镜图像处理涉及到许多算法和技术，这些算法主要用于增强图像的质量、去噪、分割、分类、跟踪和识别等方面。下面列举一些常用的算法： 基于深度学习的图像分割算法：使用卷积神经网络（CNN）进行医学图像的分割，例如U-Net、FCN、SegNet等。 基于滤波的图像去噪算法：包括中值滤波、高斯滤波、小波去噪等。 基于形态学的图像分割算法：包括膨胀、腐蚀、开运算、闭运算等。 基于边缘检测的图像分割算法：包括Canny边缘检测、Sobel边缘检测等。 基于特征提取的图像分类算法：包括SIFT、SURF、HOG等。 基于深度学习的图像识别算法：包括卷积神经网络（CNN）、循环神经网络（RNN）等。 基于跟踪的图像处理算法：包括卡尔曼滤波、粒子滤波等。
05-25
除了上述列举的算法和技术，还有其他一些常用的医疗内窥镜图像处理算法，例如： - 基于图像配准的图像处理算法：使用图像配准技术对医疗内窥镜图像进行对齐，从而提高图像质量和准确性。 - 基于形态学的肿瘤分割...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值