【数据结构】二分法

最新推荐文章于 2022-12-05 11:40:33 发布
最新推荐文章于 2022-12-05 11:40:33 发布
阅读量393 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/green1997/article/details/125361964
版权

文章目录

1. 从有序数组中找出 num

public class Code04_BSExist {

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

        int l = 0, r = arr.length - 1;
        while (l <= r) {
            // (l + r) / 2 可能会溢出
            int mid = (r - l) / 2 + l;
            if (arr[mid] == num) {
                return true;
            } else if (arr[mid] > num) {
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }

        return false;
    }

    /**
     * 暴力循环查找.
     */
    public static boolean test(int[] arr, int num) {
        for (int val : arr) {
            if (val == num) {
                return true;
            }
        }

        return false;
    }

    /**
     * 随机生成一个数组并排序.
     */
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }

        Arrays.sort(arr);
        return arr;
    }

    public static void main(String[] args) {
        int testTimes = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTimes; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);

            int num = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            if (test(arr, num) != exist(arr, num)) {
                succeed = false;
                break;
            }
        }

        System.out.println(succeed ? "Nice!" : "Oh no!");
    }
}

2. 有序数组中找到 >=num 最左的位置

public class Code05_BSNearLeft {

    public static int mostLeftNoLessNumIndex(int[] arr, int num) {
        if (arr == null || arr.length == 0) {
            return -1;
        }

        // 记录 ans 位置
        int res = -1;
        int l = 0, r = arr.length - 1;
        while (l <= r) {
            int mid = (r - l) / 2 + l;
            if (arr[mid] >= num) {
                res = mid;
                // 有可能 mid 的左侧还有 >=m 的值
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }

        return res;
    }

    /**
     * 暴力循环查找.
     */
    public static int test(int[] arr, int num) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= num) {
                return i;
            }
        }

        return -1;
    }

    /**
     * 随机生成一个数组并排序.
     */
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }

        Arrays.sort(arr);
        return arr;
    }

    public static void main(String[] args) {
        int testTimes = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTimes; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);

            int num = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            if (test(arr, num) != mostLeftNoLessNumIndex(arr, num)) {
                succeed = false;
                break;
            }
        }

        System.out.println(succeed ? "Nice!" : "Oh no!");
    }
}

3. 有序数组中找到 >=num 最左的位置

public class Code05_BSNearRight {

    public static int mostRightNoThanNumIndex(int[] arr, int num) {
        if (arr == null || arr.length == 0) {
            return -1;
        }

        // 记录 ans 位置
        int res = -1;
        int l = 0, r = arr.length - 1;
        while (l <= r) {
            int mid = (r - l) / 2 + l;
            if (arr[mid] <= num) {
                res = mid;
                // 有可能 mid 的左侧还有 >=m 的值
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }

        return res;
    }

    /**
     * 暴力循环查找.
     */
    public static int test(int[] arr, int num) {
        for (int i = arr.length - 1; i >= 0; i--) {
            if (arr[i] <= num) {
                return i;
            }
        }

        return -1;
    }

    /**
     * 随机生成一个数组并排序.
     */
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }

        Arrays.sort(arr);
        return arr;
    }

    public static void main(String[] args) {
        int testTimes = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTimes; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);

            int num = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            if (test(arr, num) != mostRightNoThanNumIndex(arr, num)) {
                succeed = false;
                break;
            }
        }

        System.out.println(succeed ? "Nice!" : "Oh no!");
    }
}

4. 局部最小值问题

1）数组第一个元素比第二个元素小，即为局部最小值。

2）数组最后一个元素比它前一个元素小，即为局部最小值。

3）若不满足，那么局部最小值必可在数组首尾两元素之间的某个位置取得。此时可以采用二分法思想，看中间位置是否符合条件，不符合就分成两部分，从不符合的那一边继续操作。

package lyb.class1;

/**
 * @author liyibin
 * @date 2022-06-20
 */
public class Code06_BSAwesome {

