位运算03 不用加号的加法[C++]

已于 2024-02-23 12:12:18 修改
阅读量991 收藏 21
点赞数 21
CC 4.0 BY-SA版权
分类专栏： # 位运算 文章标签： c++ 开发语言 算法 笔记
于 2024-02-23 12:11:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42789937/article/details/136231483

 

图源：文心一言

上机题目练习整理，位运算，供小伙伴们参考~🥝🥝

网页版目录在页面的右上角↗~🥝🥝

  • 第1版：在力扣新手村刷题的记录~🧩🧩

编辑：梅头脑🌸

审核：文心一言

题目：面试题 17.01. 不用加号的加法 - 力扣（LeetCode）

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

🧩题目

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

示例:

输入: a = 1, b = 1
输出: 2

提示：

  • a, b 均可能是负数或 0
  • 结果不会溢出 32 位整数

🌰解题一：循环+按位运算（一）

📇算法思路

  • 算法思想：

    • 初始化：函数接收两个整数a和b作为输入。

    • 循环条件：当进位b不为0时，循环继续。

    • 计算进位：使用a & b来计算a和b的哪些位都需要进位（仅当 a 为 1，且 b 为 1时，需要进位）。然后，通过左移一位（<< 1）来将这些进位应用到正确的位置上。这里使用unsigned int是为了确保左移操作不会引入任何符号位。

    • 计算本位和：使用a ^ b（异或操作）来计算不考虑进位时的和。异或操作会返回在两个输入中只有一个为1的那些位上设置1的结果，例如：

      • a = 1， b = 1 ，算数运算：a + b = 10，位运算：本位和为 1 ^ 1 = 0，进位为 1 & 1 = 1；

      • a = 1， b = 0 ，算数运算：a + b =  01，位运算：本位和为 1 ^ 0 = 1，进位为 1 & 0 = 0；

      • a = 0， b = 1 ，算数运算：a + b =  01，位运算：本位和为 0 ^ 1 = 1，进位为 0 & 1 = 0；

      • a = 0， b = 0 ，算数运算：a + b =  00，位运算：本位和为 0 ^ 0 = 0，进位为 0 & 0 = 0；

    • 更新操作数：

      • a被更新为不考虑进位的本位和（a ^ b的结果）。
      • b被更新为进位（(unsigned int)(a & b) << 1的结果）。这样，在下一次循环中，b将包含所有需要被加到a上的进位。

    • 返回结果：当b变为0（即没有更多的进位需要处理）时，循环结束，函数返回a作为最终的和。

  • 时间复杂度：O(1)或O(log(max(a, b)))；我们可以认为时间复杂度是O(1)，其中1表示一个固定的上限，即整数的大小，或整数的二进制表示的长度。
  • 空间复杂度：O(1)；

⌨️算法代码

#include <iostream>
#include <bitset>
using namespace std;

class Solution {
public:
    int add(int a, int b) {
        while (b != 0) {
            unsigned int carry = (unsigned int)(a & b) << 1;
            a = a ^ b;
            b = carry;
        }
        return a;
    }
};

//class Solution {
//public:
//    int add(int a, int b) {
//        cout << "a = " << a << " = " << bitset<32>(a) << ", b = " << b << " = " << bitset<32>(b) << endl;
//
//        while (b != 0) {
//            unsigned int carry = (unsigned int)(a & b) << 1;
//            cout << "carry = " << bitset<32>(carry);
//            a = a ^ b;
//            cout << ", a = " << bitset<32>(a);
//            b = carry;
//            cout << ", b = " << bitset<32>(b) << endl;
//        }
//        return a;
//    }
//};
//
//int main()
//{   
//    int a = 111;  int b = 899;
//    Solution solution;
//    int result = solution.add(a, b);
//    cout << "result = " << result << " = " << bitset<32>(result) << endl;
//
//    return 0;
//}

作者：力扣官方题解
链接：https://leetcode.cn/problems/add-without-plus-lcci/solutions/1718025/bu-yong-jia-hao-de-jia-fa-by-leetcode-so-pp8a/

📇执行结果

输入 a = 111， b = 899后，执行结果如下：

📇代码解释

