[经典面试题]二分查找问题汇总

最新推荐文章于 2023-08-03 14:43:30 发布
最新推荐文章于 2023-08-03 14:43:30 发布
阅读量7.9k 收藏 17
点赞数 3
文章标签： 二分查找 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunnyyoona/article/details/42406497
版权
[算法]二分查找算法
1.【给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1。】
【题目】

给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1。

【分析】

此题也就是求target在数组中第一次出现的位置。这里可能会有人想先直接用原始的二分查找，如果不存在直接返回-1，

如果存在，然后再顺序找到这个等于target值区间的最左位置，这样的话，最坏情况下的复杂度就是O（n）了，没有完全发挥出二分查找的优势。

这里的解法具体过程请参考实现代码与注释。

【代码】

/*********************************
*   日期：2015-01-05
*   作者：SJF0115
*   题目: 给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1
*   博客：
**********************************/
#include <iostream>
using namespace std;

int BinarySearch(int A[],int n,int target){
    if(n <= 0){
        return -1;
    }//if
    int start = 0,end = n-1;
    // 二分查找变形
    while(start < end){
        int mid = (start + end) / 2;
        if(A[mid] < target){
            start = mid + 1;
        }//if
        else{
            end = mid;
        }//else
    }//while
    // 目标不存在的情况
    // 此时start = end
    if(A[start] != target){
        return -1;
    }//if
    else{
        return start;
    }
}

int main(){
    int A[] = {2,3,4,4,4,4,4,5,6,7,8};
    cout<<BinarySearch(A,11,4)<<endl;
    return 0;
}


/*********************************
*   日期：2015-01-05
*   作者：SJF0115
*   题目: 给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1
*   博客：
**********************************/
#include <iostream>
using namespace std;

int BinarySearchMin(int A[],int n,int target){
    if(n <= 0){
        return -1;
    }//if
    int start = 0,end = n-1;
    // 二分查找变形
    while(start <= end){
        int mid = (start + end) / 2;
        if(A[mid] == target){
            // 如果中间元素左边元素等于目标元素
            if(mid - 1 >= 0 && A[mid - 1] == target){
                end = mid - 1;
            }//if
            else{
                return mid;
            }
        }//if
        // 目标位于左半部分
        else if(A[mid] > target){
            end = mid - 1;
        }
        // 目标位于右半部分
        else{
            start = mid + 1;
        }//else
    }//while
    return -1;
}

int main(){
    int A[] = {4,4,4,4,4,5,6,7,8};
    cout<<BinarySearchMin(A,11,4)<<endl;
    return 0;
}

2.【给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]等于target，不存在则返回-1】
【题目】

给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]等于target，不存在则返回-1

【分析】

和上题类似

【代码】

/*********************************
*   日期：2015-01-05
*   作者：SJF0115
*   题目: 给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]等于target，不存在则返回-1
*   博客：
**********************************/
#include <iostream>
using namespace std;

int BinarySearchMax(int A[],int n,int target){
    if(n <= 0){
        return -1;
    }//if
    int start = 0,end = n-1;
    // 二分查找变形
    while(start <= end){
        int mid = (start + end) / 2;
        if(A[mid] == target){
            // 如果中间元素右边元素等于目标元素
            if(mid + 1 < n && A[mid + 1] == target){
                start = mid + 1;
            }//if
            else{
                return mid;
            }
        }//if
        // 目标位于左半部分
        else if(A[mid] > target){
            end = mid - 1;
        }
        // 目标位于右半部分
        else{
            start = mid + 1;
        }//else
    }//while
    return -1;
}

int main(){
    int A[] = {2,3,4,4,4,4,4,5,6,7,8};
    cout<<BinarySearchMax(A,11,4)<<endl;
    return 0;
}

3.【给定一个有序（非降序）数组A，可含有重复元素，小于target的最大元素的位置，不存在则返回-1】
【题目】

给定一个有序（非降序）数组A，可含有重复元素，小于target的最大元素的位置，不存在则返回-1

【分析】

这个问题可以转换为给定一个有序（非降序）数组A，可含有重复元素，等于target的最小元素的前一个，不存在则返回-1