    /**
     * 局部最小 无序数组，相邻的数不相等
     * 边界：
     * arr[0] > arr[1] 下降
     * arr[n-2] < arr[n - 1] 上升
     *
     * 中间 m 就是局部最小值
     * arr[m-1] > arr[m] < arr[m + 2].
     */
    public static int oneMinIndex(int[] arr) {
        if (arr == null || arr.length == 0) {
            return -1;
        }

        if (arr.length == 1) {
            return 0;
        }

        if (arr[0] < arr[1]) {
            return 0;
        }

        if (arr[arr.length - 1] < arr[arr.length - 2]) {
            return arr.length - 1;
        }

        int l = 0, r = arr.length - 1;
        // 保有三个数进行判断
        while (l < r - 1) {
            int mid = (r - l) / 2 + l;
            if (arr[mid] < arr[mid - 1] && arr[mid] < arr[mid + 1]) {
                return mid;
            } else {
                // mid - 1 > mid  mid > mid + 1
                // mid - 1 < mid  mid < mid + 1
                // mid - 1 < mid  mid > mid + 1
                if (arr[mid] > arr[mid - 1]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            }
        }

        return arr[l] < arr[r] ? l : r;
    }

    /**
     * 生成相邻不相等的随机数组.
     */
    public static int[] generateRandomArray(int maxLen, int maxValue) {
        int[] arr = new int[(int) (Math.random() * maxLen) + 1];
        arr[0] = (int) (Math.random() * maxValue);
        for (int i = 1; i < arr.length; i++) {
            do {
                arr[i] = (int) (Math.random() * maxValue);
            } while (arr[i] == arr[i - 1]);
        }

        return arr;
    }

    /**
     * 验证得到的结果，是不是局部最小
     */
    public static boolean test(int[] arr, int index) {
        int l = index - 1;
        int r = index + 1;

        boolean left = l >= 0 ? arr[l] > arr[index] : true;
        boolean right = r < arr.length ? arr[r] > arr[index] : true;

        return left && right;
    }

    public static void main(String[] args) {
        int testTimes = 500000;
        int maxSize = 10;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTimes; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);

            int index = oneMinIndex(arr);
            if (!test(arr, index) ) {
                succeed = false;
                break;
            }
        }

