leetcode总结——数字篇

最新推荐文章于 2025-04-18 11:36:28 发布
最新推荐文章于 2025-04-18 11:36:28 发布
阅读量389 收藏
点赞数
分类专栏： Leetcode1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45680007/article/details/104365386
版权
这篇博客总结了LeetCode中关于数字处理的题目，包括翻转数字、整数除法、atoi算法、格雷编码、3的幂次方判断等，探讨了各种算法的实现和思路，例如通过位运算解决范围数字的与和问题，以及如何高效地判断一个数是否是3的幂次方。

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

数字处理
翻转数字
atoi
范围数字的与和
整数除法
丑数
pow算法：
格雷编码
是否是3的幂次方

众数
超过 ⌊ n/3 ⌋ 次的众数
所有因子

两个恰好出现一次的数
重复三次数字

灯泡开关
计算1的数目
超级丑树

范围数字的与和：
给定范围 [m, n]，其中 0 <= m <= n <= 2147483647，返回此范围内所有数字的按位与（包含 m, n 两端点）。

示例 1:
输入: [5,7]
输出: 4
示例 2:

输入: [0,1]
输出: 0

此题其实就是寻找[m,n]范围内二进制数高位（左边）没有变化的数，后面补上0即为所求的结果。
判断m、n是否相等，如果不相等，m+1会使m的二进制数末位进位，有进位说明m的末位肯定有0的情况，0与任何数相与皆得0，所以结果的末位肯定是0。同理，不断右移1位进行比较，直到最终 m=n 时，说明找到了[m,n]这个范围内高位没有变化的数，左移相同位数得到的结果就是所求的值。

class Solution {
    public int rangeBitwiseAnd(int m, int n) {
        int count = 0; // 统计移位次数
        while (m != n)
        {
            m >>= 1;
            n >>= 1;
            count++;
        }
        n <<= count;
        return n;
    }
}

翻转数字：
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21

解析：难点在于越界值得判断
举个例子。如果说允许的最大值是500的话，那么输入数字是125，逆置为521即越界。所以在
52*10之前进行一次判断。

class Solution {
    public int reverse(int x) {
        int result=0,pop=0;
        while(x!=0){
            pop=x%10;
            x=x/10;
            if(result>Integer.MAX_VALUE/10||result== Integer.MAX_VALUE/10&&pop> Integer.MAX_VALUE%10){return 0;}
            if(result<Integer.MIN_VALUE/10||result== Integer.MIN_VALUE/10&&pop< Integer.MIN_VALUE%10){return 0;} 
            result=result*10+pop;
        }
        return result;
    }
}

atoi：
请你来实现一个 atoi 函数，使其能将字符串转换成整数。
首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。
当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。

该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。

注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0。
说明：
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

示例 1:

输入: “42”
输出: 42

示例 2:
输入: " -42"
输出: -42
解释: 第一个非空白字符为 ‘-’, 它是一个负号。
我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。

示例 3：
输入: “4193 with words”
输出: 4193
解释: 转换截止于数字 ‘3’ ，因为它的下一个字符不为数字。

示例 4:
输入: “words and 987”
输出: 0
解释: 第一个非空字符是 ‘w’, 但它不是数字或正、负号。
因此无法执行有效的转换。

示例 5:
输入: “-91283472332”
输出: -2147483648
解释: 数字 “-91283472332” 超过 32 位有符号整数范围。
因此返回 INT_MIN (−231) 。

解析：
1：首先需要删除前后空格
2：判断第一个字符是否数字或者符号
3：之后读取后置所有数字，遇到非数字终止
4：读取过程中判断数字大小是否越界

class Solution {
    public int myAtoi(String str) {
        if(str.length()==0)return 0;
        str=str.trim();//去除前后空格
        char c[]=str.toCharArray();        
        if((c[0]<'0'||c[0]>'9')&&c[0]!='-'&&c[0]!='+'){
            return 0;
        }
        int i=0;int flag=1,result=0;//正负标志
        if(c[i]=='-'){i++;flag=-1;}
        else if(c[i]=='+'){i++;}
       while(i<c.length&&c[i]>='0'&&c[i]<='9'){
           // String str1=String.valueOf(c[i]);
          //  int num=Integer.parseInt(str1);
              int num=c[i]-'0';
            if(flag==1&&(result>Integer.MAX_VALUE/10||(result== Integer.MAX_VALUE/10&&num>Integer.MAX_VALUE%10))){return Integer.MAX_VALUE;}
            if(flag==-1&&(-1*result<Integer.MIN_VALUE/10||(-1*result== Integer.MIN_VALUE/10&&-1*num<Integer.MIN_VALUE%10))){return Integer.MIN_VALUE;} 
            result=result*10+num; i++;    
       }
        return flag*result;
    }
}