1：输入 a 与 b

  • a =  111（十进制） =  00000000000000000000000001101111（二进制）
  • b =  899（十进制） =  00000000000000000000001110000011（二进制）
  • 本轮需要进位的在第0位、第1位，11 + 11 = 110；

2：计算第1轮 本位和与进位

  • 进位 carry ：a & b = 00000000000000000000000000000011，无符号数算数左移1位结果为 000000000000000000000000000000110；
  • 本位和 a : a ^ b = 00000000000000000000001111101100；
  • 进位 b：b = carry = 000000000000000000000000000000110；
  • 本轮需要进位的在第2位，100 + 100 = 1000；

3：计算第2轮 本位和与进位

  • 进位 carry ：a & b = 00000000000000000000000000000100，无符号数算数左移1位结果为 00000000000000000000000000001000；
  • 本位和 a : a ^ b = 00000000000000000000001111101010；
  • 进位 b：b = carry = 00000000000000000000000000001000；
  • 本轮需要进位的在第3位，1000 + 1000 = 10000；

4：计算第3轮 本位和与进位

  • 进位 carry ：a & b = 00000000000000000000000000001000，无符号数算数左移1位结果为 00000000000000000000000000010000；
  • 本位和 a : a ^ b = 00000000000000000000001111100010；
  • 进位 b：b = carry = 00000000000000000000000000010000；
  • 本轮 a 与 b 没有同时为 1 的位，最后进行异或，进位b更新为0，本位和a即为答案；

5：计算第4轮 本位和与进位

  • 进位 carry ：a & b = 00000000000000000000000000000000，无符号数算数左移1位结果为 00000000000000000000000000000000；
  • 本位和 a : a ^ b = 00000000000000000000001111110010；
  • 进位 b：b = carry = 00000000000000000000000000000000；
  • 返回：a = 1010 (十进制) = 00000000000000000000001111110010（二进制）；

这道题目的难点应该是从后向前一轮一轮地处理 进位，（本位和异或就可以搞定了），感觉官方的解法真的很简洁美观，但是以我的功底，要能自己写出这种水平的代码，感觉至少还要1年，囧...

🌰解题二：循环+按位运算（二）（简单全加器原理）

📇算法思路

  • 算法思想：

    • 初始化：函数接收两个整数a和b作为输入。

    • 循环条件：int 通常为 32位，未读取完32位时，循环继续遍历读取每1位。

    • 全加器逻辑：

      • 每次从a和b中提取一位（从最低位开始）记入 bita、bitb进行运算，调用函数fulladder计算本位和 sum 与 进位 carryout，计算结果存入容器 adderresult。

      • 计算进位：使用a & b来计算a和b的哪些位都需要进位（仅当 a 为 1，且 b 为 1时，需要进位）。然后，通过左移一位（<< 1）来将这些进位应用到正确的位置上。这里使用unsigned int是为了确保左移操作不会引入任何符号位。

      • 计算本位和：使用 sum = a ^ b（异或操作）来计算不考虑进位时的和。异或操作会返回在两个输入中只有一个为1的那些位上设置1的结果；

    • 更新操作数：在result 中输出本位和与进位；

    • 返回结果：当int遍历结束时时，循环结束，函数返回result作为最终的和。

  • 时间复杂度：O(1)：总是处理32位整数；
  • 空间复杂度：O(1)：使用了固定数量的变量来存储中间结果和进位；

⌨️算法代码

#include <iostream>  
#include <utility> // 为了使用 std::pair  

// 全加器函数，返回一个包含和与进位的pair  
std::pair<int, int> fulladder(int a, int b, int carryin) {
    int sum = a ^ b ^ carryin; // 不考虑进位的和  
    int carryout = (a & b) | ((a ^ b) & carryin); // 进位，注意这里修正了逻辑错误  
    return std::make_pair(sum, carryout); // 返回和与进位的pair  
}

