有序数组的二分查找实现

最新推荐文章于 2022-08-04 01:41:37 发布
最新推荐文章于 2022-08-04 01:41:37 发布
阅读量315 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L13763338360/article/details/105299461
版权

1. 有序数组，查找确定值

实现一

#include<iostream>
#include<vector>

using namespace std;


int binarySearch(vector<int>& array, int target) {
    int left = 0, right = array.size();
    while (left < right) {
        int mid = (left + right) / 2;
        if (array[mid] == target) return mid;
        else if (array[mid] < target) left = mid + 1;
        else right = mid;
    }
    return -1;
}


int main(int argc, char const *argv[]) {
    vector<int> input{1,2,3,4,5,6};
    cout << binarySearch(input, 3) << endl;
    cout << binarySearch(input, 100) << endl;
    cout << binarySearch(input, -100) << endl;

    return 0;
}

输出

2
-1
-1 

总结

  • right初始化：right = arra.size()
  • 循环条件：left < right
  • 更新right值：right = mid

 

 实现二

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array, int target) {
    int left = 0, right = array.size() - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (array[mid] == target) return mid;
        else if (array[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

int main(int argc, char const *argv[]) {
    vector<int> input{1,2,3,4,5,6};
    cout << binarySearch(input, 3) << endl;
    cout << binarySearch(input, 100) << endl;
    cout << binarySearch(input, -100) << endl;
    return 0;
}

输出

2
-1
-1 

总结

  • right初始化：right = arra.size() - 1
  • 循环条件：left <= right
  • 更新right值：right = mid - 1

2. 有序数组，查找不确定值

2.1 查找第一个不小于目标值的数

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array, int target) {
    int left = 0, right = array.size();
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (array[mid] < target) left = mid + 1;
        else right = mid;
    }
    return right;
}


int main(int argc, char const *argv[]) {
    vector<int> input{2, 4, 5, 6, 9};
    cout << binarySearch(input, 3) << endl;
    cout << binarySearch(input, 100) << endl;
    cout << binarySearch(input, -100) << endl;
    return 0;
}

输出

1
5  // 当目标值大于数组中所有元素时，只能输出最后一个元素索引 
0

问题

当目标值大于数组中所有元素时，只能输出最后一个元素索引 

总结

  • right初始化：right = arra.size()
  • 循环条件：left < right
  • 更新right值：right = mid
  • 大小判断：array[mid] < target
  • 不需要判断是否相等：array[mid] == target

2.2 查找最后一个小于目标值的数

从查找第一个不小于目标值的数：

return right;

查找最后一个小于目标值的数：

return right - 1;

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array, int target) {
    int left = 0, right = array.size();
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (array[mid] < target) left = mid + 1;
        else right = mid;
    }
    return right - 1;
}


int main(int argc, char const *argv[]) {
    vector<int> input{2, 4, 5, 6, 9};
    cout << binarySearch(input, 3) << endl;
    cout << binarySearch(input, 100) << endl;
    cout << binarySearch(input, -100) << endl;
    return 0;
}

输出

0
4
-1   // 当目标值小于数组中所有元素时，只能输出-1

问题

当目标值小于数组中所有元素时，只能输出-1

总结

  • right初始化：right = arra.size()
  • 循环条件：left < right
  • 更新right值：right = mid
  • 大小判断：array[mid] < target
  • 不需要判断是否相等：array[mid] == target

2.3 查找第一个大于目标值的数

查找第一个不小于目标值的数

if (nums[mid] < target) left = mid + 1;

查找第一个大于目标值的数

if (nums[mid] <= target) left = mid + 1;

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array, int target) {
    int left = 0, right = array.size();
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (array[mid] <= target) left = mid + 1;
        else right = mid;
    }
    return right;
}


int main(int argc, char const *argv[]) {
    vector<int> input{2, 4, 5, 6, 9};
    cout << binarySearch(input, 3) << endl;
    cout << binarySearch(input, 100) << endl;
    cout << binarySearch(input, -100) << endl;
    return 0;
}

输出

1
5  // 目标值大于数组中的所有元素时，结果输出最后一个元素索引
0

问题

目标值大于数组中的所有元素时，结果输出最后一个元素索引 

2.4 查找第一个大于目标值的数

查找第一个大于目标值的数

return right;

查找最后一个不大于目标值的数

return right - 1;

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array, int target) {
    int left = 0, right = array.size();
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (array[mid] <= target) left = mid + 1;
        else right = mid;
    }
    return right - 1;
}


int main(int argc, char const *argv[]) {
    vector<int> input{2, 4, 5, 6, 9};
    cout << binarySearch(input, 3) << endl;
    cout << binarySearch(input, 100) << endl;
    cout << binarySearch(input, -100) << endl;
    return 0;
}

输出

0
4 
-1  //目标值小于所有元素时，只能返回-1