整数除法：
给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以字符串形式返回小数。
如果小数部分为循环小数，则将循环的部分括在括号内。

示例 1:
输入: numerator = 1, denominator = 2
输出: “0.5”

示例 2:
输入: numerator = 2, denominator = 1
输出: “2”

示例 3:
输入: numerator = 2, denominator = 3
输出: “0.(6)”

解析：分为四个部分±号的判别，整数部分[注意越界]，"."，小数部分

class Solution {
    public String fractionToDecimal(int numerator, int denominator) {
        StringBuilder result=new StringBuilder();
        if(numerator==0)return "0";
        //添加-号
        if(numerator<0^denominator<0){
            result.append("-");
        }
        //获得整数部分，注意越界，−2147483648​
        long  Ldenominator=Math.abs(Long.valueOf(denominator));
        long  Lnumerator=Math.abs(Long.valueOf(numerator));
        result.append(Lnumerator/Ldenominator);
        
        long num1=Lnumerator%Ldenominator;
        if(num1==0)return result.toString();
        //获得小数部分
        result.append(".");
        Map<Long,Integer> map=new HashMap<>();
        StringBuilder fraction=new StringBuilder();
        while(num1!=0){
            if(map.containsKey(num1)){
                fraction.insert(map.get(num1), "(");
                fraction.append(")");
                break;
            }
            map.put(num1,fraction.length());
            num1*=10;
            long num2=num1/Ldenominator;
            fraction.append(String.valueOf(num2));
            num1=num1%denominator;
        }
  
        result.append(fraction);
        return result.toString();
    }
}

丑数：
编写一个程序，找出第 n 个丑数。
丑数就是只包含质因数 2, 3, 5 的正整数。

示例:
输入: n = 10
输出: 12
解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。

class Solution {
    public int nthUglyNumber(int n) {
        int dp[]=new int [n];
        int i2=0,i3=0,i5=0;
        dp[0]=1;
        for(int i=1;i<n;i++){
            dp[i]=Math.min(dp[i2] * 2, Math.min(dp[i3] * 3, dp[i5] * 5));
            if(dp[i]==dp[i2]*2)i2++;
            if(dp[i]==dp[i3]*3)i3++;
            if(dp[i]==dp[i5]*5)i5++;
        }
        return dp[n-1];
    }
}

pow算法：
实现 pow(x, n) ，即计算 x 的 n 次幂函数。

示例 1:
输入: 2.00000, 10
输出: 1024.00000

示例 2:
输入: 2.10000, 3
输出: 9.26100

示例 3:
输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25

class Solution {
    public double myPow(double x, int n) {
        long N=n;
        if(n<0){
            N=-N;
            x=1/x;
        }
        return getPow(x,N);
    }
        
        public double getPow(double x,long n){
        if(n==1)return x;
        if(n==0)return 1;
        double value=getPow(x,n/2);
        if(n%2==0){    
            return value*value;
        }
        else{
            return value*value*x;
        }
        }
}

格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。格雷编码序列必须以 0 开头。

示例 1:
输入: 2
输出: [0,1,3,2]
解释:
00 - 0
01 - 1
11 - 3
10 - 2
对于给定的 n，其格雷编码序列并不唯一。
例如，[0,2,3,1] 也是一个有效的格雷编码序列。
00 - 0
10 - 2
11 - 3
01 - 1

示例 2:
输入: 0
输出: [0]
解释: 我们定义格雷编码序列必须以 0 开头。
给定编码总位数为 n 的格雷编码序列，其长度为 2^n。当 n = 0 时，长度为 20 = 1。
因此，当 n = 0 时，其格雷编码序列为 [0]。
处。
解析，其实比较找规律。利用的迭代的方法

