常用库函数（2）

3 二分查找

1）二分查找的前提

库函数只能对数组进行二分查找。

对一个数组进行二分查找的前提是这个数组中的元素是单调的。

一般为单调不减，当然如果是单调不增也可以（需要修改比较函数)。

例如:

[1,5,5,9,18]是单调的

[1,9,9,7,15]不是单调的

[9,8,8,7,7,1]是单调的

1. binary_search函数

binary_search是C++标准库中的一个算法函数，用于在已排序的序列（例如数组或容器）中查找特定元素。

它通过二分查找算法来确定序列中是否存在目标元素。

函数返回一个bool值，表示目标元素是否存在于序列中。如果需要获取找到的元素的位置，可以使用std:lower_bound函数或std:upper_bound函数。

例3.1

#include <bits/stdc++.h>

using namespace std;

int main()

{

        ios::sync_with_stdio(0), cin.tie(0),cout.tie(0);

        vector<int> numbers = {1,3,5,7,9};

        int target = 5;

        //使用binary_search查找目标元素

        bool found = binary_search(numbers.begin(),numbers.end(),target);

        if (found)

        {

        cout << "Target element " << target << " found." << endl;

        }

        else

        {

        cout << "Target element " << target << " not found." <<endl;

        }

        return 0;

}

3）lower_bound和upper_bound

前提：数组必须为非降序。

如果要在非升序的数组中使用，可以通过修改比较函数实现（方法与sort自定义比较函数类似）。

lower_bound(st, ed, x)返回地址[st, ed)中第一个大于等于x的元素的地址。

upper_bound(st, ed,x)返回地址[st, ed)中第一个大于x的元素的地址。

如果不存在则返回最后一个元素的下一个位置，在vector中即end()。

例3.2

#include <bits/stdc++.h>

using namespace std;

int main()

{

        ios::sync_with_stdio(0), cin.tie(0),cout.tie(0);

        //初始化v

        vector<int> v = {5,1,8,3,10,8,9};

        //默认用小于号比较，从小到大排列

        //如果要从大到小，要重新定义小于号，或自定义比较方式

        //但lower_bound和upper_bound函数中默认也用的小于号比较

        sort(v.begin(), v.end());

        for(auto &i : v)

                cout << i << ' ';

        cout << '\n';

        //找到数组中第一个大于等于8的元素的位置

        cout <<(lower_bound(v.begin(), v.end(),8) - v.begin())<< '\n';//当前地址-起始地址

        return 0;

}

练习1-二分查找数组元素

蓝桥账户中心

要求合理使用以上函数。

思考，时间复杂度是多少呢？

4 大小写转换

1）islower和isupper函数

islower和isupper是C++标准库中的字符分类函数，用于检查一个字符是否为小写字母或大写字母。

islower和isupper函数需要包含头文件<cctype>，也可用万能头包含。

函数返回值为bool类型。

if (islower(ch))cout << ch<< " is a lowercase letter." <<endl;

2）tolower和toupper函数

tolower(char ch)可以将ch转换为小写字母，如果ch不是大写字母则不进行操作。

toupper()同理。

char uppercaseCh = toupper(ch);

cout << "Uppercase of " << ch << " is " < uppercaseCh << endl;

3）ascii码

在了解了ascii码后，我们可以通过直接对英文字母进行加减运算计算出其大小写的字符

