一文搞懂【搜索算法 - 二分查找】

于 2024-05-23 06:14:37 发布
阅读量894 收藏 22
点赞数 13
分类专栏： 数据结构与算法 Java 技术栈 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duleilewuhen/article/details/139133860
版权

在这里插入图片描述

文章目录

把今天最好的表现当作明天最新的起点……．～

引言

  当遇到查找特定元素的时候，最容易想到的就是暴力解法：直接遍历。这种做法简单粗暴，可以解题，但是时间复杂度过高，所以我们可以用二分法来提高效率。我周围的人几乎都认为二分查找很简单，但事实真的如此吗？二分查找真的很简单吗？并不简单。个人认为其可以这样理解：思路很简单，细节是魔鬼。

一、基本查找

  在开始之前，先让我们来了解一下什么是基本查找。基本查找，也称之为线性查找、顺序查找。其算法核心就是 从0索引开始挨个往后查找，如果找到了，就给出下标值。利用基本查找，可以查询某个元素是否存在。例如，在n个元素的数组array中寻找特定的数字num，采用顺序查找法，代码实现如下所示：

public class SearchAlgorithm {

    public static void main(String[] args) {
        int[] numArray = {34, 56, -57, 68, 346, 345, 35, 23, 123, 40};
        System.out.println("下标为：" + search(numArray, number));
    }

    public static int search(int[] numArray, int number) {
        for (int i = 0; i < numArray.length; i++) {
            if (numArray[i] == number) {
                return i;
            }
        }
        return -1;
    }
}

二、二分查找算法

2.1 算法介绍

  大家都应该玩过猜数字的游戏吧！给定一个数字的范围随机抽取一个数字，然后玩家轮流猜数字，猜错时告诉玩家结果数字是大于猜测数字还是小于。那么，该怎么猜数字最快得出答案呢？当然就是折半查找了。为什么说这样效率最高呢？因为每一次选择数字，无论偏大还是偏小，都可以让剩下的选择范围缩小一半。例如，给定范围0到1000的整数，第一次我们选择500，发现偏大了，那么下一次的选择范围，就变成了1到499，如下图所示：
在这里插入图片描述

  第二次我们选择250，发现还是偏大了，那么下一次的选择范围，就变成了1到249，如下图所示：
在这里插入图片描述

  第三次我们选择125，发现偏小了，那么下一次的选择范围，就变成了126到249，如下图所示：
在这里插入图片描述

  以此类推，直到最终找到想要的元素，或者选择范围等于0为止。上述这个过程，就是所谓的二分查找算法了。
  二分查找，故此也称为折半查找（Binary Search），是一种效率较高的查找方法。它要求线性表必须采用顺序存储结构，且表中元素按关键字有序排列。二分查找的基本思想是将n个元素分成大致相等的两部分，通过比较中间元素与目标值，不断缩小查找范围，直至找到目标值或确定目标值不存在于数组中。

注：使用二分查找的前提条件是，数组已经是有序的。

2.2 算法实现

  二分查找是一种高效的搜索算法，其原理是假设数组中元素是按升序排列，不断将查找范围逐渐减半，快速定位目标元素，直到找到目标元素或确定目标元素不存在。算法思路如下：

  1. 确定搜索范围：首先确定整个有序数组的搜索范围，即左边界和右边界。通常初始时左边界为数组的第一个元素索引，右边界为数组的最后一个元素索引。
  2. 计算中间元素：计算左边界和右边界的中间索引，可以使用 (low + high) / 2 进行计算，查找到目标列表的中间元素，这个中间元素将用于与目标元素进行比较。
  3. 比较与目标元素：
    • 如果目标元素等于中间元素，则找到了目标，返回中间元素的索引。
    • 如果目标元素小于中间元素，则说明目标可能在左半边，更新右边界为中间元素的前一个索引。
    • 如果目标元素大于中间元素，则说明目标可能在右半边，更新左边界为中间元素的后一个索引。
    • 如果在某一步骤数组为空，则代表要查找的元素不在目标列表中。
  4. 缩小搜索范围：根据上一步的比较结果，缩小搜索范围。
    • 如果目标在左半边，就在左半边继续进行二分查找；
    • 如果目标在右半边，就在右半边继续进行二分查找。
    • 重复这个过程，不断缩小搜索范围，直到找到目标元素或搜索范围为空。
  5. 重复步骤：重复执行步骤 2 到步骤 4，直到找到目标元素或搜索范围为空。如果搜索范围为空，说明目标元素不存在于数组中。

  以有序数组 {10, 14, 19, 26, 27, 31, 33, 35, 42, 44} 、查找元素 33为例，逐步图解何为二分查找，如下所示：

  1. 初始状态：