class Solution {
    public List<Integer> grayCode(int n) {
        List< Integer> list=new LinkedList<>();
        list.add(0);
        if(n==0)return list;
        list.add(1);
        for(int i=1;i<n;i++){
            int value=1<<i;
            for(int j=list.size()-1;j>=0;j--){
                list.add(list.get(j)+value);
            }
        }
        return list;
    }
}

题目三：
给定一个整数，写一个函数来判断它是否是 3 的幂次方。

示例 1:

输入: 27
输出: true
示例 2:

输入: 0
输出: false
示例 3:

输入: 9
输出: true
示例 4:

输入: 45
输出: false


class Solution {
    public boolean isPowerOfThree(int n) {
        if(n==1)return true;
        if(n<3)return false;
        while(n%3==0){n=n/3;}
        if(n==1)return true;
        return false;        
    }
}

重复三次数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:
输入: [2,2,3,2]
输出: 3

示例 2:
输入: [0,1,0,1,0,1,99]
输出: 99

解析：利用模拟三进制，for (int i = 0; i < 32; i++) 对每个进制位进行计算，nums[j] >>> i & 1就将数字转变成第i位

class Solution {
    public int singleNumber(int[] nums) {
        int ans = 0;
        //考虑每一位
        for (int i = 0; i < 32; i++) {
            int count = 0;
            //考虑每一个数
            for (int j = 0; j < nums.length; j++) {
                //当前位是否是 1
                if ((nums[j] >>> i & 1) == 1) {
                    count++;
                }
            }
            //1 的个数是否是 3 的倍数
            if (count % 3 != 0) {
                ans = ans+(1 << i);
            }
        }
            return ans;
    }
}

众数：
给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在众数。
示例 1:
输入: [3,2,3]
输出: 3

示例 2:
输入: [2,2,1,1,1,2,2]
输出: 2

class Solution {
    public int majorityElement(int[] nums) {
        Stack<Integer> sta=new Stack<>();
        sta.push(nums[0]);int i=1;
        while(i<nums.length){
            if(sta.isEmpty())sta.push(nums[i]);
            else if(sta.peek()==nums[i])sta.push(nums[i]);
            else sta.pop();i++;
        }
        return sta.peek();
    }
}

超过 ⌊ n/3 ⌋ 次的众数
给定一个大小为 n 的数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。
说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。
示例 1:
输入: [3,2,3]
输出: [3]
示例 2:
输入: [1,1,1,3,3,2,2,2]
输出: [1,2]

解析：很多细节的地方。比如说虽然是两个值投票，但是刚开始的时候都指向nums[0]，关键在于if后一定要直接continue。
并且最后还要遍历一次，因为存储的值不一定是n/3

class Solution {
    public List<Integer> majorityElement(int[] nums) {
        int nums1=0,nums2=0,flag1=0,flag2=0;
        for(int i=0;i<nums.length;i++){
            if(nums1==nums[i]){flag1++;continue;}
            if(nums2==nums[i]){flag2++;continue;}
            if(flag1==0){nums1=nums[i];flag1++;continue;}
            if(flag2==0){nums2=nums[i];flag2++;continue;}
            flag1--;flag2--;
        }
        List<Integer> list=new LinkedList<>();
       flag1 = 0;
       flag2 = 0;
       for (int num : nums) {
           if (num == nums1)
               flag1++;
           else if (num == nums2)
               flag2++;      } 
        if (flag1 > nums.length / 3)
            list.add(nums1);
        if (flag2 > nums.length / 3)
            list.add(nums2);
        return list;
    }
}

所有因子：
整数可以被看作是其因子的乘积。
例如：
8 = 2 x 2 x 2;
= 2 x 4.
请实现一个函数，该函数接收一个整数 n 并返回该整数所有的因子组合。
注意：
你可以假定 n 为永远为正数。
因子必须大于 1 并且小于 n。
示例 1：
输入: 1
输出: []
示例 2：
输入: 37
输出: []
示例 3：
输入: 12
输出:
[
[2, 6],
[2, 2, 3],
[3, 4]
]

