算法基础二之二分法与异或运算

最新推荐文章于 2022-08-31 21:20:32 发布
最新推荐文章于 2022-08-31 21:20:32 发布
阅读量225 收藏
点赞数
分类专栏： 算法基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/codingToMaster/article/details/114045503
版权

二分查找 有序数组 异或运算 局部最小值 数组操作
关键词由CSDN通过智能技术生成

二分法：

1）在一个有序数组中，查找某个数是否存在

2）在一个有序数组中，找>=某个数的最左侧的位置

3）在一个有序数组中，找<=某个数最右侧的位置

4）局部最小值问题

 

小技巧：

N/2       N>>1

N*2       N<<1

N*2 + 1     (N<<1) | 1

在一个有序数组中，查找某个数是否存在

package com.zh.class001;

import com.zh.util.SortUtil;

import java.util.Arrays;

public class BSExist {
    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr = SortUtil.generateRandomArray(maxSize, maxValue);
            Arrays.sort(arr);
            int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            if (test(arr, value) != exist(arr, value)) {
                succeed = false;
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    }

    // for test
    public static boolean test(int[] sortedArr, int num) {
        for(int cur : sortedArr) {
            if(cur == num) {
                return true;
            }
        }
        return false;
    }

    public static boolean exist(int[] arr, int num) {
        if (arr == null || arr.length == 0) {
            return false;
        }
        int left = 0;
        int right = arr.length - 1;
        int mid = 0;

        while (left < right) {
            mid = left + ((right - left) >> 1);
            if (arr[mid] == num) {
                return true;
            } else if (arr[mid] > num) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return arr[left] == num;
    }
}

在一个有序数组中，找>=某个数的最左侧的位置

package com.zh.class001;

import com.zh.util.SortUtil;

import java.util.Arrays;

public class BSNearLeft {
    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr = SortUtil.generateRandomArray(maxSize, maxValue);
            Arrays.sort(arr);
            int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            if (test(arr, value) != nearleftIndex(arr, value)) {
                SortUtil.printArray(arr);
                System.out.println(value);
                System.out.println(test(arr, value));
                System.out.println(nearleftIndex(arr, value));
                succeed = false;
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    }
    // 在arr上，找满足>=value的最左位置
    public static int nearleftIndex(int[] arr, int value) {
        int left = 0;
        int right = arr.length - 1;
        int index = -1;

        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (arr[mid] >= value) {
                index = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return index;
    }

    // for test
    public static int test(int[] arr, int value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= value) {
                return i;
            }
        }
        return -1;
    }
}

在一个有序数组中，找<=某个数最右侧的位置

package com.zh.class001;

import com.zh.util.SortUtil;

import java.util.Arrays;

public class BSNearRight {
    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr = SortUtil.generateRandomArray(maxSize, maxValue);
            Arrays.sort(arr);
            int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            if (test(arr, value) != nearRightIndex(arr, value)) {
                SortUtil.printArray(arr);
                System.out.println(value);
                System.out.println(test(arr, value));
                System.out.println(nearRightIndex(arr, value));
                succeed = false;
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    }
    // 在arr上，找满足<=value的最右位置
    public static int nearRightIndex(int[] arr, int value) {
        int left = 0;
        int right = arr.length - 1;
        int index = -1;

        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (arr[mid] > value) {
                right = mid - 1;
            } else {
                index = mid;
                left = mid + 1;
            }
        }
        return index;
    }

    // for test
    public static int test(int[] arr, int value) {
        for (int i = arr.length - 1; i >= 0; i--) {
            if (arr[i] <= value) {
                return i;
            }
        }
        return -1;
    }
}

局部最小值问题

条件：无序数组，任意两个相邻的数字都不相等

package com.zh.class001;

/**
 *
 * 找出局部最小
 */
public class BSAwesome {
    public static int getLessIndex(int[] arr) {
        if (arr == null || arr.length == 0) {
            return -1; // no exist
        }
        if (arr.length == 1 || arr[0] < arr[1]) {
            return 0;
        }
        if (arr[arr.length - 1] < arr[arr.length - 2]) {
            return arr.length - 1;
        }
        int left = 1;
        int right = arr.length - 2;
        int mid = 0;
        while (left < right) {
            mid = (left + right) / 2;
            if (arr[mid] > arr[mid - 1]) {
                right = mid - 1;
            } else if (arr[mid] > arr[mid + 1]) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return left;
    }
}

异或运算

好记的方法：无进位相加

异或运算的性质：

1)0^N == N    N ^ N == 0

2)异或运算满足交换律和结合律

题目一如何不用额外变量交换两个数