在这里插入图片描述

  1. 第一轮查找：根据 27<33，可以判定 33 位于 27 右侧的区域，更新搜索区域为元素 27 右侧的区域。

在这里插入图片描述

在这里插入图片描述

  1. 第二轮查找：35>33，可以判定 33 位于 35 左侧的区域，更新搜索区域。

在这里插入图片描述

在这里插入图片描述

  1. 第三轮查找：31<33，可以判定 33 位于 31 右侧的区域，更新搜索区域。

在这里插入图片描述

在这里插入图片描述

  1. 第四轮查找：搜索区域内中间元素的位置是 [(7+7)/2]=7，因此中间元素是 33，此元素就是要找的目标元素。

在这里插入图片描述

2.3 代码实现

  二分查找并不是只是简简单单的去判断一个数组中是否存在目标值，它是一种解决问题的思想。算法的核心是在于利用二分思想，每次都与区间的中间数据比对大小，缩小查找区间的范围。算法的思路就是设定两个指针start、end 分别指向数组元素的首、尾两端，然后比较数组中间结点和待查找元素。如果待查找元素小于中间元素，那么表明带查找元素在数组的前半段，那么将 end=mid-1；如果待查找元素大于中间元素，那么表明该元素在数组的后半段，将 start=mid+1；如果中间元素等于待查找元素，那么返回mid的值。
  简单的二分查找算法的代码如下：

public class SearchAlgorithm {
    
    public static void main(String[] args) {
        int[] numArray = {2, 4, 5, 7, 9, 11, 16, 23, 45, 67};
        System.out.println("元素【2】下标为：" + binarySearch(numArray, 5));
        System.out.println("元素【23】下标为：" + binarySearch(numArray, 23));
        System.out.println("元素【1】下标为：" + binarySearch(numArray, 1));
        System.out.println("元素【110】下标为：" + binarySearch(numArray, 110));
    }

    public static int binarySearch(int[] numArray, int target) {
        if (numArray == null || numArray.length == 0) {
            return -1;
        }
        // 通过 start、end来表示当前搜索范围的左右边界。初始时，start 指向数组的第一个元素索引，end 指向数组的最后一个元素索引。
        int start = 0, end = numArray.length - 1;
        while (start <= end) {
            // 计算出当前搜索范围的中间索引 mid，这个中间索引对应的元素就是我们要和目标元素进行比较的值。
            int middle = start + (end - start) / 2;
            // 用 middle 指向的元素和要查找的元素进行比较。
            if (numArray[middle] > target) {
                // 如果大于要查找的值，那说明要查找的元素在[start, middle-1]之间
                end = middle - 1;
            } else if (numArray[middle] < target) {
                // 如果小于要查找的值，那要查找的值肯定在[middle+1, end]之间
                start = middle + 1;
            } else {
                // 如果等于，则找到目标值，直接返回下标
                return middle;
            }
        }
        // 如果循环结束仍未找到目标元素，返回-1，表示未找到
        return -1;
    }
}

  二分查找算法除了用上面的循环实现，实际上还可以用递归实现。简单二分查找算法的递归代码如下：

public class SearchAlgorithm {
    public static void main(String[] args) {
        int[] numArray = {10, 14, 19, 26, 27, 31, 33, 35, 42, 44};
        int number = 33;
        System.out.println("下标为：" + binarySearch(numArray, number, 0, numArray.length - 1));
    }

    public static int binarySearch(int[] numArray, int target, int start, int end) {
        if (numArray == null || start > end || target < numArray[start] || target > numArray[end]) {
            return -1;
        }
        int center = start + (end - start) / 2;
        if (numArray[center] == target) {
             // 如果等于，则找到目标值，直接返回下标
            return center;
        } else if (numArray[center] < target) {
            // 如果小于，则去右半边继续找
            return binarySearch(numArray, target, center + 1, end);
        } else {
            // 如果大于，则去左半边继续找
            return binarySearch(numArray, target, start, center - 1);
        }
    }
}

  上述的是二分查找的最基础、最基本的形式，这是一个标准的二分查找，用于查找可以通过访问数组中的单个索引来确定的元素。

