【力扣刷题】整数除法

最新推荐文章于 2022-12-30 17:43:00 发布
最新推荐文章于 2022-12-30 17:43:00 发布
阅读量607 收藏 1
点赞数
文章标签： 整数除法 算法优化 溢出处理 位运算 循环优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jireen/article/details/122246262
版权

在这里插入图片描述

救命，人生第一次通过呜呜呜
整体利用减法思路~
1）a=0的情况—i=0;
2）a=-2147483648的情况—
①b=-1（因为会溢出）—i=2147483647
②b<0并且！=-1
如果a与b相等就为1，
不等:先判断2b是否溢出，不溢出就用a+|2b|<=0作为条件，true那就a=a+|2b|,i=i+2；
接着 a+|b|<=0作为条件，true那就a=a+|b|,i=i+1；（这里其实b不用判断是否溢出，因为b就是输入，谁会输入一个溢出的数呢，笑死，被自己整笑了）
（其实这两步就是脱裤子放屁，因为怕超出时间限制，这是为了当a很大，b很小的时候减少循环次数的）
③b>0是同样的作法
与上面不一样的就是，最后结果要取相反数
3）除掉以上的特殊情况之外，一般情况
①同号
同上2.2
②异号
同上2.3

class Solution {
    public int divide(int a, int b) {
        int i;
       i=0;
        if(a==0)
        {
            i=0;
        }
        else if(a==-2147483648 )
        { 
            if(b==-1)
            {
                 i=2147483647;
            }
            else if(b<0&&b!=-1)
            {
               i=0;
               if(a==b)
                 {
                     i=1;
                 }
               else
               {
                if (Math.abs(b) > Integer.MAX_VALUE /2|| Math.abs(b) < Integer.MIN_VALUE / 2)
               {
               }
               else
               {
               while(a+2*Math.abs(b)<=0)
               {
                     a=a+2*Math.abs(b);
                     i=i+2;
                }
                }
                while(a+Math.abs(b)<=0)
                {
                     a=a+1*Math.abs(b);
                     i=i+1;
                }
                }
            }
            else
            {
                i=0; 
               if (Math.abs(b) > Integer.MAX_VALUE /2|| Math.abs(b) < Integer.MIN_VALUE / 2)
                {
                }
                else
                {
                while(a<=-2*b)
                {
                     a=a+2*b;
                     i=i+2;
                }
                }
                 
                while(a<=-1*b)
                {
                     a=a+b;
                     i=i+1;
                }
                i=-i;
            }
        }
        else 
        {
            if (((a ^ b) >>> 31) == 0)
            {   
               if(Math.abs(a)==Math.abs(b))
                 {
                     i=1;
                 }
                 else if((((a-b) ^ a) >>> 31) == 1)
                 {
                   i=0;
                 }
                 else
                {  
                i=0;
                 if (Math.abs(b) > Integer.MAX_VALUE /5 || Math.abs(b) < Integer.MIN_VALUE / 5)
                {
                }
                else
                {
                     while(Math.abs(a)>=5*Math.abs(b))
                {
                     a=Math.abs(a)-5*Math.abs(b);
                     i=i+5;
                }
                }
                   if (Math.abs(b) > Integer.MAX_VALUE /4 || Math.abs(b) < Integer.MIN_VALUE / 4)
                {
                }
                else
                {
                     while(Math.abs(a)>=4*Math.abs(b))
                {
                     a=Math.abs(a)-4*Math.abs(b);
                     i=i+4;
                }
                }
                   if (Math.abs(b) > Integer.MAX_VALUE /3 || Math.abs(b) < Integer.MIN_VALUE / 3)
                {
                }
                else
                {
                     while(Math.abs(a)>=3*Math.abs(b))
                {
                     a=Math.abs(a)-3*Math.abs(b);
                     i=i+3;
                }
                }

                  if (Math.abs(b) > Integer.MAX_VALUE /2 || Math.abs(b) < Integer.MIN_VALUE /2)
                {
                }
                else
                {
                     while(Math.abs(a)>=2*Math.abs(b))
                {
                     a=Math.abs(a)-2*Math.abs(b);
                     i=i+2;
                }
                }

                    if (Math.abs(b) > Integer.MAX_VALUE /1 || Math.abs(b) < Integer.MIN_VALUE / 1)
                {
                
                }
                else
                {
                     while(Math.abs(a)>=Math.abs(b))
                {
                     a=Math.abs(a)-Math.abs(b);
                     i=i+1;
                }
                }
              }
            }
              else
            {  
                i=0; 
               if(Math.abs(a)==Math.abs(b))
                {
                    i=1;
                 }
                 else if((((a+b) ^ a) >>> 31) == 1)
                 {
                   i=0;
                 }
                 else
                 {   
                if (Math.abs(b) > Integer.MAX_VALUE /5 || Math.abs(b) < Integer.MIN_VALUE / 5)
                {
                }
                else
                {
                while(Math.abs(a)>=5*Math.abs(b))
                {
                     a=Math.abs(a)-5*Math.abs(b);
                     i=i+5;
                }
                }
                
                  if (Math.abs(b) > Integer.MAX_VALUE /4 || Math.abs(b) < Integer.MIN_VALUE / 4)
                {
                
                }
                else
                {
                     while(Math.abs(a)>=4*Math.abs(b))
                {
                     a=Math.abs(a)-4*Math.abs(b);
                     i=i+4;
                }
                }
                   if (Math.abs(b) > Integer.MAX_VALUE /3 || Math.abs(b) < Integer.MIN_VALUE /3)
                {
                
                }
                else
                {
                     while(Math.abs(a)>=3*Math.abs(b))
                {
                     a=Math.abs(a)-3*Math.abs(b);
                     i=i+3;
                }
                }

                   if (Math.abs(b) > Integer.MAX_VALUE /2 || Math.abs(b) < Integer.MIN_VALUE / 2)
                {
                
                }
                else
                {
                     while(Math.abs(a)>=2*Math.abs(b))
                {
                     a=Math.abs(a)-2*Math.abs(b);
                     i=i+2;
                }
                }

                   if (Math.abs(b) > Integer.MAX_VALUE /1 || Math.abs(b) < Integer.MIN_VALUE /1)
                {
                
                }
                else
                {
                     while(Math.abs(a)>=Math.abs(b))
                {
                     a=Math.abs(a)-Math.abs(b);
                     i=i+1;
                }
                }
                 }
                i=-i;
               // return -i;
            }
        }
    return i;
    }
}