class Solution {
    List<List<Integer>> result=new LinkedList<>();
    public List<List<Integer>> getFactors(int n) {
        if(n==1)return result;
        getValue(2,n,n,new LinkedList<>());
        return result;
    }
    public void getValue(int start,int value ,int n,LinkedList<Integer> list){
        if(value==1)
        {result.add(new LinkedList(list));return; }
        for(int i=start;i<n;i++){
            if(value%i==0){
                list.add(i);
                getValue(i,value/i,n,list);
                list.remove(list.size()-1);
            }
        }
    }
}

两个恰好出现一次的数
给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。
示例 :
输入: [1,2,1,3,2,5]
输出: [3,5]
注意：

class Solution {
  public int[] singleNumber(int[] nums) {
        int xor = 0;
        for (int i : nums)// 一样的抵消,不一样的两个数字异或运算结果必定有一位是1
            xor ^= i;
        int mask = xor & (-xor);
        int[] ans = new int[2];
        for (int i : nums) {
            if ((i & mask) == 0)//== 0、 == mask 两种结果
                ans[0] ^= i;
            else
                ans[1] ^= i;
        }
        return ans;
    }
}

灯泡开关
初始时有 n 个灯泡关闭。 第 1 轮，你打开所有的灯泡。 第 2 轮，每两个灯泡你关闭一次。 第 3 轮，每三个灯泡切换一次开关（如果关闭则开启，如果开启则关闭）。第 i 轮，每 i 个灯泡切换一次开关。 对于第 n 轮，你只切换最后一个灯泡的开关。 找出 n 轮后有多少个亮着的灯泡。
示例:
输入: 3
输出: 1
解释:
初始时, 灯泡状态 [关闭, 关闭, 关闭].
第一轮后, 灯泡状态 [开启, 开启, 开启].
第二轮后, 灯泡状态 [开启, 关闭, 开启].
第三轮后, 灯泡状态 [开启, 关闭, 关闭].
你应该返回 1，因为只有一个灯泡还亮着。

class Solution {
    public int bulbSwitch(int n) {
        return (int)Math.sqrt(n);
    }
}

计算1的数目
给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。
示例 1:
输入: 2
输出: [0,1,1]
示例 2:
输入: 5
输出: [0,1,1,2,1,2]

public class Solution {
    public int[] countBits(int num) {
        int[] ans = new int[num + 1];
        int i = 0, b = 1;
        while (b <= num) {
            while(i < b && i + b <= num){
                ans[i + b] = ans[i] + 1;
                ++i;
            }
            i = 0;   
            b <<= 1; 
        }
        return ans;
    }
}

超级丑数：
编写一段程序来查找第 n 个超级丑数。
超级丑数是指其所有质因数都是长度为 k 的质数列表 primes 中的正整数
示例:
输入: n = 12, primes = [2,7,13,19]
输出: 32
解释: 给定长度为 4 的质数列表 primes = [2,7,13,19]，前 12 个超级丑数序列为：[1,2,4,7,8,13,14,16,19,26,28,32] 。
说明:
1 是任何给定 primes 的超级丑数。
给定 primes 中的数字以升序排列。
0 < k ≤ 100, 0 < n ≤ 106, 0 < primes[i] < 1000 。
第 n 个超级丑数确保在 32 位有符整数范围内。
解析:nums为超级丑数的值，pos[i]指的是primes[i]对应nums中的哪一个位置

