Day7/7：2021-1-31 剑指offer-位运算

最新推荐文章于 2024-04-29 23:18:05 发布
最新推荐文章于 2024-04-29 23:18:05 发布
阅读量481 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34318539/article/details/113486768
版权

在这里插入图片描述

文章目录

7.位运算

// jdk中二进制转十进制方式
System.out.println(Integer.parseInt("1001", 2));

// jdk中十进制转二进制方式
System.out.println(Integer.toBinaryString(9));
System.out.println(Integer.toString(9, 2));
剑指 Offer 15 .二进制中1的个数

思考：那就记住吧。只能用>>>。而不能用>>。

public class Offer15 {
    public static void main(String[] args) {
        int n = 9;
        System.out.println(hammingWeight(n));
    }

    public static int hammingWeight(int n) {
        int res = 0;
        while (n != 0) {
            res += n & 1;
            n >>>= 1;
        }
        return res;
    }
}

// 在传递时也把符号一起传递，比如+3、-2在传递再传出时依然是+3、-2，而使用>>>时就会统一变为3、2。带符号于无符号的差别就在此。
public class Offer15_1 {
    public static void main(String[] args) {
        System.out.println(2 >> 1);//1
        System.out.println(2 >>> 1);//1
        System.out.println(-2 >> 1);//-1
        System.out.println(-2 >>> 1); //2147483647
    }
}
// 感觉也不是呀。
剑指 Offer 56 - 基础题
基础内容：
如果除了一个数字以外，其他数字都出现了两次，那么如何找到出现一次的数字？
另一种是，一个数组中一个数字出现了奇数次，其他数字都出现了偶数次，求出这个出现奇数次的数字。

答案很简单：全员进行异或操作即可。考虑异或操作的性质：对于两个操作数的每一位，相同结果为 0，不同结果为 1。那么在计算过程中，成对出现的数字的所有位会两两抵消为 0，最终得到的结果就是那个出现了一次的数字。

在一开始设置的为0。
n&(n-1)会删掉二进制中最后一个1。

public class Offer56_1_3 {
    public static void main(String[] args) {
        // 找出数组中只出现一次的数。
        int[] nums = new int[]{1, 1, 2, 2, 3};
        System.out.println(singleNumbers(nums));
    }

    public static int singleNumbers(int[] nums) {
        int res = 0;
        for (int num : nums) {
            res = res ^ num;
        }
        return res;
    }
}
// 结果为3
剑指 Offer 56 - I 数组中数字出现的次数

一个整型数组 nums 里除一个数字之外，其他数字都出现了两次。请写程序找出这个只出现一次的数字。全员异或操作即可得到结果。

（1）位运算

题解：https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof/solution/jian-zhi-offer-56-i-shu-zu-zhong-shu-zi-tykom/

image-20210130173526122

// 位运算
import java.util.Arrays;
import java.util.HashMap;

public class Offer56_1_2 {
    //一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
    public static void main(String[] args) {
        int[] nums = new int[]{4, 1, 4, 6};
        System.out.println(Arrays.toString(singleNumbers(nums)));
    }

    public static int[] singleNumbers(int[] nums) {
        //xor用来计算nums的异或和
        int xor = 0;

        // 计算异或和 并存到xor
        // e.g. [2,4,2,3,3,6] 异或和：(2^2)^(3^3)^(4^6)=2=010
        for (int num : nums) {
            xor ^= num;
//            System.out.println(Integer.toBinaryString(xor));
        }

        //设置mask为1，则二进制为0001
        // mask是一个二进制数，且其中只有一位是1，其他位全是0，比如000010，
        // 表示我们用倒数第二位作为分组标准，倒数第二位是0的数字分到一组，倒数第二位是1的分到另一组
        int mask = 1;

        // & operator只有1&1时等于1 其余等于0
        // 用上面的e.g. 4和6的二进制是不同的 我们从右到左找到第一个不同的位就可以分组 4=0100 6=0110
        // 根据e.g. 010 & 001 = 000 = 0则 mask=010
        // 010 & 010 != 0 所以mask=010
        // 之后就可以用mask来将数组里的两个数分区分开
        System.out.println("xor=" + Integer.toBinaryString(xor));
        System.out.println("mask=" + Integer.toBinaryString(mask));
        while ((xor & mask) == 0) {
            mask <<= 1;
            System.out.println(Integer.toBinaryString(mask));
        }
        System.out.println("mask=" + Integer.toBinaryString(mask));
        //两个只出现一次的数字
        int a = 0, b = 0;

        for (int num : nums) {
            //根据&是否为0区分将两个数字分区，并分别求异或和
            if ((num & mask) == 0) a ^= num;
            else {
                b ^= num;
            }
        }
        return new int[]{a, b};
    }
}
（2）hashmap
// hashmap
import java.util.Arrays;
import java.util.HashMap;