救命，看了一下评论区，厉害的姐妹好多
贴个评论区看到的，转自力扣
思想差不多，但是明显我位运算不如人家啊哈哈哈
Integer.MIN_VALUE的绝对值还是他本身
Integer.MIN_VALUE的绝对值-5=+（2147483648-5）

 public int divide(int a, int b) {
	        if (a == 0) return 0;
	        if (b == 1) return a;
	        if (b == -1) return a == Integer.MIN_VALUE ? Integer.MAX_VALUE : -a;
	        if (b == 2) return a >> 1;
	        if (b == -2) return -(a >> 1);
	        int result = 0;
	        int tempa = Math.abs(a);
	        int tempb = Math.abs(b);
	        int temp = tempb;
	        // 如果使用下面的方法，则会出现超时的情况	
//	        while((temp += tempb) >= tempa){
//	            result ++;
//	        }
	        while((tempa -= tempb) >= 0){
	            result ++;
	        }
	        if((a < 0 && b < 0) || (a > 0 && b > 0)){
	            return result;
	        }else{
	            return -result;
	        }
	    }
fancyZiZi~
关注
力扣刷题精选11111
03-23
《力扣刷题精选11111》是针对编程爱好者和准备面试的开发者们的一份宝贵资源，它聚焦于LeetCode平台上的算法题目，涵盖了数据结构与算法、职场技能和职业发展等多个方面。LeetCode作为全球知名的在线编程挑战平台，...
力扣整数除法
qq_59419129的博客
06-15 566
力扣整数除法
【力扣】剑指offer II 001.整数除法
vcomp的专栏
10-20 300
题目https://leetcode-cn.com/problems/xoh6Oh/ class Solution { public int divide(int a, int b) { if(a == Integer.MIN_VALUE && b == -1) { return Integer.MAX_VALUE; } int sign = (a > 0) ^ (b > 0) ? -1 : 1;
leetcode力扣-剑指offer刷题-day1-001整数除法
weixin_45230053的博客
01-21 820
leetcode力扣-剑指offer刷题-day1-001整数除法
算法问题：整数除法详解（Java方向）
weixin_44719346的博客
03-10 1146
算法（力扣001）—— 整数除法1.力扣题目2.思路 1.力扣题目 1.给定两个整数 a 和 b ，求它们的除法的商 a/b? 2.要求：不得使用 乘号 '*'、除号 '/' 、 求余 '%' 。 2.思路 if (a == Integer.MIN_VALUE && b == -1) { return Integer.MAX_VALUE; } 1.首先，对参数的边界值进行判断。 如果被除数a是整形的最小值，并且除数b是-1的情况下，那么其结果为整形的最大值，直接返回结果不用
[LeetCode]29. 两数相除
张小猪的家
07-31 243
29. 两数相除 难度：中等 给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。 返回被除数 dividend 除以除数 divisor 得到的商。 整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2 示例 1: 输入: dividend = 10, divisor = 3 输出: 3 解释: 10/3 = truncate(3.33333..
使用力扣刷题的经验.pdf
04-21
在使用力扣平台刷题提升编程和算法能力的过程中，需要把握几个关键的知识点，以及遵循一定的学习方法和策略。 首先，对于编程初学者来说，掌握一门编程语言是进行算法练习的前提。C语言和Java是比较常见的选择，...
力扣刷题算法截图汇总2021
04-02
2021年的力扣刷题算法截图汇总是一个珍贵的学习资源，它可能包含了当年力扣上的热门问题及其解决方案的截图。由于标签为"python"，我们可以推断这些截图主要涉及使用Python语言解决这些问题。 在Python编程中，解决...
基于Java和Python的力扣刷题练习设计源码
最新发布
10-09
该项目是一款结合Java和Python语言的力扣刷题练习系统源码，共计包含98个文件，其中Java源文件94个，Markdown文档2个，Python脚本1个，XML配置文件1个。系统旨在提供一个全面的学习和练习平台，帮助用户高效地提升...
基于Java编程的力扣刷题记录及心得分享设计源码
10-04
该项目是一个基于Java编程的个人力扣刷题记录及心得分享系统设计源码，共包含98个文件，其中89个为Java源文件，3个为XML配置文件，2个为Git忽略文件，以及少量其他类型文件。该系统旨在帮助用户高效地记录和整理力扣...
基于Java的LazyCat力扣刷题记录源码分享
10-01
该项目是一个基于Java开发的LazyCat力扣刷题记录系统源码，包含1299个Java类文件、965个Markdown文档、636个Java源代码文件以及其他少量XML、JSON、LCV等配置和忽略文件，共计2917个文件。该系统旨在帮助用户记录和...
基于Python实现的个人力扣刷题记录与源码分享平台
10-03
该项目是一个基于Python的个人力扣刷题记录与源码分享平台，包含39个文件，包括24个Python源代码文件、7个Markdown文档、3个PNG图片文件、2个文本文件、1个Git忽略文件、1个开源许可证文件、1个CSV文件和1个Markdown...
Leetcode:记录力扣刷题之路
03-15
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为程序员提升技能和准备面试而设计。在这个平台上，你可以找到各种算法问题，涵盖数据结构、排序算法、搜索算法、图论等多个领域。本压缩包文件"Leetcode-...
大厂笔试算法宝典力扣刷题
05-25
《大厂笔试算法宝典力扣刷题》是针对求职者特别是希望进入知名互联网公司（大厂）的程序员们精心准备的一份学习资料。这份宝典聚焦于算法和编程技巧，旨在帮助读者提升解决实际问题的能力，特别是应对面试和笔试中的...
基于Java编程的力扣刷题合集设计源码分享
10-06
该项目是一个基于Java编程的力扣刷题合集设计源码，总计包含314个文件，其中包括308个Java源文件、4个HTML文件、1个Git忽略文件和1个Markdown文件。该合集旨在记录算法学习与成长的历程，适合用于算法练习与学习。
力扣剑指offer第一题：整数除法
qq_67633964的博客
12-30 191
并没有解出来，官方题解也没有直接给的一种很笨的方法
力扣题399除法求值
xxyneymar的博客
12-28 461
给你一个变量对数组 equations 和一个实数值数组 values 作为已知条件，其中 equations[i] = [Ai, Bi] 和 values[i] 共同表示等式 Ai / Bi = values[i] 。每个 Ai 或 Bi 是一个表示单个变量的字符串。 另有一些以数组 queries 表示的问题，其中 queries[j] = [Cj, Dj] 表示第 j 个问题，请你根据已知条件找出 Cj / Dj = ? 的结果作为答案。 返回 所有问题的答案 。如果存在某个无法确定的答案，则用
力扣||29. 两数相除
obsidianlyg的博客
03-29 183
给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。 返回被除数 dividend 除以除数 divisor 得到的商。 整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2 示例 1: 输入: dividend = 10, diviso...
力扣 两数相除
qq_41723573的博客
04-19 303
29. 两数相除 难度中等321收藏分享切换为英文关注反馈 给定两个整数，被除数dividend和除数divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。 返回被除数dividend除以除数divisor得到的商。 整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8以及truncate(-2.7335) = ...
力扣刷题C++常用操作
10-18
好的，关于力扣刷题C++常用操作，我可以给你一些常见的操作和技巧： 1. 使用 STL 容器和算法库：STL（Standard Template Library）是 C++ 标准库中的一个重要组成部分，包含了许多常用的容器和算法。在力扣刷题中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值