LeetCode题库第67题二进制求和

最新推荐文章于 2024-03-17 13:33:01 发布

空间跳跃Space

最新推荐文章于 2024-03-17 13:33:01 发布

阅读量1.8k

点赞数 2

文章标签： leetcode javascript

本文链接：https://blog.youkuaiyun.com/qq_53818001/article/details/124355947

版权

这篇博客介绍了LeetCode第67题的解题思路，涉及将二进制字符串转换为数组进行运算，通过双层循环计算相同位置的数字相加，处理进位问题，最终得到二进制和的字符串表示。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述:给你两个二进制字符串，返回它们的和（用二进制表示）。输入为非空字符串且只包含数字 `1` 和 `0`。

题解思路:

把二进制字符串转换成数组这样便于运算
把数组元素进行倒转,最后再把运算结果倒转一下;因为二进制运算是从右到左运算
对两个数组进行循环,把对应位置的数字相加,再定义一个空数组,若相加大于等于2时,则在数组中加入相加结果减去2的值,并在下一次循环时把结果加1;若小于2时则在数组中加入相加的结果
再把数组倒转返回结果就可以了

下面实战开始:

定义函数,参数为需传入的两个字符串a,b

           var addBinary = function (a, b) {}

把字符串转换为数组,并颠倒其顺序

            var arrA = a.split('')
            arrA.reverse() //顺序倒转
            var arrB = b.split('')
            arrB.reverse()

找出两数组较长的数组,目的是为了把其长度切割成与短数组一样的长度，并把切下来的长度最后直接加上就行了

            if (a.length > b.length) {
                resMax = arrA
                resMIn = arrB
            } else {
                resMax = arrB
                resMIn = arrA
            }
            var len = resMIn.length
            var resArr = resMax.splice(len) //切割的数组

定义三个变量,分别为储存运算结果的空数组啊arr1、需要往数组中添加的元素sum和判断条件flag,flag的意义是为true时，下次运算结果加1

            var arr1 = [];
            var sum = 0;
            var flag = false

对两个数组进行双层for循环,为了使相同位置的元素相加，需要使两层循环的索引数字相同，即把外层索引值等于内层（即内层 j = 外层 i），注意的是内层循环每次只需执行一次，来保证相同位置的元素运算

             for (var i = 0; i < resMax.length; i++) {
                for (var j = i; j < resMIn.length; j++) {

                    if (resMax[i] * 1 + resMIn[j] * 1 + sum < 2 && flag) {
                        arr1.push(resMax[i] * 1 + resMIn[j] * 1 + sum)
                        sum = 0
                        flag = false
                        break
                    } else if (resMax[i] * 1 + resMIn[j] * 1 + sum >= 2 && flag) {
                        sum = resMax[i] * 1 + resMIn[j] * 1 + sum - 2
                        arr1.push(sum);
                        sum =1
                        flag = true;

                        
                        break
                    } else if (resMax[i] * 1 + resMIn[j] * 1 + sum>= 2) {
                        if (sum > 0) {
                            arr1.push(resMax[i] * 1 + resMIn[j] * 1 + sum - 2);
                            sum = resMax[i] * 1 + resMIn[j] * 1 + sum -2;

                        }else{
                            arr1.push(0);
                            sum  +=1
                        }
                       
                        flag = true;
                        break
                    } else if (resMax[i] * 1 + resMIn[j] * 1 +sum < 2) {
                        arr1.push(resMax[i] * 1 + resMIn[j] * 1 +sum)
                        break
                    }
                }
            }

上面代码*1的目的是因为切割的数组中的元素类型都是String的，需要把它转换成Number型的

然后其中判断的条件分别是

相加结果小于2且flag为true；这时直接往数组arr1中添加运算结果即可，同时把flag变成false，sum变为0，因为下次运算不需要额外加1
相加结果大于2等于且flag为true；这时运算结果需要-2，flag依旧为true，sum需要加1
相加结果大于等于2，即flag为false状态，这时若sum=0；sum需要加1，且flag需要变化
相加结果小于2，把相加结果直接添加到数组中

下面需要做的是把长数组截取下来的部分添加进数组

分析：

其长度小于等于0且flag为true时，只需要在数组中添加元素1即可

其长度大于0且flag为true时，其第一个元素加1之后是否大于等于或小于2；若小于2，只需要第一个元素加1后面的元素直接添加即可；若大于等于2；还需要进一步for循环判断，若直到最后一个元素时，flag仍为true，则需要额外添加元素1