问题

目标值大于数组中的所有元素时，结果输出最后一个元素索引 

3 有序数组旋转

3.1 情形一：无固定target 值

3.1.1 实现一

源码

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array) {
    int left = 0, right = (int)array.size() - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (array[mid] > array[right]) left = mid + 1;
        else right = mid;
    }
    return nums[right];
}


int main(int argc, char const *argv[]) {
    vector<int> input{4,5,6,7,0, 1,2};
    cout << "no repeat element：" << binarySearch(input) << endl;

    vector<int> input2{6,6,6,6,6,6,0,1,1,1,6,6};
    cout << "has repeat element：" << binarySearch(input2) << endl;
    return 0;
}

输出

no repeat element：0
has repeat element：6

问题

  • 无法处理数组中含有重复值的情况
  • 测试用例还有点要求，比如{6,6,0,1,1,1,6,6}就测试不出bug来

3.1.2 实现二

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array) {
    int left = 0, right = (int)array.size() - 1;
    while (left < right) {
        int mid = (left + right) / 2;
        if (array[mid] > array[right]) {
            left = mid + 1;
        } else if (array[mid] < array[right]) {
            right = mid;
        } else {
            --right;
        }
    }
    return nums[right];
}

int main(int argc, char const *argv[]) {
    vector<int> input{4,5,6,7,0, 1,2};
    cout << "no repeat element：" << binarySearch(input) << endl;

    vector<int> input2{6,6,6,6,6,6,0,1,1,1,6,6};
    cout << "has repeat element：" << binarySearch(input2) << endl;
    return 0;
}

输出

no repeat element：0
has repeat element：0 

 此时，数组中含有重复元素也可以找出最小值

3.1.3 总结

  • right初始化：array.size() - 1
  • 循环条件：left < right
  • 数组有重复元素时，需要处理array[mid] = array[right]：--right

3.2 情形二：有固定target值