2.4 算法复杂度

  二分类似于猜数字游戏，每次都猜给定区间的中间值，但是前提条件是此序列已经排好序了。如果猜小了，下一次就到右区间猜；如果猜大了，下次就到左区间猜。这样逐渐逼近正确的结果，每次缩小一半的范围，因此 二分查找的时间复杂度是O(log(n))，最坏情况下的时间复杂度是O(n)，其中 n 是数组的长度。

三、算法示例

  根据前文实现的简单二分查找代码，我们知道区间的中间元素跟要查找的元素的大小关系有三种情况：大于、小于、等于。对于中间元素大于要查找的元素的情况，我们需要更新 high= mid-1；对于中间元素小于要查找的元素的情况，我们需要更新 low=mid+1。这两点和简单二分查找代码一样，但是当中间元素等于要查找的元素时，二分查找算法的变形有着不同的处理形式，毕竟不同的人有着不同的解决方法嘛！

3.1 查找第一个值等于给定值的元素

  要使用二分查找算法来查找第一个值等于给定值的元素，我们可以在标准的二分查找算法上进行一些修改。具体来说，当我们在数组中找到一个等于目标值的元素时，我们不会立即返回，而是继续向左搜索，以确保我们找到的是第一个这样的元素。以下是一个Java方法的示例，它使用二分查找来查找第一个值等于给定值的元素的索引：

public class SearchAlgorithm {
    public static void main(String[] args) {
        int[] numArray = {2, 4, 5, 9, 11, 16, 16, 45, 67};
        int number = 116;
        System.out.println("查找第一个值等于【" + number + "】的元素下标：" + binarySearch(numArray, number));
    }

    public static int binarySearch(int[] numArray, int target) {
        if (numArray == null || numArray.length == 0) {
            return -1;
        }
        int start = 0, end = numArray.length - 1, result = -1;
        while (start <= end) {
            int middle = start + (end - start) / 2;
            if (numArray[middle] > target) {
                end = middle - 1;
            } else if (numArray[middle] < target) {
                start = middle + 1;
            } else {
                result = middle;
                end = middle - 1;
            }
        }
        return result;
    }
}

  在这个示例中，binarySearch方法使用二分查找算法来查找目标值在数组中的第一个出现位置。当我们找到一个等于目标值的元素时，我们更新结果result并继续向左搜索，直到start大于end，此时我们已经搜索了整个可能包含目标值的区域。

3.2 查找最后一个值等于给定值的元素

  要利用二分查找算法来查找最后一个值等于给定值的元素，我们可以在标准的二分查找算法上进行修改。当找到一个等于目标值的元素时，我们不会立即返回，而是继续向右搜索，以确保找到的是最后一个这样的元素。以下是一个Java方法的示例，它使用二分查找来查找最后一个值等于给定值的元素的索引：

public class SearchAlgorithm {
    public static void main(String[] args) {
        int[] numArray = {2, 4, 5, 9, 11, 16, 16, 45, 67};
        int number = 16;
        System.out.println("查找最后一个值等于【" + number + "】的元素下标：" + binarySearch(numArray, number));
    }

    public static int binarySearch(int[] numArray, int target) {
        if (numArray == null || numArray.length == 0) {
            return -1;
        }
        int start = 0, end = numArray.length - 1, result = -1;
        while (start <= end) {
            int middle = start + (end - start) / 2;
            if (numArray[middle] > target) {
                end = middle - 1;
            } else if (numArray[middle] < target) {
                start = middle + 1;
            } else {
                result = middle;
                start = middle + 1;
            }
        }
        return result;
    }
}

  在这个示例中，binarySearch方法使用二分查找算法来查找目标值在数组中的最后一个出现位置。当我们找到一个等于目标值的元素时，我们更新结果result并继续向右搜索，直到start大于end，此时我们已经搜索了整个可能包含目标值的区域。

3.3 查找第一个值大于等于给定值的元素

  要利用二分查找算法来查找第一个值大于等于给定值的元素，我们可以在标准的二分查找算法上进行修改。当找到一个元素大于等于目标值时，我们需要确保它是第一个这样的元素，这通常意味着我们需要向左检查以确保没有更小的元素也满足条件。但是，由于我们只需要找到第一个这样的元素，一旦我们找到一个满足条件的元素，我们就可以停止搜索了。以下是一个Java方法的示例，它使用二分查找来查找第一个值大于等于给定值的元素的索引：