【代码】

/*********************************
*   日期：2015-01-05
*   作者：SJF0115
*   题目: 给定一个有序（非降序）数组A，可含有重复元素，小于target的最大元素的位置，不存在则返回-1
*   博客：
**********************************/
#include <iostream>
using namespace std;

int BinarySearch(int A[],int n,int target){
    if(n <= 0){
        return -1;
    }//if
    int start = 0,end = n-1;
    // 二分查找变形
    int index;
    // 求含重复元素中等于target的最小位置
    while(start <= end){
        int mid = (start + end) / 2;
        if(A[mid] == target){
            // 如果中间元素左边元素等于目标元素
            if(mid - 1 >= 0 && A[mid - 1] == target){
                end = mid - 1;
            }//if
            else{
                return mid-1;
            }
        }//if
        // 目标位于左半部分
        else if(A[mid] > target){
            end = mid - 1;
        }
        // 目标位于右半部分
        else{
            start = mid + 1;
        }//else
    }//while
    return -1;
}

int main(){
    int A[] = {1,2,4,4,4,4,4,5,6,7,8};
    cout<<BinarySearch(A,11,4)<<endl;
    return 0;
}

4.【给定一个有序（非降序）数组A，可含有重复元素，大于target的最小元素的位置，不存在则返回-1】
【题目】

给定一个有序（非降序）数组A，可含有重复元素，大于target的最小元素的位置，不存在则返回-1

【分析】

这个问题可以转换为给定一个有序（非降序）数组A，可含有重复元素，等于target的最大元素的后一位置，不存在则返回-1

【代码】

/*********************************
*   日期：2015-01-05
*   作者：SJF0115
*   题目: 给定一个有序（非降序）数组A，可含有重复元素，大于target的最小元素的位置，不存在则返回-1
*   博客：
**********************************/
#include <iostream>
using namespace std;

int BinarySearch(int A[],int n,int target){
    if(n <= 0){
        return -1;
    }//if
    int start = 0,end = n-1;
    // 二分查找变形
    int index;
    // 求含重复元素中等于target的最大位置
    while(start <= end){
        int mid = (start + end) / 2;
        if(A[mid] == target){
            // 如果中间元素右边元素等于目标元素
            if(mid + 1 < n && A[mid + 1] == target){
                start = mid + 1;
            }//if
            else{
                return (mid + 1 >= n)?-1:mid+1;
            }
        }//if
        // 目标位于左半部分
        else if(A[mid] > target){
            end = mid - 1;
        }
        // 目标位于右半部分
        else{
            start = mid + 1;
        }//else
    }//while
    return -1;
}

int main(){
    int A[] = {1,2,4,4,4,4,4,5,6,7,8};
    cout<<BinarySearch(A,11,4)<<endl;
    cout<<BinarySearch(A,11,5)<<endl;
    cout<<BinarySearch(A,11,8)<<endl;
    return 0;
}

5.【给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的次数】
【题目】

给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的次数

【分析】

上面已经求出给定一个有序（非降序）数组A，可含有重复元素，求等于target最小位置和最大位置。

【代码】

/*********************************
*   日期：2015-01-05
*   作者：SJF0115
*   题目: 给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的次数
*   博客：
**********************************/
#include <iostream>
using namespace std;
// 求等于target的最小元素位置
int BinarySearchMin(int A[],int n,int target){
    if(n <= 0){
        return -1;
    }//if
    int start = 0,end = n-1;
    // 二分查找变形
    while(start <= end){
        int mid = (start + end) / 2;
        if(A[mid] == target){
            // 如果中间元素左边元素等于目标元素
            if(mid - 1 >= 0 && A[mid - 1] == target){
                end = mid - 1;
            }//if
            else{
                return mid;
            }
        }//if
        // 目标位于左半部分
        else if(A[mid] > target){
            end = mid - 1;
        }
        // 目标位于右半部分
        else{
            start = mid + 1;
        }//else
    }//while
    return -1;
}
// 求等于target的最大元素位置
int BinarySearchMax(int A[],int n,int target){
    if(n <= 0){
        return -1;
    }//if
    int start = 0,end = n-1;
    // 二分查找变形
    while(start <= end){
        int mid = (start + end) / 2;
        // 中间元素等于目标
        if(A[mid] == target){
            // 如果中间元素右边元素等于目标元素
            if(mid + 1 < n && A[mid + 1] == target){
                start = mid + 1;
            }//if
            else{
                return mid;
            }//else
        }//if
        else if(A[mid] > target){
            end = mid -1;
        }//else
        else{
            start = mid + 1;
        }
    }//while
    return -1;
}