// 两个32位整数相加  
int add(int a, int b) {
    int carry = 0; // 初始化进位为0  
    int result = 0; // 初始化结果为0  
    for (int i = 0; i < 32; ++i) { // 逐位相加  
        int bita = (a >> i) & 1; // a的第i位  
        int bitb = (b >> i) & 1; // b的第i位  
        // 调用全加器并更新结果和进位  
        std::pair<int, int> adderresult = fulladder(bita, bitb, carry);
        result |= adderresult.first << i; // 将当前位的和加入结果中  
        carry = adderresult.second; // 更新进位为全加器的进位输出  
    }
    // 注意：此实现不处理溢出情况。在实际应用中，应考虑溢出。  
    return result;
}

int main() {
    int a = 111; // 101 in binary, 但实际上在32位整数中是 0000 ... 0101  
    int b = 899; // 011 in binary, 但实际上在32位整数中是 0000 ... 0011  
    int expected = 1010; // 1000 in binary, 但实际上在32位整数中是 0000 ... 1000  
    int actual = add(a, b); // 应该返回1010（没有溢出的情况下）  
    std::cout << "expected: " << expected << std::endl; // 输出期望结果  
    std::cout << "actual: " << actual << std::endl; // 输出实际结果，应该是8  
    return 0; // 程序成功执行完毕，返回0表示成功状态码  
}

作者：文心一言 

📇执行结果

测试代码

int add(int a, int b) {
    int carry = 0;
    int result = 0;
    for (int i = 0; i < 32; ++i) {
        int bita = (a >> i) & 1;
        int bitb = (b >> i) & 1;

        std::pair<int, int> adderresult = fulladder(bita, bitb, carry);

        // 添加打印语句来查看中间变量的值  
        std::cout << "Iteration（位数） " << i << ":" << std::endl;
        std::cout << "  bita: " << bita << std::endl;
        std::cout << "  bitb: " << bitb << std::endl;
        std::cout << "  carry（本轮进位）: " << carry << std::endl;
        std::cout << "  adderresult (sum, carry): ("
            << adderresult.first << ", " << adderresult.second << ")" << std::endl;

        result |= adderresult.first << i;
        carry = adderresult.second;

        // 打印当前的结果和进位  
        std::cout << "  result: " << result << " = " << std::bitset<32>(result) <<std::endl;
        std::cout << "  carry（下轮进位）: " << carry << std::endl;
        std::cout << std::endl; // 打印空行以便于阅读  
    }
    return result;
}

运行结果 

1：输入 a 与 b

  • a =  111（十进制） =  00000000000000000000000001101111
  • b =  899（十进制） =  00000000000000000000001110000011

2：代码运行

Iteration（位数） 0:
  bita: 1
  bitb: 1
  carry（本轮进位）: 0
  adderresult (sum, carry): (0, 1)
  result: 0 = 00000000000000000000000000000000
  carry（下轮进位）: 1

Iteration（位数） 1:
  bita: 1
  bitb: 1
  carry（本轮进位）: 1
  adderresult (sum, carry): (1, 1)
  result: 2 = 00000000000000000000000000000010
  carry（下轮进位）: 1

Iteration（位数） 2:
  bita: 1
  bitb: 0
  carry（本轮进位）: 1
  adderresult (sum, carry): (0, 1)
  result: 2 = 00000000000000000000000000000010
  carry（下轮进位）: 1

Iteration（位数） 3:
  bita: 1
  bitb: 0
  carry（本轮进位）: 1
  adderresult (sum, carry): (0, 1)
  result: 2 = 00000000000000000000000000000010
  carry（下轮进位）: 1

Iteration（位数） 4:
  bita: 0
  bitb: 0
  carry（本轮进位）: 1
  adderresult (sum, carry): (1, 0)
  result: 18 = 00000000000000000000000000010010
  carry（下轮进位）: 0

Iteration（位数） 5:
  bita: 1
  bitb: 0
  carry（本轮进位）: 0
  adderresult (sum, carry): (1, 0)
  result: 50 = 00000000000000000000000000110010
  carry（下轮进位）: 0

Iteration（位数） 6:
  bita: 1
  bitb: 0
  carry（本轮进位）: 0
  adderresult (sum, carry): (1, 0)
  result: 114 = 00000000000000000000000001110010
  carry（下轮进位）: 0