public class SearchAlgorithm {
    public static void main(String[] args) {
        int[] numArray = {2, 4, 5, 9, 11, 16, 16, 16, 45, 67};
        int number = 46;
        int index = binarySearch(numArray, number);
        System.out.println("查找第一个大于等于【" + number + "】的元素下标：" + (index > -1 ? numArray[index] : index));
    }

    public static int binarySearch(int[] numArray, int target) {
        if (numArray == null || numArray.length == 0) {
            return -1;
        }
        int start = 0, end = numArray.length - 1, result = -1;
        while (start <= end) {
            int middle = start + (end - start) / 2;
            if (numArray[middle] >= target) {
                // 找到第一个大于等于目标值的元素，但可能不是最左边的，尝试向左搜索，看是否有更小的元素也满足条件
                result = middle;
                end = middle - 1;
            } else {
                start = middle + 1;
            }
        }
        return result;
    }
}

  在这个示例中，binarySearch方法使用二分查找算法来查找第一个值大于等于给定值的元素的索引。一旦找到一个元素满足条件，我们检查它是否是第一个这样的元素（即它左边的元素是否小于目标值）。如果是，我们返回该元素的索引；如果不是，我们继续向左搜索。

3.4 查找最后一个值小于等于给定值的元素

  要利用二分查找算法来查找最后一个值小于给定值的元素，我们需要在标准的二分查找算法上进行一些调整。基本思路是，当我们找到一个元素小于目标值时，我们应该继续向右搜索，直到找到一个不满足条件的元素（即大于或等于目标值的元素）为止，然后返回上一个访问的元素的索引，它必然是最后一个小于目标值的元素。以下是一个Java方法的示例，它使用二分查找来查找最后一个值小于给定值的元素的索引：

public class SearchAlgorithm {
    public static void main(String[] args) {
        int[] numArray = {2, 4, 5, 9, 11, 16, 45, 67};
        int number = 46;
        int index = binarySearch(numArray, number);
        System.out.println("查找最后一个值小于等于【" + number + "】的元素下标：" + (index > -1 ? numArray[index] : index));
    }

    public static int binarySearch(int[] numArray, int target) {
        if (numArray == null || numArray.length == 0) {
            return -1;
        }
        int start = 0, end = numArray.length - 1, result = -1;
        while (start <= end) {
            int middle = start + (end - start) / 2;
            if (numArray[middle] > target) {
                end = middle - 1;
            } else {
                result = middle;
                start = middle + 1;
            }
        }
        return result;
    }
}

3.5 查找多个值等于给定值的元素

  二分查找算法通常用于在一个已排序的数组中查找一个特定的元素，若是想要查找多个值等于给定值的元素，实际上是在查找一个值域。首先，可以使用二分查找来找到该值的第一个出现位置，然后从这个位置开始向后搜索，直到找到该值的最后一个出现位置。以下是一个Java方法的示例，它使用了二分查找来找到给定数组中所有等于给定值的元素的起始和结束索引：

public class SearchAlgorithm {
    public static void main(String[] args) {
        int[] numArray = {2, 4, 5, 9, 11, 16, 45, 67};
        int target = 1;
        int[] range = findRange(numArray, target);

        // // 初始化范围数组，-1 表示未找到
        if (range[0] != -1 && range[1] != -1) {
            System.out.println("数组范围: [" + range[0] + ", " + range[1] + "]");
        } else {
            System.out.println("在数组中找不到值。");
        }
    }

    public static int[] findRange(int[] numArray, int target) {
        int[] range = {-1, -1};
        if (numArray == null || numArray.length == 0) {
            return range;
        }
        // 查找第一个等于 target 的元素的索引
        int left = findFirstIndex(numArray, target);
        // 如果找到了第一个元素，则继续查找最后一个元素
        if (left != -1) {
            int right = findLastIndex(numArray, target, left);
            range[0] = left;
            range[1] = right;
        }
        return range;
    }

    /**
     * 使用二分查找找到第一个等于 target 的元素的索引
     */
    private static int findFirstIndex(int[] numArray, int target) {
        int start = 0, end = numArray.length - 1, firstIndex = -1;
        while (start <= end) {
            int middle = start + (end - start) / 2;
            if (numArray[middle] >= target) {
                end = middle - 1;
                firstIndex = numArray[middle] == target ? middle : firstIndex;
            } else {
                start = middle + 1;
            }
        }
        return firstIndex;
    }