int BinarySearchCount(int A[],int n,int target){
    int min = BinarySearchMin(A,n,target);
    int max = BinarySearchMax(A,n,target);
    // 没有
    if(min == -1){
        return 0;
    }//if
    int count = max - min + 1;
    return count;
}

int main(){
    int A[] = {1,2,4,4,4,4,4,5,6,7,8};
    cout<<"Count->"<<BinarySearchCount(A,11,4)<<endl;
    return 0;
}

6.【给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的下标范围】
【题目】

给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的下标范围

【分析】

上面已经求出给定一个有序（非降序）数组A，可含有重复元素，求等于target最小位置和最大位置。

具体参考：[LeetCode]34.Search for a Range

【代码】
/*********************************
*   日期：2015-01-24
*   作者：SJF0115
*   题目: 34.Search for a Range
*   网址：https://oj.leetcode.com/problems/search-for-a-range/
*   结果：AC
*   来源：LeetCode
*   博客：
**********************************/
#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    vector<int> searchRange(int A[], int n, int target) {
        vector<int> result;
        if(n <= 0){
            return result;
        }//if
        // 目标元素的最小位置
        int left = searchStartRange(A,n,target);
        // 目标元素的最大位置
        int right = searchEndRange(A,n,target);
        result.push_back(left);
        result.push_back(right);
        return result;
    }
private:
    // 目标元素的最小位置
    int searchStartRange(int A[],int n,int target){
        int start = 0,end = n-1;
        while(start <= end){
            int mid = (start + end) / 2;
            // 目标是中间元素
            if(A[mid] == target){
                // 如果中间元素左边元素等于目标元素
                if(mid - 1 >= 0 && A[mid - 1] == target){
                    end = mid - 1;
                }//if
                else{
                    return mid;
                }
            }
            // 目标位于右半部分
            else if(A[mid] < target){
                start = mid + 1;
            }//
            // 目标位于左半部分
            else{
                end = mid - 1;
            }
        }//while
        return -1;
    }
    // 目标元素的最大位置
    int searchEndRange(int A[],int n,int target){
        int start = 0,end = n-1;
        while(start <= end){
            int mid = (start + end) / 2;
            // 目标是中间元素
            if(A[mid] == target){
                // 如果中间元素右边元素等于目标元素
                if(mid + 1 < n && A[mid + 1] == target){
                    start = mid + 1;
                }//if
                else{
                    return mid;
                }
            }
            // 目标位于右半部分
            else if(A[mid] < target){
                start = mid + 1;
            }//
            // 目标位于左半部分
            else{
                end = mid - 1;
            }
        }//while
        return -1;
    }
};

int main(){
    Solution solution;
    int A[] = {1};
    int n = 1;
    int target = 0;
    vector<int> result = solution.searchRange(A,n,target);
    // 输出
    for(int i = 0;i < result.size();++i){
        cout<<result[i]<<endl;
    }//for
    return 0;
}

7.【给定一个有序（非降序）数组A，不含重复元素，求target在数组中下标位置，如果找不到，则返回插入位置】
【题目】

给定一个有序（非降序）数组A，可含有重复元素，求target在数组中下标位置，如果找不到，则返回插入位置。

【分析】

具体参考：[LeetCode]35.Search Insert Position