a = a ^ b;
b = a ^ b;
a = a ^ b;
public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = -100;

        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
        
        System.out.println("a:" + a);
        System.out.println("b:" + b);
    }
}

a:-100
b:10

public class Test {
    public static void main(String[] args) {

        int[] arr = {3, 1, 100};
        swap(arr, 0, 2);
        System.out.println(Arrays.toString(arr));

    }

    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

}

[100, 1, 3]

注意：交换可以是相同的值，但是必须是不同的内存区域，否则会变成0

public class Test {
    public static void main(String[] args) {

        int[] arr = {3, 1, 100};
        swap(arr, 0, 0);
        System.out.println(Arrays.toString(arr));

    }


    public static void swap(int a, int b) {
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
        System.out.println("a:" + a);
        System.out.println("b:" + b);
    }
}

[0, 1, 100]

题目二 一个数组中有一种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这种数

运用上面的异或性质，相同的数异或后为0.0异或上一个数，不变。可以将所有的数异或，得到的数，就是奇数次出现的数

public class EvenTimesOddTimes {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 1, 2, 3, 4, 1};
        printOddTimesNum1(arr);
    }
    // arr中，只有一种数，出现奇数次
    public static void printOddTimesNum1(int[] arr) {
        int eor = 0;
        for (int i = 0; i < arr.length; i++) {
            eor ^= arr[i];
        }
        System.out.println(eor);
    }
}

1

题目三 怎么把一个int类型的数，提取出最右侧的1来

 提示：N & ((~N) + 1)

// 怎么把一个int类型的数，提取出最右侧的1来   
 public static int getRightOne(int num) {
        return num & (~num + 1);
    }

题目四 一个数组中有两种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这两种数。

    // arr中，有两种数，出现奇数次
    public static void printOddTimesNum2(int[] arr) {
        int eor = 0;
        for (int num : arr) {
            eor ^= num;
        }

        // 提取最右侧的1
        int rightOne = eor & (~eor + 1);
        int onlyOne = 0;
        for (int num : arr) {
            if ((num & rightOne) != 0) {
                onlyOne ^= num;
            }
        }
        System.out.println(onlyOne + " " + (eor ^ onlyOne));
    }

推广题目：

一个数组中有一种数出现K次，其他数都出现了M次，M>1，K<M找到，出现了K次的数，要求，额外空间复杂度O(1)，时间复杂度O(N)

思路：将每个数转化为二进制，那么int数字可以转化为32大小的数组，因此定义32大小的数组，用来计算每个位置上1的个数和。

如果i位置上1的个数和可以整除M，那么此处出现K次的数，必定不为1，否则为1。

将所有出现K次的数字，为1的位置全部找出来，就可以组成这个数的二级制表示，进而计算出数字。

package com.zh.class001;

import java.util.HashMap;
import java.util.Map;

/**
 * 一个数组中有一种数出现K次，其他数都出现了M次，M>1，K<M找到，
 * 出现了K次的数，要求，额外空间复杂度O(1)，时间复杂度O(N)
 *
 */
public class KTimesNum {
    private static final int K = 1;
    private static final int M = 3;
    public static void main(String[] args) {
        int[] arr = {1, 1, 1, 2, 2, 2, 3, 3, 3, 0, 0};
        System.out.println(onlyKTimesNUms(arr, K, M));
        System.out.println(test(arr, K, M));
    }
    public static int onlyKTimesNUms(int[] arr, int k, int m) {
        int[] bitSum = new int[32];

        for (int num : arr) {
            for (int i = 0; i < 32; i++) {
                if (((num >> i) & 1) != 0) {
                    bitSum[i]++;
                }
            }
        }

        int res = 0;
        for (int i = 0; i < 32; i++) {
            if (bitSum[i] % m == 0) {
                continue;
            }
            if (bitSum[i] % m == k) {
                res |= (1 << i);
            } else {
                return -1;
            }
        }

        int zeroCount = 0;
        if (res == 0) {
            for (int num : arr) {
                if (num == 0) {
                    zeroCount++;
                }
            }

            if (zeroCount != k) {
                return -1;
            }
        }
        return res;
    }

    public static int test(int[] arr, int k, int m) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : arr) {
            if (map.containsKey(num)) {
                map.put(num, map.get(num) + 1);
            } else {
                map.put(num, 1);
            }
        }

        for (int key : map.keySet()) {
            if (map.get(key) == k) {
                return key;
            }
        }
        return -1;

    }
}

 

题目五 找出二进制1的个数

    public static int bit1Count(int num) {
        int count = 0;
        while (num != 0) {
            int rightOne = num & (~num + 1);
            count++;
            num ^= rightOne;
        }
        return count;
    }

 

 