在ASCII码表中，大写字母的编码范围是65(A'）到90('Z')，而小写字母的编码范围是97 ('a')到122 (z)。根据这个规则，可以使用ASCII码表进行大小写转换。

Tips:在程序设计时，尤其是用到char类型时，一定要注意0～9到底是“数字0~9”还是“字符0~9“，它们也可以通过ascii进行转换。

例子，大写转小写，小写转大写

用函数和ascii两种方法写。

5 全排列

1）next_permutation()函数

next_permutation函数用于生成当前序列的下一个排列。它按照字典序对序列进行重新排列，如果存在下一个排列，则将当前序列更改为下一个排列，并返回true;如果当前序列已经是最后一个排列，则将序列更改为第一个排列，并返回false。

123.

132

213

231

312

321

例5.1

#include <bits/stdc++.h>

using namespace std;

int main()

{

        ios::sync_with_stdio(0), cin.tie(0),cout.tie(0);

        vector<int> nums = {1,2,3};

        cout << "Initial permutation: ";

        for (int num : nums)

        {

                cout << num << " ";

        }

        cout <<endl;

        //生成下一个排列

        while(next_permutation(nums.begin(),nums.end()))

        {

                cout << "Next permutation: ";

                for (int num : nums)

                {

                        cout <<num <<"";

                }

                cout << endl;

        }      

        return 0;

}

2）prev_perrmutation()函数

prev_permnutation函数与next_permutation函数相反，它用于生成当前序列的上一个排列。它按照字典序对序列进行重新排列，如果存在上一个排列，则将当前序列更改为上一个排列，返回true；如果当前序列已经是第一个排列，则将序列更改为最后一个排列，并返回false。

例子，生成某个数组的全排列，用数组和vector两种方法实现。

全排列一般用bfs搜索，如果只是全排列，可以用以上两个函数。

例5.2

#include <bits/stdc++.h>

using namespace std;

int main()

{

        ios::sync_with_stdio(0), cin.tie(0),cout.tie(0);

        int a[ 10];

        for(int i = 1;i <= 4; ++ i)a[i] = i;

        bool tag = true;

        while(tag)

        {

       

                for( int i=1;i<=4;++i)

                    cout<<a[i]<<' ';

                cout<<'\n' ;

                tag = next_permutation(a+1, a+1+4);

        }      

        return 0;

}

6 其他库函数

1）menset()

memset()是一个用于设置内存块值的函数。

它的原型定义在<cstring>头文件中，函数的声明如下:

void*memset(void* ptr,int value,size_t num);

memset()函数接受三个参数:

ptr:指向要设置值的内存块的指针。

value:要设置的值,通常是一个整数。（8位二进制数）

num:要设置的字节数。

memset()函数将ptr指向的内存块的前num个字节设置为value的值。它返回一个指向ptr的指针。

memset()函数通常用于初始化内存块，将其设置为特定的值。

例如，如果要将一个整型数组的所有元素设置为0，可以使用memset()函数如下:

int arr[10];

memset(arr, 0, sizeof(arr));

在上述示例中，memset(arr, 0, sizeof(arr))将数组arr的所有元素设置为0。

需要注意的是，memset()函数对于非字符类型的数组可能会产生未定义行为。在处理非字符类型的数组时，最好使用C++中的其他方法，如循环遍历来初始化数组。

memset会将每个byte设置为value。

例5.3

#include <bits/stdc++.h>

using namespace std;

int main()

{

        ios::sync_with_stdio(0), cin.tie(0),cout.tie(0);

        int a[5];

        memset(a,1,sizeof a); //1改成0x3f试试

        //for( int i=0 ;i<5; ++i)cout << a[i] << '\n';return 0;

        for(int i = 0;i < 5; ++ i)cout<<bitset<32>(a[i])<<'\n';

        //0和-1都正确，因为-1的补码是全1

        return 0;

}

2）swap()

swap(T &a,T &b)函数接受两个参数:

a:要交换值的第一个变量的引用。（引用可以理解成变量的别名，代表变量本身）

b:要交换值的第二个变量的引用。

swap()函数通过将第一个变量的值存储到临时变量中，然后将第二个变量的值赋给第一个变量，最后将临时变量的值赋给第二个变量，实现两个变量值的交换。

swap()函数可以用于交换任意类型的变量，包括基本类型（如整数、浮点数等）和自定义类型（如结构体、类对象等)。