Iteration（位数） 7:
  bita: 0
  bitb: 1
  carry（本轮进位）: 0
  adderresult (sum, carry): (1, 0)
  result: 242 = 00000000000000000000000011110010
  carry（下轮进位）: 0

Iteration（位数） 8:
  bita: 0
  bitb: 1
  carry（本轮进位）: 0
  adderresult (sum, carry): (1, 0)
  result: 498 = 00000000000000000000000111110010
  carry（下轮进位）: 0

Iteration（位数） 9:
  bita: 0
  bitb: 1
  carry（本轮进位）: 0
  adderresult (sum, carry): (1, 0)
  result: 1010 = 00000000000000000000001111110010
  carry（下轮进位）: 0

……

Iteration（位数） 31:
  bita: 0
  bitb: 0
  carry（本轮进位）: 0
  adderresult (sum, carry): (0, 0)
  result: 1010 = 00000000000000000000001111110010
  carry（下轮进位）: 0

expected: 1010
actual: 1010

🌰自留错误版本

📇算法思路

  • 基本思想同算法一，通过计算本位和与进位计算结果~

⌨️算法代码（错误，自留代码）

#include <iostream>
#include <bitset>
using namespace std;

class Solution {
public:

    //代码逻辑有问题， sum += 那一行，违背了位运算原则。
    int add(int a, int b) {
        int sum = 0;
        int carry = 0;
        int i = 0;
        for (i = 0; i < 32; i++) {
            cout << "本轮 i = " << i << endl;
            int bitA = (a >> i) & 1;
            cout << "本轮 bitA = " << bitA << endl;
            int bitB = (b >> i) & 1;
            cout << "本轮 bitB = " << bitB << endl;
            int bitSum = bitA ^ bitB;
            cout << "本轮 bitSum = " << bitSum << endl;
            carry = (bitA & bitB) | (bitSum & carry);
            cout << "本轮 carry = " << carry << endl;
            sum = sum + (carry << i + 1) + (bitSum << i);
            cout << "本轮 sum = " << sum << endl;
            carry <<= 1;
            cout << "carry 左移一位" << endl;
            cout << endl;
        }
        return sum;
    }

    //int add(int a, int b) {
    //    int result = 0;
    //    int carry = 0;
    //    int i = 0;
    //    for (i = 0; i < 32; i++) {
    //        cout << "本轮 i = " << i << endl;
    //        int bitA = (a >> i) & 1;
    //        cout << "本轮 bitA = " << bitA << endl;
    //        int bitB = (b >> i) & 1;
    //        cout << "本轮 bitB = " << bitB << endl;
    //        int bitSum = bitA ^ bitB;
    //        cout << "本轮 bitSum = " << bitSum << endl;
    //        carry = (bitA & bitB) | (bitSum & carry);
    //        cout << "本轮 carry = " << carry << endl;
    //        // sum = sum + (carry << i + 1) + (bitSum << i);
    //        result = result | bitSum << i;
    //        if (carry & 1) { result |= (1 << (i + 1));}
    //        cout << "本轮 result = " << result << endl;
    //        carry >>= 1;
    //        cout << "carry 右移一位" << endl;
    //        cout << endl;
    //    }
    //    return result;
    //}

};

int main()
{   
    //int a = 1;  int b = 1;
    int a = 111;  int b = 899;
    Solution solution;
    int result = solution.add(a, b);
    cout << result;
    return 0;
}

作者：梅头脑

这个解法呃，倒是可以运行，将 本位和 与 进位和分开了，接近解法二的思路。但是因为没能很好得处理进位的问题，就使用了加法企图蒙混过关 sum = sum + (carry << i + 1) + (bitSum << i); （此处如果使用 “ | ” 会吞掉进位与本位的相同位），违背了题目不能使用加法的本意 。又想到使用result，也出现了类似的问题，后来摆脱文心一言用全加器的原理修改掉，也就是解法二~~

🔚结语

博文到此结束，写得模糊或者有误之处，欢迎小伙伴留言讨论与批评，督促博主优化内容{例如有错误、难理解、不简洁、缺功能}等，博主会顶锅前来修改~~😶‍🌫️😶‍🌫️