给自己加加油
关注
专栏目录
基础算法题——异或（复杂度的小差异）
Zhengyangxinn的博客
11-01 557
异或 题目描述 给定一个长度为 n 初始全为 0 的数列 ai，下标从 1 开始。定义操作模 k 异或 v 为对所有满足 ki≡0(mod k) 的下标 i，将异或上整数v（即令 ai = ai⊕v）。 给出q次操作，每次操作之后输出序列的异或和，并且在操作结束之后输出整个序列。 序列的异或和为 a 1⊕a 2⊕…⊕an 输入描述: 第一行两个整数n,q。 接下来q行，每行两个整数 ki, vi。 1 ≤ n, q ≤ 2×105 1 ≤ ki, vi ≤ 109 输出描述: 输出共q+1行，其中前q行每
1对数器二分法异或运算
huaikong2020
01-16 158
时间复杂度 选择排序、冒泡排序、插入排序 //选择排序 public static void selectionSort(int[] arr){ if(arr == null ||arr.length < 2){ return; } for(int i = 0;i < arr.length;i++){ int minIndex = i; for(int j = i + 1;j
对数器二分法异或
LoveLSD的博客
06-04 372
这里写目录标题对数器二分法有序数组中，找某个数是否存在有序数组中，找>=某个数最左侧的位置有序数组中，找<=某个数最右侧的位置认识异或运算 对数器 1.你想要测的方法a 2.实现复杂度不好但是容易实现的方法b 3.实现一个随机样本产生器 4.把方法a和方法b跑相同的随机样本，看看得到的结果是否一样 5.如果有一个随机样本使得比对结果不一致，打印样本进行人工干预，改对方法a和方法b 6.当样本数量很多时比对测试依然正确，可以确定方法a已经正确。 三个可以参考的对数器： package duis
二分法与异或的使用
qq_56893858的博客
09-22 142
异或的使用： 概念：相同为0，不相同为1 （简单记忆：不进位相加即为异或） 比如说： 00011010 （异或） 10010100 = 10001110 [danger]用法：a^0 = a a^a=0 a^a^a=a[/danger] 实例： 一、两个数互换 (a,b) 则可以这样操作：a = a ^ b , b = a^b (此时得到b等于a) , a = a ^ b(此时得到a等于b) 二、找到一个数组中唯一为奇次数的哪个数 [ 1,1,2] 此时唯一为奇...
探索数据结构与算法——如何运用异或，二分解题
Shany_Ming的博客
04-20 912
📔 前言 数据结构与算法如今在工作面试中占很高的比重，为了学好算法，大多数人都会去看各种书籍与视频，然后去做题，以做leetcode为例，没学算法前，你可能可以做些简单题，中等题也会一部分，学过数据结构与算法后，你可能发现自己会的中等题变多了，但依然有许多题无从下手，想暴力可时间过不了，此类情况就是无法将所学结合起来，没想到能用学过的方法解题，接下来，我们就来通过题目，剖析异或与二分。 📘 异或 异或作为位运算的一种，其运算方法为：相同（1与1，0与0）为0，相异为1 📑 例题引入 交换两个
左神算法笔记: 1. 认识复杂度、对数器、二分法与异或运算
fc625的博客
12-11 354
#algorithem/左神算法/基础 #sorting #XOR 评估算法优劣的核心标准 时间复杂度（流程决定） 额外空间复杂度（流程决定） 常数项时间（实现细节决定） 常数时间的操作 算数运算-加减乘除 位运算（ >>[带符号右移]/ >>>[不带符号右移]/ <</ |/ &/ ^） 赋值、比较、自增、子减 数组寻址 三种排序 选择排序：遍历整个数组找最大，放在最后 冒泡排序：相邻的两个数比较谁大谁放在后面 插入排序：第k次循环的时候
算法基础01-复杂度、排序、二分、异或
weixin_42503072的博客
01-28 639
文章目录1 时间复杂度、空间复杂度、排序、异或运算1.1 时间复杂度1.1.1 排序操作1.1.1.1 选择排序1.1.1.2 冒泡排序1.1.1.3 插入排序1.2 空间复杂度1.3 常数项时间复杂度1.4 算法最优解1.5 常见时间复杂度1.6 算法和数据结构脉络1.7 认识对数器1.8 认识二分法1.9 认识异或运算 1 时间复杂度、空间复杂度、排序、异或运算 1.1 时间复杂度 常数时间操作： 算数运算：+ - * / 位运算：>>（带符号右移动）、 >>>（不带
算法数据结构学习视频教程，算法和数据结构的基础概念、进阶技巧以及特定算法的应用和实现
最新发布
03-26
第3节 异或运算相关面试题.mp4 第4节 一些基础的数据结构.mp4 第5节 归并排序及其相关面试题.mp4 第6节 归并排序附加题、随机快速排序.mp4 第7节 堆和堆排序.mp4 第8节 加强堆.mp4 第9节 前缀树、不基于比较的排序、...
（Java）算法基础1：时间复杂度/位运算/选择，冒泡，插入排序/对数器/二分
m0_46266264的博客
03-24 1327
时间复杂度 下图就是选择排序时间复杂度，N平方，O（N^2） 时间复杂度就是常数操作数量的表达式：aN^2+bn+c，只要最高阶项.为什么会只算N平方，因为都是考虑数据量起来以后的情况。 选择排序与冒泡排序 选择排序 比方一个数组【4，2，3，1】，将其按照从小到达排列 其实就是先从第一个开始遍历，找到一个最小值放到首位，然后从第二个开始遍历，找到第二小的数放到第二位，以此类推 package class01; import java.util.Arrays; public class Code0
java 二维数组排序算法二分法
qq_43382750的博客
06-29 384
Java传递 传值:传基本数据类型 传引用:引用类型的传递,传地址 //值传递,原数据不受影响(栈内存中两个方法同时运行互不影响) //传引用,原数据跟着改变(传的是栈内存中的地址,通过地址改变堆内存中的数据后也就是改的原数据) 如下图左边是栈内存右边是堆内存 public static void main(String[] args) { int i = 10; m1(i); System.out.pri...
异或运算算法相关
Re-moved
12-07 2190
O(N)的寻找算法~
C语言之数组数字异或
zhangxu
01-31 4296
接着上次我们讨论的在一组数字中找出一个只出现一次的数，这次我们加大难度，在一组数字中找出两个只出现一次出现一次的数字。题目具体内容如下：一个数组中只有两个数字是出现一次， 其他所有数字都出现了两次。 找出这两个数字，编程实现。 例如：int arr[] = {1,2,4,5,3,5,1,2} 这组数中出现一次的数字位3和4. 思路：在上面这组数中如何找出3和4呢？我们知道这组数...
Codeforces 1722G 结论：异或性质
stdforces的博客
08-31 232
异或
给定的数是否为数组两元素之和
tianyingang的博客
07-25 276
//给定n个整数的集合Ｓ和另一个整数x，该算法能确定是否存在两个数之和等于x #include <stdio.h> #include <stdbool.h> #include <malloc.h> int merge(int * objary,unsigned int index_start,unsigned int index_middle,unsigne...
[二分法]二分法的常见题型
ltcz99的博客
11-16 724
认识二分法 经常见到的类型是在一个有序数组上，开展二分搜索，但有序真的是所有问题求解时使用二分的必要条件吗？ 只要能正确构建左右两侧的淘汰逻辑，你就可以二分。 二分常见题型 1>在一个有序数组中，找某个数是否存在 public static boolean exist(int[] sortedArr, int num) { if (sortedArr == null || sortedArr.length == 0) { return false; } int L =.
在一个有序数组中,找＞=某个数最左侧的位置
Harrison的学习博客
11-22 346
package com.harrison.Class01; import java.util.Arrays; public class Code05_BSNearLeft { public static int nearestIndex(int[] arr,int value) { int l=0; int r=arr.length-1; int mid=0; int index=-1; while(l<=r) { mid=l+((r-l)>>1);
3.二分算法
weixin_59868842的博客
03-28 652
1.二分法 1.1简单的二分法 package class03; import java.util.Arrays; /** * 使用二分法找到有序数组中的一个数*/ public class Code01_BSExist { // arr保证有序 public static boolean find(int[] arr, int num) { //边界条件 if (arr == null || arr.length == 0) { return false; } //
LeetCode题解——数组中两个数的最大异或值
yxh_1_的博客
05-16 461
LeetCode题解——数组中两个数的最大异或值 题目介绍 解题思路 第一种暴力解法，双重循环时间复杂度O(n2)，不符合题目要求。 第二种字典树，我们先要知道一点，异或就是相同为0，否则为1，那么我们随机给出一个数nums[i]怎么让它的异或结果最大呢，是不是要选择一个和num[i]二进制位数基本相反的，就是你是1，那我就选0 比如nums[i]= 00101,那么是不是选择一个11010的数和它异或结果最大 那么如何找到这个值呢，可以通过字典树来完成，树的左为0，右分支为1 我们先把nu.
判断数组中是否存在两数之和为给定值
码出你的世界
12-20 1728
尽可能小的时间复杂度判断数组中是否存在两元素质和为给定值
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值