public class Solution {
    public int nthSuperUglyNumber(int n, int[] primes) {
        if (n<=1) return 1;
        int[] nums = new int[n];
        nums[0] = 1;
        int[] pos = new int[primes.length];
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer i1, Integer i2) {
               return Integer.compare(nums[pos[i1]] * primes[i1], nums[pos[i2]] * primes[i2]);
            }
        });
        for(int i=0; i<primes.length; i++) minHeap.add(i);
        for(int i=1; i<n; i++) {
            do {
                int min = minHeap.poll();
                nums[i] = nums[pos[min]] * primes[min];
                pos[min] ++;
                minHeap.offer(min);
            } while (nums[i]==nums[i-1]);
        }
        return nums[n-1];
    }
}
LeetCode总结
Allan的专栏
01-04 18万+
最近完成了www.leetcode.com的online judge中151道算法题目。除各个题目有特殊巧妙的解法以外，大部分题目都是经典的算法或者数据结构，因此做了如下小结
leetcode总结——数组篇
weixin_45680007的博客
02-17 788
快慢指针：环形数组，最多出现两次的数组 pat型：除开自己的以外的乘积 Map：两数和/三数和/四数和，播放磁带，01数组 滑动窗口：最长不重复子串,t步内差小于k 首尾指针：水桶容量 贪心算法：合并区间，跳跃数组，矩阵面积 计算机数字转化 环形数组： 给定一个含有正整数和负整数的环形数组 nums。 如果某个索引中的数 k 为正数，则向前移动 k 个索引。相反，如果是负数 (-k)，则向后移动 ...
leetcode总结
08-06
把刷的leetcode的算法经典题及其博客详解总在一起，方便查看
Leetcode链表题总结
最新发布
qq_52092747的博客
04-18 1130
leetcode提供的链表一般没有头结点，某些题目需要注意添加头结点，这样一来，我们就不需要对链表的第一个结点进行特殊的操作与判断了。
leetcode 总结
Luckyzhoufangbing的博客
09-27 277
这道题就是情况多了点，仔细分析完 var maximumProduct = function(nums) { var sortArr = nums.sort((a, b) => { return a - b }) // 后三个数 // 如果有三个正 直接乘积返回 // 如果有一个正 数组前两与最后一项 // 如果有两个正 数组前两与最后一项 var maxIndex = nums.length - 1 // 前两项..
leetcode总结——树篇
weixin_45680007的博客
02-17 390
自上而下： 路径和sum 最短路径 镜像树 层次遍历 树化链表 完全二叉树的节点个数： 路径和sum： 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及目标和 sum = 22， 5 / \ 4 8 ...
leetcode总结——字符串篇
weixin_45680007的博客
02-17 667
字符串处理： 翻转字符串 同构字符串 异位字符串： 翻转字符串 给定一个字符串，逐个翻转字符串中的每个单词。 示例 1： 输入: “the sky is blue” 输出: “blue is sky the” 示例 2： 输入: " hello world! " 输出: “world! hello” 解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。 示例 3： 输...
【LeetCode 总结】Leetcode 题型分类总结、索引与常用接口函数
只能说希望每日一更
08-07 3555
文章目录零. Java 常用接口函数集合类数学类字符串一. 动态规划知识点题目二. 链表知识点题目三. 哈希表知识点题目四. 滑动窗口知识点题目五. 字符串知识点题目六. DFS、BFS知识点题目七. 二分法知识点题目八. 偏数学、过目不忘 and 原地算法等知识点题目 前言： 是时候开一个对于我的 LeetCode 专栏的总结索引了= = 虽然说大概只刷了150道左右，不过应该也可以简单总结一下了呢～ 题型主要是 LeetCode hot100 + 剑指Offer，也有其他的一些高频题 零. Java
LeetCode 有效数字
hestyle的博客
02-14 413
验证给定的字符串是否为数字。 例如: "0" =&gt; true " 0.1 " =&gt; true "abc" =&gt; false "1 a" =&gt; false "2e10" =&gt; true 说明: 我们有意将问题陈述地比较模糊。在实现代码之前，你应当事先思考所有可能的情况。 思路分析：这题干给的不是一般的模糊，不要将什么策略，撸起袖子就是干！！
LeetCode：Valid Number - 判断字符串中内容是否为数字
09-19 799
1、题目名称 Valid Number（判断字符串中内容是否为数字） 2、题目地址 https://leetcode.com/problems/valid-number/ 3、题目内容 英文：Validate if a given string is numeric. 中文：给出一...
LeetCode题解(0065)：验证字符串是否可以解释为十进制数字(Python)【有限状态自动机】
长行
08-13 395
题目：原题链接（困难） 标签：字符串、正则表达式、自动机、自动机-有限状态自动机 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) – – 44ms (80.06%) Ans 2 (Python) – – 48ms (56.89%) Ans 3 (Python) O(N)O(N)O(N) O(N)O(N)O(N) 48ms (56.89%) LeetCode的Python执行用时随缘，只要时间复杂度没有明显差异，执行用时一般都在同一个量级，仅作参考意义。
力扣(LeetCode)-猜数字（简单）
weixin_48163692的博客
04-13 283
01. 猜数字 题目链接：https://leetcode-cn.com/problems/guess-numbers/ 题目： 小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？ 输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。 示例 1： 输入：guess = [1,2,3], answer = [1,2,3
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值