我是梅头脑，本片博文若有帮助，欢迎小伙伴动动可爱的小手默默给个赞支持一下，感谢点赞小伙伴对于博主的支持~~🌟🌟

同系列的博文：🌸位运算_梅头脑_的博客-CSDN博客

同博主的博文：🌸随笔03 笔记整理-CSDN博客

不用加号实现加法！
fjqcyq2的专栏
04-24 8373
有一个题目说的是如何不用加号来实现加法运算，看到了一个大牛的代码，顿时膜拜！废话不说，上思路。 比如，int a =7, int b=8; 如何不用加号来计算a+b？ 代码如下： int Add(int a, int b) { char *c = (char *)a; return (int) &c[b]; }就是这么简单的两句代码。具体的意思就是： 1、首先将a转换为地址类型，即a=7，
简单加法【C++】
m0_62843151的博客
04-11 5139
算术运算符“+” C++支持多种运算符，其中就有算术运算符，而算术运算符又包括多种运算符，其中之一就是“+”运算符。 完整代码 #include<iostream> using namespace std; int main(){ int numberA,numberB; //int count; cout<<"ENTER NUMBER A:"; cin>>numberA; cout<<"EN...
C /C++ 位运算
sudo 专栏
07-30 674
<br />C/C++支持比较低阶的位运算，在是众人皆知的了。每本C/C++的教科书都会说到这部分的内容，不过都很简略，我想会有很多人不知道位运算用在什么地 方。这个帖子就简略说说位运算的用处，更进一步的用法要大家自己去体会。而主要说的是操作标志值方面。<br /><br /> 考虑一个事物、一个系统、或者一个 程序可能会出现一种或者几种状态。为了在不同的状态下，作出不同的行为，你可以设立一些标志值，再根据标志值来做判断。比如C++的文件流，你就可以设定 一些标志值，ios::app, ios::a
「C/C++」 使用位运算实现加法
look_outs的博客
11-16 1185
算法：加法器原理
不用运算符号实现加法（c++）实现
shenyuhan的博客
03-22 819
给定两个数num1、num2，不使用运算符号，求它们的和。 思路 计算机内部的运算都是位运算，所以可以用位运算实现。 以最简单的加法为例，可得出结论： C = A & B D = A ^ B D是两数相加的直接结果，C是进位，用一般思维进行加法运算时，都是先每一位相加，再进到下一位，在本算法中，由于加法具有交换律，可以先计算所有位数相加的结果，再与进位的结果相加，当然，进位的结果还要左移一位。 当进位为0时，计算停止，直接相加的结果即为最终结果。 由于进位每次会向左移动，所以经过有限次循环后，.
C++ 不使用加号计算加法 （位运算加法）
catalpeak的博客
03-15 726
位运算的按位与可以无进位的计算加法，但是还要有进位就可以使用按位异或，是计算进位的，不过要左移一位才是进位。 所以将二者相加，之道不存在进位即可 递归代码如下： #include <iostream> int sum (int a, int b) { return b ? sum (a^b, (a&b) << 1) : a; } int main...
如何在程序中不用加号实现加法_python不用加号实现加法
weixin_39618121的博客
01-13 426
问题:Calculate the sum of two integers a and b, but you are not allowed to use the operator + and -.Example:Given a = 1 and b = 2, return 3.class Solution(object):def getSum(self, a, b):""":type a: int:...
c语言不用加号怎么算加法,加法
weixin_33971453的博客
05-18 491
除法没有结合律2021-05-14 17:35:24除法没有结合律被除数只有一个，除数可以有多个如果除法使用了结合律，那么 被除数不变，除数变小了，结果反而变大了✔被除数，和除数，应该是敌人，所以不能让除数倒戈相向，，这是一场除数向被除数的讨伐战争，而乘法，本质是加法的缩写，，加法的话，它们都是好朋友，聚集在一起，当然谁先谁后高精度加法2021-05-11 21:01:15高精度加法模板例题：给定...
C++三级编程技巧：加号放置优化使多位整数快速变为单一位数的方法解析
03-26
内容概要：本文介绍了通过特定规则的加法运算将多位数字转换为一位数字的具体方法和技术细节，着重展示了C++三级难度下这一操作的最佳实现方式。具体来说，该文章探讨了将整数分割成两个部分并逐步累加的方式，直到...
【C++编程题】解析字符串 实现加法运算
西木的博客
11-20 883
C++实现加法运算，输入只含加号的加法算式，输出运算结果。字符串操作。
C++编写一段代码使我输入加号时运算加法运算，输入减号时运算减法运算。
10-09
在C++中，你可以使用`if...else`结构结合`cin`（标准输入流）来实现这样的功能。下面是一个简单的示例： ```cpp #include int main() { char operatorChoice; int num1, num2; std::cout 请输入一个运算符 (+...
《C++》stack容器详解
Maysheeo的博客
08-03 878
C++中的stack详解
C++ 虚函数和多态
Vallelonga的博客
08-02 716
cpp 虚函数、虚函数表相关基础知识，面试必会。
C++：STL中的栈和队列的适配器deque
lrhhappy的博客
08-03 972
本文主要探讨了C++中容器适配器stack和queue的底层实现原理及其优势。通过分析deque（双端队列）的特性，解释了其作为stack和queue默认底层容器的原因：deque在头部和尾部操作效率高（O(1)），且空间利用率优于list，同时避免了vector扩容时的数据迁移问题。文章详细比较了不同容器的优缺点，指出deque虽不适合遍历，但完美适配stack和queue只需单端操作的需求。此外，还介绍了优先级队列的模拟实现，重点阐述了堆结构如何通过向上/向下调整算法维护特性，确保O(logn)时间复杂
【C++】石头剪刀布游戏
C语言实战大全
08-04 1048
课程设计实现，包含面向对象设计、随机数生成、胜负判定等功能，适合课程设计或编程练习~
C++ list
chj_1206的博客
08-02 882
list底层是带哨兵位的双向循环链表，是实现列表的最优解。
2025年6月电子学会青少年软件编程（C语言）等级考试试卷（四级）
No0d1es的博客
08-03 302
本文包含两道编程题：1.打印金字塔：输入整数n，输出n层金字塔图案，需处理空格与字符排列；2.统计数带：计算a到b之间所有数字拼接后"12"出现的次数，注意跨数字组合情况。输入样例和输出样例已给出，涉及字符串处理和边界条件判断。更多内容可在指定网站查看。
C++信息学奥赛一本通-第一部分-基础一-第2章-第2节
最新发布
BECOMEviolet的博客
08-05 300
这题暴力我觉得没意思，正好对算法导论的多项式算法还有印象。
c++简单加法运算
03-20
### C++ 中实现基本加法运算 以下是通过 C++ 编写的一个简单加法运算的示例代码： ```cpp #include <iostream> using namespace std; int main() { double num1, num2, sum; cout << "Enter the first number: "; cin >> num1; cout << "Enter the second number: "; cin >> num2; sum = num1 + num2; // 使用加法运算符完成求和 cout << "The sum of " << num1 << " and " << num2 << " is " << sum << endl; return 0; } ``` 在此代码中，`num1` 和 `num2` 是用户输入的两个数值，`sum` 变量存储它们相加后的结果。这里使用了标准输入输出流以及加法运算符 `+` 来完成这一功能[^1]。 另外，在更底层的情况下可以利用位运算模拟加法操作。例如下面展示了一个不借助 `+` 运算符而仅依靠按位操作实现两数相加的例子： ```cpp #include <iostream> using namespace std; int add(int x, int y) { while (y != 0) { // 当进位为0时结束循环 unsigned carry = x & y; // 计算进位 x = x ^ y; // 不带进位的加法 y = carry << 1; // 将进位左移一位 } return x; } int main() { int a, b; cout << "Enter two integers to add: "; cin >> a >> b; cout << "Sum: " << add(a, b) << endl; return 0; } ``` 在这个例子中，`add()` 函数展示了如何通过按位异或 (`^`) 处理无进位部分，并用按位与 (`&`) 配合左移 (`<<`) 来管理进位情况，最终实现了无需传统加号即可完成整数相加的功能[^3]。 #### 输出说明 当运行以上任一段代码并提供适当的数据作为输入时，程序会返回这两个数字之和的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值