【代码】
/*********************************
*   日期：2015-01-24
*   作者：SJF0115
*   题目: 35.Search Insert Position
*   网址：https://oj.leetcode.com/problems/search-insert-position/
*   结果：AC
*   来源：LeetCode
*   博客：
**********************************/
#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    int searchInsert(int A[], int n, int target) {
        if(n <= 0){
            return -1;
        }//if
        int start = 0,end = n - 1;
        // 二分查找
        while(start <= end){
            int mid = start + ((end - start) >> 1);
            // 目标找到
            if(A[mid] == target){
                return mid;
            }//if
            // 目标在左半部分
            else if(A[mid] > target){
                end = mid - 1;
            }//else
            // 目标在右半部分
            else{
                start = mid + 1;
            }//else
        }//while
        // 目标元素没有找到则找插入位置
        return start;// end + 1
    }
};

int main(){
    Solution solution;
    int A[] = {1,3,5,6};
    int n = 4;
    int target = 0;
    int result = solution.searchInsert(A,n,target);
    // 输出
    cout<<result<<endl;
    return 0;
}

8.【输入一个排好序的数组的一个旋转，输出旋转数组的最小元素】
【题目】

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。

【分析】

具体参考：[经典面试题]输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。

【代码】
/*********************************
*   日期：2015-01-04
*   作者：SJF0115
*   题目: 输入一个排好序的数组的一个旋转，输出旋转数组的最小元素
*   博客：
**********************************/
#include <iostream>
using namespace std;

int SearchMin(int A[],int n){
    if(n <= 0){
        return -1;
    }//if
    int start = 0,end = n-1;
    // 数组有序
    if(A[end] > A[start]){
        return A[start];
    }//if
    // 数组旋转
    // 二分查找
    while(start <= end){
        int mid = (start + end) / 2;
        // [start,mid]有序[mid,end]无序
        if(A[mid] > A[start]){
            start = mid;
        }
        // [start,mid]无序[mid,end]有序
        else if(A[mid] < A[start]){
            end = mid;
        }
        else{
            return A[mid+1];
        }
    }//while
}

int main(){
    int A[] = {2,3,4,5,6,7,8};
    cout<<SearchMin(A,7)<<endl;
    return 0;
}


9.【输入一个排好序的数组的一个旋转，求target在数组中下标，没有重复元素】

/*********************************
*   日期：2014-01-15
*   作者：SJF0115
*   题号: 33.Search in Rotated Sorted Array
*   来源：http://oj.leetcode.com/problems/search-in-rotated-sorted-array/
*   结果：AC
*   来源：LeetCode
*   总结：
**********************************/
#include <iostream>
#include <stdio.h>
using namespace std;

class Solution {
public:
    //二分查找
    int search(int A[], int n, int target) {
        int start = 0,end = n-1;
        int mid;
        while(start <= end){
            mid = (start + end) / 2;
            if(A[mid] == target){
                return mid;
            }
            //中间元素大于最左边元素则左部分为有序数组
            else if(A[mid] >= A[start]){
                //目标位于左部分
                if(target >= A[start] && target <= A[mid]){
                    end = mid - 1;
                }
                //目标位于右部分
                else{
                    start = mid + 1;
                }
            }
            //中间元素小于最右边元素则右部分为有序数组
            else{
                //目标位于左部分
                if(target <= A[end] && target >= A[mid]){
                    start = mid + 1;
                }
                //目标位于左部分
                else{
                    end = mid - 1;
                }
            }
        }
        return -1;
    }
};
int main() {
    int result;
    Solution solution;
    int A[] = {3,1};
    result = solution.search(A,2,1);
    printf("Result:%d\n",result);
    return 0;
}

10.【Find Minimum in Rotated Sorted Array]
[LeetCode]153.Find Minimum in Rotated Sorted Array

11.【Find Minimum in Rotated Sorted Array II ]

[LeetCode]154.Find Minimum in Rotated Sorted Array II