public class Offer56_1 {
    //一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
    public static void main(String[] args) {
        int[] nums = new int[]{4, 1, 4, 6};
        System.out.println(Arrays.toString(singleNumbers(nums)));
    }

    public static int[] singleNumbers(int[] nums) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int count = map.getOrDefault(nums[i], 0) + 1;
            map.put(nums[i], count);
        }
        int[] res = new int[2];
        int index = 0;
        for (Integer key : map.keySet()) {
            if (map.get(key) == 1) {
                res[index++] = key;
                if (index == 2) {
                    break;
                }
            }
        }
        return res;
    }
}
剑指 Offer 56 - II 数组中数字出现的次数 II
（1）位运算

思考：

首先遍历一个数，将其转为二进制形式。数组形式。

比如 n=11=8+2+1=1011B

import java.util.Arrays;

public class Offer56_2_1 {
    public static void main(String[] args) {
        int n = 11;
        int[] count = new int[32];
        System.out.println("n=" + n + "二进制位：" + Integer.toBinaryString(n));
        for (int i = 0; i < 32; i++) {
            count[i] += n & 1;
            n >>>= 1;
            System.out.println("i=" + i + " count=" + Arrays.toString(count));
        }
    }
}

n=11二进制位：1011 你看，下面的结果是逆序的。这个是和自己一开始考虑的不一样哦。
i=0 count=[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
i=1 count=[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
i=2 count=[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
i=3 count=[1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
i=4 count=[1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
i=5 count=[1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

image-20210131152749876

image-20210131152810694

image-20210131152825407

public class Offer56_2 {
    public static void main(String[] args) {
        int[] nums = new int[]{9, 1, 7, 9, 7, 9, 7};
        System.out.println(singleNumber(nums));
    }

    public static int singleNumber(int[] nums) {
        int[] count = new int[32];
//        System.out.println(Arrays.toString(count));
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < 32; j++) {
                count[j] += nums[i] & 1;
                nums[i] >>>= 1;
//                System.out.println(Arrays.toString(count));
            }
        }
//        System.out.println(Arrays.toString(count));
        for (int i = 0; i < 32; i++) {
            count[i] = count[i] % 3;
        }
//        System.out.println(Arrays.toString(count));
        int res = 0;//[0,0,0,1]=0001
        for (int i = count.length - 1; i >= 0; i--) {
            res <<= 1;
            res |= count[i];
        }
        return res;
    }
}
（2）简单做法 HashMap
import java.util.HashMap;

public class Offer56_2 {
    public static void main(String[] args) {
        int[] nums = new int[]{9, 1, 7, 9, 7, 9, 7};
        System.out.println(singleNumber(nums));
    }

    // 在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。
    public static int singleNumber(int[] nums) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int count = map.getOrDefault(nums[i], 0) + 1;
            map.put(nums[i], count);
        }
        // 遍历 map 的 values
        int res = -1;
        for (Integer key : map.keySet()) {
            if (map.get(key) == 1) {
                res = key;
                break;
            }
        }
        return res;
    }
}
剑指 Offer 64 .求1+2+…+n

思考：

// 但是这里使用了if，不满足题意。要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
public class Offer64 {
    public static void main(String[] args) {
        int n = 9;
        System.out.println(sumNums(n));
    }
    public static int sumNums(int n) {
        //终止条件
        if(n==1){
            return 1;
        }
        n+=sumNums(n-1);
        return n;
    }
}

// 使用 &&
public class Offer64_1 {
    public static void main(String[] args) {
        int n = 9;
        System.out.println(sumNums(n));
    }

    static int res = 0;
    static boolean flag;

    public static int sumNums(int n) {
        System.out.println("flag=" + (n > 1 && sumNums(n - 1) > 0) + "  n=" + n);
        flag = n > 1 && sumNums(n - 1) > 0;
        res += n;
        return res;
    }
}
剑指 Offer 65 .不用加减乘除做加法

思考：虽然系统分类是简单。但并不容易吧。

image-20210131221309300

image-20210131221321937

image-20210131221337755

public class Offer65 {
    public static void main(String[] args) {
        int a = 20;
        int b = 17;
        System.out.println(add(a, b));
    }

    public static int add(int a, int b) {
        if (b == 0) {
            return a;
        }

        // 转换成非进位和 + 进位
        return add(a ^ b, (a & b) << 1);
    }
}
剑指 Offer 66 .构建乘积数组

思考：

自己手写了一张笔记，还需要上传。

image-20210201095212989

image-20210201095226818

（1）在不使用除法的情况下
import java.util.Arrays;

public class Offer66_1 {
    public static void main(String[] args) {
        int[] nums = new int[]{1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(constructArr(nums)));
    }

    public static int[] constructArr(int[] a) {
        //输入判断
        if (a == null || a.length == 0) {
            return new int[0];
        }
        int len = a.length;
        int[] res = new int[len];
        int[] left = new int[len];
        int[] right = new int[len];
        left[0] = right[len - 1] = 1;
        for (int i = 1; i < len; i++) {
            left[i] = left[i - 1] * a[i - 1];
        }
        for (int i = len - 2; i >= 0; i--) {
            right[i] = right[i + 1] * a[i + 1];
        }
        for (int i = 0; i < len; i++) {
            res[i] = left[i] * right[i];
        }
        return res;
    }
}
（2）在使用除法的情况下
import java.util.Arrays;

public class Offer66 {
    public static void main(String[] args) {
        int[] nums = new int[]{1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(constructArr(nums)));
    }

    public static int[] constructArr(int[] a) {
        int[] res = new int[a.length];
        int value = 1;
        for (int i = 0; i < a.length; i++) {
            value *= a[i];
        }
        for (int i = 0; i < res.length; i++) {
            res[i] = value / a[i];
        }
        return res;
    }
}
自渡2021
关注
Day4/7：2021-1-28：剑指offer的 哈希表 部分+MySQL必知必会
renxanshou的博客
01-28 450
文章目录第3章 使用MySQL3.0创建数据库3.1连接数据库3.3了解数据库和表第4章 检索数据4.2select检索单列4.3select检索多列4.4select检索所有列4.5使用distinct 去重，这个作用还是挺重要的吧4.6限制结果的查询，使用limit检索部分行，开始位置为行索引值，索引从0开始第5章 排序检索数据5.1使用order by 子句对输出排序6.**哈希表**剑指 Offer 50 .[第一个只出现一次的字符 ](https://leetcode-cn.com/problem
Day1/7：2021-2-1 剑指offer-位运算+哈希表的完全整理+mysql【15-18】
renxanshou的博客
02-01 187
昨天的剑指offer-位运算的完全整理 https://blog.csdn.net/qq_34318539/article/details/113486768 剑指offer-哈希表的完全整理：
Day6/7：2021-1-30 mysql必知必会【13-14】+剑指offer-位运算的一部分
renxanshou的博客
01-30 385
文章目录第13章 分组计算 group by和having13.3having子句 过滤分组13.4分组和排序第14章 使用子查询 嵌套查询 多个查询7.**剑指offer-位运算**剑指 Offer 15 .[二进制中1的个数 ](https://leetcode-cn.com/problems/er-jin-zhi-zhong-1de-ge-shu-lcof)剑指 Offer 56 - 基础题剑指 Offer 56 - I [数组中数字出现的次数 ](https://leetcode-cn.com
《剑指offer》 -day22- 位运算（中等）
weixin_56915683的博客
12-22 297
剑指 Offer 56 - I. 数组中数字出现的次数 题目描述 一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。 限制： 2<=nums.length<=100002 <= nums.length <= 100002<=nums.length<=10000 哈希表 思路： 比较简单的思路是利用 map 统计每个元素出现的次数，然后取次数只出现一次的元素，即可。
《剑指offer》 -day21- 位运算（简单）
weixin_56915683的博客
12-22 209
剑指 Offer 15. 二进制中1的个数 题目描述 编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为 汉明重量).）。 提示： 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。 在 Java 中，编译器使用 二进制补码 记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号
剑指 offer day21-22 位运算
qq_52641681的博客
11-03 4025
剑指 Offer 15. 二进制中1的个数 题目： 编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数。 题解1: 直接调用Integer.bitCount()函数 public int hammingWeight(int n) { return Integer.bitCount(n); } 题解2(逐位判断)： 位运算，清晰图解 1.若n&1=0，则证明最右一位是0；反之若n&1=1，则证明最后一位是1，则返回值
剑指offer刷题day-1
weixin_43193071的博客
07-23 263
剑指offer刷题day-1 (12道题） 知识点梳理 1.类似于二分从右上角开始找，复杂度o(n2)—>0(n+m) 就是o(n)级别的 2.语法题，python里的replace函数 3.vector(ans.rbegin(),ans.rend()) 返回一个反转数组 4.重点： ...
《剑指offer》 -day13- 双指针（简单）
weixin_56915683的博客
12-13 203
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面 题目描述 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。 提示： 0<=nums.length<=500000 <= nums.length <= 500000<=nums.length<=50000 0<=nums[i]<=100000 <= nums[i] <= 100000<=nums[i]<=1000
剑指offer-day1
yzfwx2000的博客
03-08 619
剑指 Offer 03. 数组中重复的数字 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 剑指 Offer 04. 二维数组中的查找 在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 剑指 Offer 05
Java基础编程题50道题
热门推荐
yuweiran_5的博客
05-06 1万+
1、題目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 思路：微笑刚开始真的无从下手，这么难的，怎么可以说是基础呢，感觉这些应该是逻辑分析很强的，第一个月只有一对兔子，第二个月还是只有一对兔子，第三个月，就有两对了，第四个月3对，第五个月5对，第六个月8对，第七个月是13对。。。。。。规律出来了，你们发了没？ public class TestDay01 { public static void
算法速成记录贴Day0
m0_73851292的博客
05-06 248
找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2 步，慢指针每次移动 1 步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。将两个排序后的子链表合并，得到完整的排序后的链表。可以使用「21. 合并两个有序链表」的做法，将两个有序的子链表进行合并。思路：每走一次，fast指针比slow快1，若有环，两指针一定相遇。思路1：复制链表值到数组列表中，利用双指针判回文。思路2：设定一个哨兵节点，不断调整其指针pre。对两个子链表分别排序。
2024华为OD机试最新E卷题库-(C卷+D卷+E卷)-(JAVA、Python、C++)
goldarmour的博客
04-29 6530
2023年11月以后，考的都是C卷，题库已经准备好，欢迎大家交流学习。 据考过D卷的同学反馈，D卷和C卷是相同的题目。如果发现新题，会及时更新。祝大家考试顺利！
题解 | #删除有序链表中重复的元素-I#原地复制链表比清晰
华鑫的专栏
04-26 476
投了产品数据工程实习生，已做完测评、笔试，现在都没有反应，求hr捞一波，沟通面试流程base可成都、1、自我介绍2、挖项目，简历写了两个项目，问我想挖哪个，我说游戏那个。投的后端，某书上次笔试a了3.5/4道，过了一个周没动静突然叫我笔试。1、自我介绍2、简历上项目详述，然后提问讨论3、为什么没有留在上一家公司实习，实习工资是多少4、中断。一面4.17 一个小时,电话面试1. 地图首屏优化怎么做的2. 优化做的挺多的,另一个怎么做的?刚接到团子的电话，但我昨天已经接了得物的offer，现在很。
算法 64式 7、搜索算法整理_第3部分_31到45题
qingyuanluofeng的专栏
10-13 671
1 算法思想 算法分类 搜索算法主要分为: 暴力搜索+剪枝，枚举，广度优先搜索，深度优先搜索，二分查找，哈希查找， A*算法，两边向中间逼近,从中间向两边扩散等 1.1枚举 枚举: 最直白的搜索方式，依次尝试搜索空间中的所有解。可以在搜索过程中通过加强条件约束来减少搜索范围图。 例如: 百鸡问题 1.2广度优先搜索(BFS) 含义:遍历解答树时使每次状态转移时扩展出尽可...
基于java的贝儿米幼儿教育管理系统答辩PPT.pptx
11-04
基于java的贝儿米幼儿教育管理系统答辩PPT.pptx
课设毕设基于SpringBoot+Vue的养老院管理系统的设计与实现源码可运行.zip
11-04
本压缩包资源说明，你现在往下拉可以看到压缩包内容目录 我是批量上传的基于SpringBoot+Vue的项目，所以描述都一样；有源码有数据库脚本，系统都是测试过可运行的，看文件名即可区分项目~ ｜Java｜SpringBoot｜Vue｜前后端分离｜ 开发语言：Java 框架：SpringBoot，Vue JDK版本：JDK1.8 数据库：MySQL 5.7+（推荐5.7，8.0也可以） 数据库工具：Navicat 开发软件： idea/eclipse（推荐idea） Maven包：Maven3.3.9+ 系统环境：Windows/Mac
基于java的消防物资存储系统答辩PPT.pptx
11-04
基于java的消防物资存储系统答辩PPT.pptx
【java毕业设计】饮食营养管理信息系统源码（springboot+vue+mysql+说明文档）.zip
最新发布
11-04
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
【java毕业设计】酷听音乐源码（springboot+vue+mysql+说明文档）.zip
11-04
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
typedef struct airline { char terminal_name[size];//终点站名 char air_Numer[size];//航班号 char plane_Numer[size];//飞机号 char day[100];//飞行日期 int ticket_price; //机票价格 int Sum_Ticket_Numer;//总位置 int ticket_sur;//余票量 linklist *order;//乘员名单域指向乘员名单链表的头指针 } lineinfo; lineinfo *start; struct airline air_info[MAXSIZE]= { {"北京","K12312","B8571","2021/07/05-13:00--2021/07/05-15:00",509,100,100}, {"上海","D24322","S1002","2021/07/06-13:00--2021/07/06-15:00",529,100,100}, {"伦敦","K35234","L1003","2021/07/07-13:00--2021/07/07-15:00",642,100,100}, {"杭州","D42414","B9571","2021/07/08-13:00--2021/07/08-15:00",322,100,100}, {"武汉","K12314","B3451","2021/07/09-13:00--2021/07/09-15:00",562,100,100}, {"广州","K64124","C3451","2021/07/10-13:00--2021/07/10-15:00",645,100,100}, {"美国","H12412","M3451","2021/07/11-13:00--2021/07/11-15:00",685,100,100} }; start=air_info;
06-13
这段代码定义了一个名为 "airline" 的结构体，其中包含了航班的相关信息，如终点站名、航班号、飞机号、飞行日期、机票价格、总位置、余票量以及乘员名单链表等。同时还定义了一个指向 "airline" 结构体的指针 "start"，并将 "air_info" 数组的首元素的地址赋值给了它。这个数组中包含了多个 "airline" 类型的结构体变量，每个变量表示一个航班的信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值