以下是一个示例，展示如何使用swap()函数交换两个整数的值:

int a = 10;int b = 20;

std::swap(a,b);

3）reverse()

是一个用于反转容器中元素顺序的函数。它的原型定义在<algorithm>头文件中，函数的声明如下:

template<class BidirIt>

void reverse(BidirIt first，BidirIt last);

reverse()函数接受两个参数:

1.first:指向容器中要反转的第一个元素的迭代器。

2.last:指向容器中要反转的最后一个元素的下一个位置的迭代器。

reverse()函数将[first, last)范围内的元素顺序进行反转。

也就是说，它会将[first, last)范围内的元素按相反的顺序重新排列。reverse()函数可用于反转各种类型的容器，包括数组、向量、链表等。

以下是一个示例，展示如何使用reverse()函数反转一个整型向量的元素顺序。

例5.4

#include <algorithm>

using namespace std;

int main()

{

        ios::sync_with_stdio(0), cin.tie(0),cout.tie(0);

        std::vector<int> vec = {1,2,3,4,5};//因为没有使用namespace std

        std::reverse(vec.begin(), vec.end());

        for (int num : vec)

        {

                cout << num <<' ';

        }

        std:: cout << std::endl;

        return 0;

}

在上述示例中，std:reverse(vec.begin(),vec.end())将整型向量vec中的元素顺序进行反转。最终输出的结果是54321。

需要注意的是，reverse()函数只能用于支持双向迭代器的容器，因为它需要能够向前和向后遍历容器中的元素，我们一般就是对数组和vector操作。

对于只支持单向迭代器的容器（如前向链表)，无法使用reverse()函数进行反转。

4）unique()

是一个用于去除容器中相邻重复元素的函数。它的原型定义在<algorithm>头文件中，函数的声明如下:

template<class ForwardIt>

ForwardIt unique(ForwardIt first，ForwardIt last);

unique(first, last)函数接受两个参数:

first:指向容器中要去重的第一个元素的迭代器。

last:指向容器中要去重的最后一个元素的下一个位置的迭代器。

unique()函数将[first, last)范围内的相邻重复元素去除，并返回一个指向去重后范围的尾后迭代器。

去重后的范围中只保留了第一个出现的元素，后续重复的元素都被移除。

unique()函数可用于去除各种类型的容器中的相邻重复元素，包括数组、向量、链表等。

以下是一个示例，展示如何使用unique()函数去除一个整型向量中的相邻重复元素。

//不会删掉

例5.5

#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

int main()

{

        ios::sync_with_stdio(0), cin.tie(0),cout.tie(0);

        std::vector<int> vec = {1,1,2,2,3,3,3,4,4,5};

        auto it = std::unique(vec.begin(),vec.end());

        //vec.erase(it, vec.end());  //先屏蔽此行

        for (int num : vec)

        {

                std::cout << num <<" ";

        }

        std::cout << std::endl;

        return 0;

}

在上述示例中，std:.unique(vec.begin(), vec.end())将整型向量vec中的相邻重复元素并未真正去除，而是放在了末尾。

使用vec.erase(it, vec.end());完成后续元素的删除，最终输出的结果是12345。

需要注意的是，unique()函数只能去除相邻的重复元素，如果容器中存在非相邻的重复元素，则无法去除。

如果需要去除所有重复元素，而不仅仅是相邻的重复元素，可以先对容器进行排序，然后再使用unique()函数。

unique()时间复杂度为O(n)。

例5.5

#include <iostream>

#include <vector>

#include <bits/stdc++.h>

using namespace std;

int main()

{

        int a[] = {3,1,2,2,3};

        //sort(a, a + 5);  //先屏蔽发现不相邻的未移到后面

        int n = unique(a,a+5)-a; //确定不重复的数据个数，因为重复的只是移到了后面

        for(int i =0;i < n; ++i)

                cout << a[i] << ' ';

        return 0;

}