@SmartSi
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
二分查找问题全集汇总
08-03
问题：给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1，例如：A[2,4,6,8,8,8,9]求8得最小位置3的相关代码。
二分查找经典例题
luhaimin7的博客
01-31 1170
二分查找例题
二分查找，你真的掌握了吗？
热门推荐
计算机的艺术
05-21 1万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/8937978 二分查找，最基本的算法之一，也是面试中常被考察的重点，因为基本的算法最能反映出一个人的基础是否扎实。本文对二分查找相关题目做一个总结。 题目列表： 1. 给定一个有序（非降序）数组A，求任意一个i使得A[i]等于target，不存
【数据结构】折半查找法
qq_45314905的博客
12-22 1910
使用折半查找法实现给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]小于target，不存在则返回 -1
【数据结构】二分查找，你真的掌握了吗？
码农印象
06-03 1934
前言 二分查找，最基本的算法之一，也是面试中常被考察的重点，因为基本的算法最能反映出一个人的基础是否扎实。本文对二分查找相关题目做一个总结。 二分查找函数实现： int bin_search(int arr[], int n, int key) { int mid = 0; int low = 0, high = n-1; while (low &amp;amp;...
Redis面试题汇总经典.docx
03-13
Redis面试题汇总经典.docxRedis面试题汇总经典.docxRedis面试题汇总经典.docxRedis面试题汇总经典.docxRedis面试题汇总经典.docxRedis面试题汇总经典.docxRedis面试题汇总经典.docxRedis面试题汇总经典.docxRedis...
嵌入式经典面试题PDF
01-09
嵌入式软件工程师，面试经典题目
Java 面试题经典汇总
02-12
Java 面试题经典汇总
C++二分查找问题汇总
03-05
C++二分查找问题、解答思路、答案相关汇总
C语言面试题总结汇总经典.pdf
最新发布
03-29
C语言面试题总结汇总经典.pdfC语言面试题总结汇总经典.pdfC语言面试题总结汇总经典.pdfC语言面试题总结汇总经典.pdfC语言面试题总结汇总经典.pdfC语言面试题总结汇总经典.pdfC语言面试题总结汇总经典.pdfC语言面试题...
顺序表的折半查找（Ｃ语言）
12-16
折半查找的Ｃ语言程序，可用 基于Ｃ语言的程序 利用顺序表，学习数据结构时会有用
有序数组的折半查找
04-15
Visual C++,有序数组的折半查找,和顺序查找法相比，其速度更快。
刷题笔记C++
weixin_43398741的博客
08-03 589
1231231263
二分查找
auvKone
01-06 458
在排序的数组中查找一个数，不存在则返回-1。 int binarySearch(int a[], int num, int value) { int low, mid, high; low = 0; high = num - 1; while(low <= high){ mid = (low + high) / 2; i
【转】二分查找（折半查找Binary Search）
u011252067的博客
08-30 280
首先给五个题目： 1.给定一个有序（不降序）的数组a[]，求任意一个index使得a[index]==k,不存在则返回0. 2.给定一个有序（不降序）的数组a[]，求最小的index使得a[index]==k,不存在则返回0. 3.给定 一个有序（不降序）的数组a[]，求最大的index使得a[index]==k,不存在则返回0. 4.给定一个有序（不降序）的数组a[]，求最大的index
二分查找问题全集OK
gexiaobaoHelloWorld的专栏
09-05 5440
xxx
js实现二分查找（二分搜索）
weixin_45281446的博客
09-29 2881
首先了解什么是数据结构和算法 数据结构 = 数据结构 + 算法 数据结构：用来存储数据的数组 算法：暴力搜索，二分搜索 二分搜索：是一个搜索某个值的索引的算法 条件：在一个有序的数组中查找一个特定的元素 X 算法思路： 1）从数组的中间元素开始，如果中间元素正好是X，而查找成功 2）如果不是中间元素，则利用中间元素，将数组分为前后两个子数组 如果X小于中间位置的元素，则进一...
kafka经典面试题
09-01
当谈到Kafka的经典面试题时，有一些常见的问题可以问到。以下是几个可能的问题： 1. 什么是Kafka？它的核心概念是什么？ 2. Kafka的主要优势是什么？ 3. Kafka如何实现高吞吐量和低延迟？ 4. Kafka如何处理数据丢失...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

@SmartSi

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

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

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

打赏作者

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

抵扣说明：

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

余额充值