其长度大于0且flag为false时,直接for循环添加

代码如下：

            if (resArr.length <= 0 && flag) {
                arr1.push(1)
            } else if (resArr[0] * 1 + 1 < 2 && flag) {
                arr1.push(resArr[0] * 1 + 1)
                for (var m = 1; m < resArr.length; m++) {
                    arr1.push(resArr[m] * 1)
                }

            } else if (resArr[0] * 1 + 1 >= 2 && flag) {

                for (var n = 0; n < resArr.length; n++) {
                    if (resArr[n] * 1 + 1 >= 2 && flag && n == resArr.length - 1) {
                        arr1.push(0)
                        arr1.push(1)
                        break
                    }
                    if (resArr[n] * 1 + 1 >= 2 && flag) {
                        arr1.push(0)
                    } else if (resArr[n] * 1 + 1 < 2 && flag) {
                        arr1.push(resArr[n] * 1 + 1)
                        flag = false
                    } else {
                        arr1.push(resArr[n])
                    }
                }
            } else {
                for (var z = 0; z < resArr.length; z++) {

                    arr1.push(resArr[z] * 1)
                }
            }

最后把结果的元素顺序再颠倒一次，类型变成字符串型，再return出去即可完成功能

            var arr2 =  arr1.reverse().join('')
           
            return arr2;

全部代码如下：

var addBinary = function (a, b) {
            var arrA = a.split('')
            arrA.reverse()
            var arrB = b.split('')
            arrB.reverse()
            if (a.length > b.length) {
                resMax = arrA
                resMIn = arrB
            } else {
                resMax = arrB
                resMIn = arrA
            }
            var len = resMIn.length
            var resArr = resMax.splice(len) //切割的数组
            var arr1 = [];
            var sum = 0;
            var flag = false
            for (var i = 0; i < resMax.length; i++) {
                for (var j = i; j < resMIn.length; j++) {

                    if (resMax[i] * 1 + resMIn[j] * 1 + sum < 2 && flag) {
                        arr1.push(resMax[i] * 1 + resMIn[j] * 1 + sum)
                        sum = 0
                        flag = false
                        break
                    } else if (resMax[i] * 1 + resMIn[j] * 1 + sum >= 2 && flag) {
                        sum = resMax[i] * 1 + resMIn[j] * 1 + sum - 2
                        arr1.push(sum);
                       sum =1
                            flag = true;
        
                        break
                    } else if (resMax[i] * 1 + resMIn[j] * 1 + sum>= 2) {
                        if (sum > 0) {
                            arr1.push(resMax[i] * 1 + resMIn[j] * 1 + sum - 2);
                            sum = resMax[i] * 1 + resMIn[j] * 1 + sum -2;

                        }else{
                            arr1.push(0);
                            sum  +=1
                        }
                       
                        flag = true;
                        break
                    } else if (resMax[i] * 1 + resMIn[j] * 1 +sum < 2) {
                        arr1.push(resMax[i] * 1 + resMIn[j] * 1 +sum)
                        break
                    }
                }
            }
           
            if (resArr.length<=0 && flag ) {
                arr1.push(1)
            } else if (resArr[0] * 1 + 1 < 2 && flag) {
                arr1.push(resArr[0] * 1 + 1)
                for (var m = 1; m < resArr.length; m++) {
                    arr1.push(resArr[m] * 1)
                }

            } else if (resArr[0] * 1 + 1 >= 2 && flag) {

                for (var n = 0; n < resArr.length; n++) {
                    if (resArr[n] * 1 + 1 >= 2 && flag && n == resArr.length-1) {
                        arr1.push(0)
                        arr1.push(1)
                        break
                    }
                    if (resArr[n] * 1 + 1 >= 2 && flag) {
                        arr1.push(0)
                    } else if (resArr[n] * 1 + 1 < 2 && flag) {
                        arr1.push(resArr[n] * 1 + 1)
                        flag = false
                    }else{
                        arr1.push(resArr[n])
                    }
                }
            }else{
                for (var z = 0; z < resArr.length; z++) {
                   
                    arr1.push(resArr[z] * 1)
                }
            }
           var arr2 =  arr1.reverse().join('')
           
            return arr2;
        };
       var a  ="110010"
       var b = "10111"

        var res = addBinary(a, b)
        console.log(res);

本次文章到这里就结束了，若有错误之处，还望谅解，谢谢！！！