实现一

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array, int target) {
    int left = 0, right = (int)array.size() - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (array[mid] == target) return mid;
        if (array[mid] < array[right]) {
            if (array[mid] < target && target <= array[right]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        } else {
            if (target < array[mid] && target >= array[left]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
    }
    return -1;
}


int main(int argc, char const *argv[]) {
    vector<int> input{4,5,6,7,0,1,2};
    cout << "no repeat element：" << binarySearch(input, 0) << endl;
    vector<int> input2{3,1,1};
    cout << "has repeat element：" << binarySearch(input2, 3) << endl;
    return 0;
}

输出

no repeat element：4
has repeat element：-1 

问题

当有重复元素时，可能会出问题

实现二 

#include<iostream>
#include<vector>

using namespace std;

int binarySearch(vector<int>& array, int target) {
    int left = 0, right = (int)array.size() - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (array[mid] == target) return mid;
        if (array[mid] < array[right]) {
            if (array[mid] < target && target <= array[right]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        } else if (array[mid] > array[right]){
            if (target < array[mid] && target >= array[left]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else {
            --right;
        }
    }
    return -1;
}


int main(int argc, char const *argv[]) {
    vector<int> input{4,5,6,7,0,1,2};
    cout << "no repeat element：" << binarySearch(input, 0) << endl;


    vector<int> input2{3,1,1};
    cout << "has repeat element：" << binarySearch(input2, 3) << endl;
    return 0;
}

输出

no repeat element：4
has repeat element：0 

总结

  • right初始化：array.size() - 1
  • 循环条件：left < right
  • 数组有重复元素时，需要处理array[mid] = array[right]：--right
L13763338360
关注
专栏目录
用C语言实现有序数组的二分查找
weixin_49449676的博客
04-16 2955
C语言实现二分查找
写一个函数，实现一个有序数组的二分查找。
IT小书生的博客
05-02 895
#include <stdio.h>int binary_search(int arr[],int key,int sz) { int mid = 0; int left = 0; int right = sz - 1; while (left <= right) { int mid = left + (right - left) / 2;
有序数组的二分查找
Xu__CSDN的博客
01-18 889
给定一个有序整型数组, 实现二分查找 实现思路： 找出位于数组中间的值，并存放在一个变量中，变量暂时命名为mid，需要找到的toSearch和mid进行比较，如果toSearch值大于mid，则把数组中间位置作为下一次计算的起点，重复前面两步，如果toSearch值小于mid，则把数组中间位置作为下一次计算的终点，重复前面三步，如果toSearch值等于mid，则返回数组下标，完成查找。 代码实现 package com.company; public class Main { public sta
java数据结构与算法---有序数组的二分查找
代码之神
05-01 267
之前学校开了数据结构这门课，是C语言版的，没认真学，只好现在来补一补了 首先要说的是必须是有序的，不然是没办法用二分法查找的 1.有序数组优缺点 优点:查找速度（采用二分查找法）比无序数组快很多(查找的数据量越大，优势越明显) 下面是一组用二分法查找的数据: 数据量                                                            ...
Python实现二维有序数组查找的方法
09-21
一种直观的方法是对每一行分别进行二分查找，但这可能会导致效率较低，因为每次只能排除一部分元素，而不能一次性剔除一行或一列。 更好的方法是采用“边界移动”策略。从数组的右上角元素开始，即最大值所在的位置...
JS实现二分查找查找有序数组中的数字
09-20
二分查找，也称为折半查找，是一种在有序数组中高效寻找特定元素的搜索算法。在JavaScript中，利用二分查找可以显著提升查找效率，尤其适用于大数据量的处理。二分查找的基本思想是通过不断缩小查找范围，直到找到...
详解Java数据结构和算法（有序数组和二分查找）
08-29
本篇文章主要介绍了有序数组和二分查找的相关知识点，并提供了一个使用 Java 实现的有序数组类的示例代码。有序数组是一种特殊的数组结构，它的元素按照特定的顺序排列。有序数组的优点是查找速度快，但是插入时需要...
菜鸡的算法修炼——有序数组的二分查找（剑指offer题目，旋转数组的最小值，Java实现）
12-22
题目描述 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的...而本题研究的对象是有序数组的旋转。菜鸡觉得这道题目颇为简单，只要遍历数组array，如果存在array[i] < array[0]，那么array[i]一定就是
【Java】和【C语言】实现一个有序数组的二分查找
超烦豆先森
08-04 1385
Java实现二分查找、C语言实现二分查找
C初阶（十九） 函数_实现一个整型有序数组的二分查找
weixin_42536748的博客
03-25 221
//1.3 函数实现一个整型有序数组的二分查找 #include <stdio.h> int Binary_search(int arr[], int k, int sz)//int arr[] 等价于 int* arr { int left = 0; int right = sz - 1; while (left<=right) { int mid = (left...
写一个函数, 实现一个整型有序数组的二分查找
HHHuYYYue的博客
03-25 736
二分查找必须知道数组的左右下标, 通常情况下, 数组的左右下标表示如下: int left = 0; int right = sizeof(arr) / sizeof(arr[0]) - 1; 若通过函数调用来实现二分查找, 就要进行传参. 需要将数组和所要寻找的值传递给二分查找所对应的函数 然而, 数组在传参的时候, 传过去的是一个数组名(arr), 本质上传过去的确是数组的首元素...
有序数组 二分查找
weixin_46091520的博客
11-06 189
704.二分查找 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1 示例： 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 class Solution { public: int search(vector<int>& nums, int target) {
二分查找算法（有序数组）
来杯咖啡吗的博客
05-26 960
只适用于有序数组哦！！！ 二分查找,顾名思义就是将数组对半分开进行查找 package search; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * 二分查找法 * 数组必须有序 */ public class BinarySeatch { public static void main(String[] args) { int[] arr = {1,1,
二分查找算法(有序数组）
weixin_63954483的博客
03-14 1294
二分查找算法
【数据结构与算法】有序数组查找：二分查找算法实现
Minuhy
09-02 1066
有序数组查找：二分查找算法实现 Java https://leetcode-cn.com/problems/binary-search/solution/you-xu-shu-zu-cha-zhao-er-fen-cha-zhao-s-ciza/ 解题思路 这是一个有序数组，里面的元素都是可比较的，那么可以使用时间复杂度较小的二分查找算法。定义l为查找区间最左边元素的索引，r为区间中元素的个数，或者r-1为区间中最右边的索引，具体逻辑如下：首先找到中间的元素m，对比要查找的元素，如果m大了，那么就在[l,m
基于有序数组的二分查找
技术人生
08-05 482
#define MAX_COUNT 100 //基于有序数组的二分查找 int keys[MAX_COUNT] = {0}; int values[MAX_COUNT] = {0}; int count = 0; int isEmpty() { return count == 0; } //根据给定的关键字,在字典中查找是否有匹配项,并返回匹配的项的 //数组索引,如果没有找到匹配
循环有序数组 二分查找算法 递归实现
qq_38241346的博客
12-04 471
int findK(int a[],int n,int k){ int l=n; int p=div(a,0,n-1); cout<<p<<endl; if(k>a[0]){ return divl(a,0,p-1,k); } else{ return divl(a,p,n-1,k); ...
C语言——实现一个整型有序数组的二分查找的两种方法
m0_49687898的博客
03-29 2251
C语言——实现一个整型有序数组的二分查找的两种方法
实现对有序数组二分查找
最新发布
04-19
以下是实现有序数组二分查找的步骤： 1. 初始化左指针left为数组的起始位置，右指针right为数组的结束位置。 2. 计算中间位置mid，可以使用公式mid = (left + right) / 2。 3. 比较中间位置的元素与目标值的大小： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值