    /**
     * 从给定索引开始向后查找，找到最后一个等于 target 的元素的索引
     */
    private static int findLastIndex(int[] numArray, int target, int startIndex) {
        int end = numArray.length - 1, lastIndex = startIndex;
        while (startIndex <= end) {
            if (numArray[startIndex] == target) {
                lastIndex = startIndex;
                startIndex++;
            } else {
                break;
            }
        }
        return lastIndex;
    }
}

四、结语

  二分查找是一种高效的、适用于有序数组中查找某一特定元素的搜索算法，有点类似分治思想。即每次都通过跟区间中的中间元素对比，将待查找的区间缩小为一半，直到找到要查找的元素，或者区间被缩小为 0。它的时间复杂度为 O(log n)，其中 n 是数组的长度。由于每次迭代都将搜索范围减半，因此它比线性查找算法更加高效，特别是对于大型有序数组。通过仔细实现和理解二分查找算法，可以帮助我们在 Java 中轻松应用它来解决各种查找问题。
  不过它的缺陷却也是那么明显的，就是数据必须是有序的，而我们很难保证我们的数组都是有序的。如果数据是乱的，先排序再用二分法查找得到的索引没有意义，只能确定当前数字在数组中是否存在，因为排序后的数字位置发生了变化。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

独泪了无痕
关注
  • 13
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
一文搞懂Raft算法
01-27
直到看到raft的论文，两位研究者也提到，他们也花了很长的时间来理解Paxos，他们也觉得很难理解，于是研究出了raft算法。raft是一个共识算法（consensusalgorithm），所谓共识，就是多个节点对某个事情达成一致的...
一文看懂ARM Cortex-M处理器
01-19
ARM Cortex-M处理器家族现在有8款处理器成员。在本文中，我们会比较Cortex-M系列处理器之间的产品特性，重点讲述如何根据产品应用选择正确的Cortex-M处理器。本文中会详细的对照Cortex-M 系列处理器的指令集和中断...
一文读懂业务流程再造-BPR.pdf
07-14
一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造-BPR一文读懂业务流程再造
算法-二分查找
qq754261595的博客
05-07 145
待写
【算法】二分查找
Martian
07-08 196
二分查找是比较常用且高效的查找算法，原理是给定一个有序数组和待查找target，利用分治思想进行搜索。 默认数组是升序，时间复杂度O(logn)，空间复杂度O(1) &amp;lt;?php #二分查找 function BinarySearch(Array $arr, $target) { $length = count($arr); if (!is_...
算法 二分查找
笑笑的博客
08-24 100
public class search { public static void main(String[] args) { int[] a = {1, 4, 5, 6, 8, 9}; int ret = binary(a, 9); System.out.println(ret); } public static ...
查找算法—二分查找
hahachenchen789的博客
10-15 590
假设表中元素是有序的，将表的中间位置的关键字与所需的关键字比较，相等则成功，否则分为前后两个子表，若所需的值大于中间元素，则在后半部分查找，否则在前半部分查找。重复上述过程，直到查询到结果。   优点：比较次数少，速度快 缺点：要求待查表为有序表。   时间复杂度：O(h)=O(log2n)   c/c++代码实现： 方法一：循环   int binsearch(SeqLis...
二分查找算法
艾笑的博客
07-08 3329
仅仅作为自己的存储代码，具体，还需要自己分析！谢谢 #include <stdio.h> #define MAX 21 int n; //8.3 int BinSearch(int A[],int k) { int low=1,high=MAX,mid; n=1; while(low<=high) { mid=(low+high)/2; printf("当...
一文搞懂模拟退火算法（Simulated Annealing，SA）
最新发布
02-17
模拟退火算法一文搞懂模拟退火算法（Simulated Annealing，SA）一文搞懂模拟退火算法（Simulated Annealing，SA）一文搞懂模拟退火算法（Simulated Annealing，SA）一文搞懂模拟退火算法（Simulated Annealing，SA）...
一文读懂物联网NB-IoT与LoRa的区别
01-19
物联网的无线通信技术很多，主要分为两类：一类是Zigbee、WiFi、蓝牙、Z－wave等短距离通信技术；另一类是LPWAN（low－powerWide－AreaNetwork，低功耗广域网），即广域网通信技术。物联网的快速发展对无线通信技术...
【算法】查找算法—二分查找
weixin_62633072的博客
03-28 935
文章目录二分查找代码实现扩展/代码实现 二分查找 二分查找的前提是有序的数组。 在本文中会使用递归来实现二分查找。 具体思路： 使用两个指针来确定数组范围。left==0以及right==a.length-1。 通过比较findVal与midVal的值，来确定是向右递归还是向左递归。 每次递归都会从当前数组中间（mid）开始，向左或向右。即实现二分。 代码实现 public class Binarysearch { public static void main(String[] args)
算法：二分查找法
OceanStar的博客
04-28 8527
引入 二分查找是一种非常简单易懂的快速查找算法，生活中到处可见。 例子一 我们现在来做一个猜字游戏。我随机写一个 0 到 99 之间的数字，然后你来猜我写的是什么。猜的过程中，你每猜一次，我就会告诉你猜的大了还是小了，直到猜中为止。你来想想，如何快速猜中我写的数字呢？ 假设我写的数字是 23，猜数过程如下。（如果猜测范围的数字有偶数个，中间数有两个，就选择较小的那个。） 例子2 假设有1000条订单数据，已经按照订单金额从小到大排序，每个订单金额不同，并且最小单位是元。我们现在想知道支付存在金额等
算法篇：二分查找基础篇
zhghost的专栏
08-22 96
算法：目标Target:需要查找的值 索引index:要查找的当前位置 左右指示符Left,Right:用来维持查找的空间坐标 中间指示符Mid:用应用条件来确定我们应该向左查找还是向右...
算法：二分查找法(处理有序数组时可用）
weixin_44333294的博客
01-19 260
处理边界索引指向：保证循环不变量，虽然left和right的值在不断变化，但待查找的target在[l…r]的范围里的声明是不变的，控制边界保证循环不变量 public int binarySearch(E arr[], E target, int n) { int left=0; int right=n-1;//在[left..right]的范围里寻找target while(left<=right) {//没有可查找内容时跳出循环；当lef
【算法】二分搜索
代码星辰的博客
01-07 3788
本文对二分搜索算法进行了详细地介绍，包括概述、代码实现和应用。
二分搜索算法 (binary search)
TheAnnoyingDog的博客
02-15 4348
二分搜索算法 二分的本质并不是单调性，但是具有单调性一定可以使用二分，可以使用二分不一定具有单调性。二分的要点是"边界问题" 二分算法看似很容易实现，但是对于处理二分的边界上的细节时却十分复杂。 所以使用二分算法之前需要根据实际问题进行建模，根据不同的性质设置判断条件，划分红蓝区域，最终定位边界。 请看下图： 找出蓝色的边界的数字和红色边界的数字。 可以将图中的一串数字根据颜色的不同，而划分成红蓝两个区域，可以使用通过二分法来确定红蓝区域的边界。 两头分别设立两个指针，l 和 r ，l 是从左相向右扫描
二分搜索简介
aidscooler的专栏
09-29 568
它的基本思想是将数组分为两部分，通过比较目标值与数组中间元素的大小关系，确定目标值可能存在的区间，然后不断缩小区间直到找到目标值或确定不存在。二分搜索算法适用于已经排序的静态数据集，例如查找某个元素在字典中的位置、查找某个数字是否在排序好的数组中等。二分搜索算法要求有序数组，因为它是通过比较目标值与中间元素的大小关系来确定搜索范围的。依赖有序数组：二分搜索算法要求输入数组是有序的，如果数组无序，则需要先进行排序。二分搜索算法用于在有序数组中查找特定元素的位置，即确定目标值在数组中的索引。
一文读懂MADDPG算法
09-29
一文读懂MADDPG算法的文章介绍了MADDPG算法的基本原理和应用。MADDPG代表多智能体深度确定性策略梯度算法，是一种用于协同多智能体决策的强化学习算法。该算法通过维护一个actor-critic结构的网络，每个智能体都有自己的actor网络和一个共享的critic网络，来实现多智能体的协同决策。在训练过程中，每个智能体根据自己的观测和动作进行策略优化，并通过共享的critic网络来评估策略的价值。MADDPG算法在多智能体协同决策问题上取得了很好的效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

独泪了无痕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值