《算法笔记》二分查找

二分查找（非递归实现）

二分查找的前提是有序，并且每次查找的范围都是闭区间

#include <iostream>
#include<string.h>
#include <algorithm>
using namespace std;
int a[10] = {1, 4, 6, 10, 34, 56, 78, 90, 98, 99};
int main()
{
    //二分查找(非递归实现)
    int n = 0, left = 0, right = 9;
    scanf("%d", &n);
    bool flag = false;
    while(left <= right){
        int mid = (left + right) / 2;
        //当left和right较大时，可以使用如下等价方法
        //int mid = left + (right - left) / 2;
        if(a[mid] == n){
            cout << mid << endl;
            flag = true;
            break;
        }
        else if(a[mid] > n) right = mid - 1;
        else if(a[mid] < n) left = mid + 1;
    }
    if(!flag) scanf("抱歉，未找到");
    system("pause");
    return 0;
}

二分查找（递归实现）

#include <iostream>
#include<string.h>
#include <algorithm>
using namespace std;

int a[10] = {1, 4, 6, 10, 34, 56, 78, 90, 98, 99};

bool binarySearch(int left, int right, int n){
    if(left > right) return false;
    int mid = (left + right) / 2;
    if(a[mid] == n){
        cout << mid ;
        return true;
    }
    else if(a[mid] > n) return binarySearch(left, mid - 1, n);
    else return binarySearch(mid + 1, right, n);
}
int main()
{
    //二分查找(递归实现)
    int n = 0, left = 0, right = 9;
    scanf("%d", &n);
    bool flag = binarySearch(left, right, n);
    if(!flag) printf("Sorry,cannot find");
    system("pause");
    return 0;
}

查找第一个大于目标值元素的下标

#include <iostream>
#include<string.h>
#include <algorithm>
using namespace std;

int a[11] = {1, 4, 6, 6, 6, 8, 78, 90, 98, 99};
//在一个有重复元素的数组中找到第一个大于等于目标值的下标
int lowerBound(int left, int right, int n){
    //注意与二分查找的区别，二分查找只要找到就会return，而这个必须找到 left== right的位置才会结束
    while(left < right){
        int mid = (left + right) / 2;
        if(a[mid] >= n) right = mid;//如果中间值大于等于目标值，则在[left, mid]区间查找
        else if(a[mid] < n) left = mid + 1; //如果中间值小于等于目标值，则在[mid + 1, right]区间查找
    }
    return left;
}
int main()
{
    int n = 0 ;
    scanf("%d", &n);
    //因为可能所有数都小于目标值，此时应返回n+1
    int ans = lowerBound(0, 10, n);
    printf("%d", ans);
    system("pause");
    return 0;
}

大于目标值的第一个元素下标

代码与上一个类似，只是在判断时稍微改了改哦，注意初始的left 和 right 应该包括所有可能出现的结果，即要输入[0,n]

#include <iostream>
#include<string.h>
#include <algorithm>
using namespace std;

int a[11] = {1, 4, 6, 6, 6, 8, 78, 90, 98, 99};
//在一个有重复元素的数组中找到第一个大于目标值的下标
int lowerBound(int left, int right, int n){
    //注意与二分查找的区别，二分查找只要找到就会return，而这个必须找到 left== right的位置才会结束
    while(left < right){
        int mid = (left + right) / 2;
        if(a[mid] > n) right = mid;//如果中间值大于等于目标值，则在[left, mid]区间查找
        else if(a[mid] <= n) left = mid + 1; //如果中间值小于等于目标值，则在[mid + 1, right]区间查找
    }
    return left;
}
int main()
{
    int n = 0 ;
    scanf("%d", &n);
    //因为可能所有数都小于目标值，此时应返回n+1
    int ans = lowerBound(0, 10, n);
    printf("%d", ans);
    system("pause");
    return 0;
}

在一个有序数组中查找满足任意条件的第一个元素

在模板中，无论数组是增序还是降序，都要先判断是否满足条件，因为一旦满足条件就要去左区间寻找，才会找到第一个元素。欧耶！！！
如果找满足条件的最后一个元素，可以先找到不满足条件的最后一个元素，然后减一；

#include <iostream>
#include<string.h>
#include <algorithm>
using namespace std;

int a[11] = {1, 4, 6, 6, 6, 8, 78, 90, 98, 99};
//在一个有重复元素的数组中找到第一个大于目标值的下标
int lowerBound(int left, int right, int n){
    while(left < right){
        int mid = (left + right) / 2;
        if(元素应该满足的条件) right = mid;//如果中间值大于等于目标值，则在[left, mid]区间查找
        else if(对立问题) left = mid + 1; //如果中间值小于等于目标值，则在[mid + 1, right]区间查找
    }
    return left;
}
int main()
{
    int n = 0 ;
    scanf("%d", &n);
    //因为可能所有数都小于目标值，此时应返回n+1
    int ans = lowerBound(0, 10, n);
    printf("%d", ans);
    system("pause");
    return 0;
}

二分法的应用

装水问题
木条切割问题

快速幂

#include <iostream>
#include<string.h>
#include <algorithm>
using namespace std;
typedef long long LL;

LL binaryPower(LL a, LL b, LL m){
//如果指数为0，返回1
    if(b == 0) return 1;
    //如果指数为奇数，则返回b-1
    if(b % 2 == 1){
        return a * binaryPower(a, b - 1, m) % m;
    }
    //如果指数为偶数，则返回 b / 2
    else{
        int temp =  binaryPower(a, b / 2, m) ;
        return temp * temp % m;
    }
}

int main()
{
    LL a, b, m;
    scanf("%lld%lld%lld", &a, &b, &m);
    LL  ans = binaryPower(2, 10, 100);
    printf("%lld", ans);
    system("pause");
    return 0;
}

合并两个有序数组

#include <iostream>
#include<string.h>
#include <algorithm>
using namespace std;
typedef long long LL;
int a[3] = {1,3,5}, b[3] = {2,4,6}, c[10] = {0};

void merge1(int a[], int b[], int c[], int m, int n){
    int i = 0, j = 0, k = 0;
    //如果i < m && j < n 就一直执行
    while(i < m && j < n){
        if(a[i] <= b[j]){
            c[k++] = a[i++];
        }
        else if(a[i] > b[j]) c[k++] = b[j++];
    }
    //如果有一个数组没有输出完，就全部输出
    while(i < m) c[k++] = a[i++];
    while(j < n) c[k++] = b[j++];
}

int main()
{
    merge1(a, b, c, 3, 3);
    for(int i = 0; i < 6; i++) printf("%d", c[i]);
    system("pause");
    return 0;
}