        System.out.println(succeed ? "Nice!" : "Oh no!");
    }
}
movYou521
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二分法（1）
Surge_Pitt的博客
11-07 750
参考：https://www.cnblogs.com/cs-whut/p/11212022.html 在用二分法进行查找时，查找对象的数组必须是有序的，即各数组元素的次序是按其值的大小顺序存储的。 其基本思想是先确定待查数据的范围（可用 [left,right] 区间表示），然后逐步缩小范围直到找到或找不到该记录为止。具体做法是： 1、先取数组中间位置（mid=(left+right)/2）的数据元素与给定值比较。 2、若相等，则查找成功；否则，若给定值比该数据元素的值小（或大），则给定值必在数组的
二分法数据结构
05-30
二分法数据结构
数据结构二分法
qq_44033530的博客
11-20 233
前提：该序列必须为有序序列 #include<stdio.h> void main() { int a[8]={1,2,3,4,5,6,7,8}; int min,max,mid,n; min=0; max=7; scanf("%d",&n); while(min<=max) { mid=(max+min)/2; if(a[mid]>n) max=mid-1; if...
【数据结构】关于二分法
weixin_30519071的博客
03-24 144
二分法 例：假设有一个容量为n+1开始的数组，从小到大存储了n个数(从下标1开始存储)。给定给定数m,求出数组中值为m的元素的下标，如果未找到则返回0。 分析： 以11个数进行分析。 首先令左边界为left=1，右边界为right=11，mid=(left+right)/2 即为6，判断m跟num[6]的大小。 如果num[mid]<m,那么令left=mid...
【数据结构回顾】二分法
Gin.TaMa的博客
07-05 203
普通情况： 给出一个升序的数组 numnumnum，数组长度为 lenlenlen。补全binary_search函数，判断数组num中是否存在元素target，若存在则返回该数字在数组中的 下标，否则返回 −1-1−1。 min 指向头，max 指向尾，mid 为（min + max) / 2 当min >= max 时候终止循环 如果arr[mid] < target , min ...
图解数据结构二分法查找法
12-15
二分法查找法
SongyangJi#JavaBooks#数据结构-二分法1
07-25
二分法思想：在有序列表中，取中间记录作为比较对象，若给定值与中间记录的关键词相等，则查找成功；若给定值小于中间记录的关键词，则在中间记录的左半区继续查找；若给定
C语言版数据结构二分法查找代码
12-27
C语言版数据结构中利用二分查找实现在顺序表的查找。同时包含循序表的插入等操作。
数据结构快速排序二分法查找
11-02
适合有点基础的人使用,于软件水平考试,计算机等级考试等复习使用
数据结构——二分法
Leeyuqq的博客
09-22 682
算法思想： 先设想一个不大于100数，你可以几次猜出。首先猜50，大了；再猜25，小了；再猜······ 代码实现： int fun(int *a, int n, int key) { int low,high,mid; low = 0; high = n-1; while(low <= high) { mid = (low+high)/2; if(key < a[...
数据结构算法——二分法
melon0014的博客
06-01 371
文章目录一、简介1.1 二分查找的前提1.2 模版二、例题2.1 平方根（Leetcode 69） 一、简介 1.1 二分查找的前提 1.2 模版 （背诵！！！） 二、例题 2.1 平方根（Leetcode 69） 注意边界问题，while的边界，结果return的边界，if-else先左先右的讲究。 （由于要求结束在真实结果的左边，所以要取最后崩盘前最后一次mid*mid<x时候的mid值） class Solution(object): def mySqrt(self, x):
数据结构之二分法
nashse的专栏
09-18 462
问：什么时候使用二分法？ 答：
数据结构：二分法的整理
qq_35752161的博客
10-04 272
#include<iostream> #include<Eigen/Dense> #include<map> #include<vector> using namespace std; using namespace Eigen; int main() { int a[7] = { 1,2,3,4,9,10,11 }; int ...
数据结构二分法算法的步骤_数据结构与算法 - 算法详解
weixin_34442022的博客
12-23 1735
最近重新温习了一下数据结构与算法，所以稍作整理，做了个总结，用通俗易懂的语言，满足更多的初学者阅读和学习这方面的知识，希望对大家有所帮助。算法算法的时间复杂度和空间复杂度我们所讲的算法主要分为查找算法和排序算法，这里也经常会提到算法的时间复杂度和空间复杂度，它可以体现算法的性能，那么什么是算法的时间复杂度和空间复杂度呢？时间复杂度：执行算法所需要的计算工作量。它是一个函数，描述了该算法的运行时间，...
数据结构——二分法查找
学习ing的小东东
12-05 1094
用二分法查找首先要将产生的一组随机数排序，然后调用二分查找函数。找到则输出这个数，找不到则输出错误信息。#include <stdio.h> #include <stdlib.h> #define N 100 #define ERROR -1void random_array(int a[],int n) { int i=0; for(i=0;i<n;i++)
[数据结构]二分法查找
南瓜饼
09-06 580
1.最坏情况查找最后一个元素（或者第一个元素）Master定理T(n)=T(n/2)+O(1)所以T(n)=O(logn) 2.最好情况查找中间元素O(1)查找的元素即为中间元素（奇数长度数列的正中间，偶数长度数列的中间靠左的元素） 空间复杂度： S(n)=n public class BinaryTest { public static int binary(int[] arra
数据结构与算法(七) 二分法
半虹小站
12-05 706
这篇文章来讲二分法，这是一种在实际情况中十分常用的算法
20.数据结构——二分法查找（笔记）
枫城雪-----学习空间
05-30 945
什么是搜索算法        搜索是在一个项目集合中找到一个特定项目的算法过程。搜索通常的答案是真的或假的，因为该项目是否存在。 搜索的几种常见方法：顺序查找、二分法查找、二叉树查找、哈希查找。 二分法查找        二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频
数据结构二分法检索
最新发布
05-29
好的，我可以为您解答关于数据结构中二分法检索的问题。二分法检索，也称为折半查找，是一种高效的查找算法。它的基本思想是将有序数组一分为二，然后判断待查找元素在哪一部分，再在相应的部分中继续二分查找，直到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值