C++一些函数

已于 2023-02-26 15:55:43 修改
阅读量76 收藏
点赞数 2
文章标签： c++ 算法 开发语言
于 2022-12-15 09:24:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74053777/article/details/128273259
版权

输入

输入不确定个数的一组数

以空格为间隔输入纯数字

#include<iostream>
#include<vector>
#include<sstream>

using namespace std;
int main()
{
    string s;
    vector<int> v;
    getline(cin,s);
    istringstream is(s);
    int inter;

    while(is>>inter){
        v.push_back(inter);
    }

    for(int i=0;i<v.size();i++)
        cout<<v[i]<<" ";
    cout<<endl;
    return 0;
}

以‘，’为间隔输入数字

#include<iostream>
#include<vector>
#include<sstream>

using namespace std;
int main()
{
    string s;
    vector<int> v;
    getline(cin, s);
    istringstream is(s);
    int inter;
    char ch;
    while (is >> inter)
    {
        v.push_back(inter);
        is >> ch;
    }
    for(int i=0;i<v.size();i++)
        cout<<v[i]<<" ";
    cout<<endl;
    return 0;
}

输入n行 长度不定的数字

#include<iostream>
#include<vector>
#include<sstream>

using namespace std;
int main()
{
    int n;
    string s;
    vector<int> v;

    cin>>n;
    cin.ignore();//删掉滞留在输入流中的'\n'
    for(int i=0;i<n;i++){
        getline(cin,s);
        istringstream is(s);
        int inter;
        while(is>>inter){
            v.push_back(inter);
        }
    }

    for(int i=0;i<v.size();i++)
        cout<<v[i]<<" ";
    cout<<endl;

    return 0;
}

memset

memset为初始化函数，但是它是以字节为单位进行初始化的。
操作为memset(要初始化的内存块，值，要初始化的字节大小）
因为是以字节为单位初始化，因此不能随意赋值，不是填入什么数就初始化为什么数。
对于char类型，由于char类型占1个字节，memset函数刚好以字节为单位，故可直接赋值

int main(){
    char a[4];
    memset(a,'1',4);
    for(int i=0; i<4; i++){
        cout<<a[i]<<" ";
    }
    return 0;
}

在这里插入图片描述
而对于int类型，int类型占4个字节，除了0和-1能直接赋值，其他的都不行

int main(){
    int a[4];
    memset(a,1,sizeof(a));
    for(int i=0; i<4; i++){
        cout<<a[i]<<" ";
    }
    return 0;
}

在这里插入图片描述
而如果要让4个int值变为1，可以这样操作：

memset(a,1,16); //int所占内存为4字节的情况
memset(a,1,sizeof(a));

这里的sizeof()则可以对全部内容进行初始化，故最好使用sizeof()，或者用for和while循环进行初始化。

memcpy

以字节为单位进行复制操作，在复制数组上挺好用的。最好用sizeof。

int a[5]={0,1,2,3,4},b[5];
memcpy(b,a,sizeof(a));

这时b数组的值就和a数组一样啦

swap

首先要提一下引用传递和指针传递的不同
指针传递

void myswap(int *a,int *b){//传入的是a和b的地址值
    int tmp=*a;  //除了声明或初始化指针时，*代表指针的意思，其他时候*在指针变量名左边代表指针指向的内容。这里tmp=a地址指向的内容，即a的值
    *a=*b;      //指针a指向的地址空间内容变成指针b指向的地址空间内容，即a=b
    *b=tmp;    //同理b指向的地方=tmp/a，完成交换
}
void main(){
	int a=1,b=2;
    myswap(&a,&b);  //传入地址值
    printf("%d %d",a,b); // 输出为2 1
    return 0;  
}

引用传递

void myswap(int &a,int &b){  //传入的为引用，调用该函数的时候，会生成引用a=a,引用b=b，所以函数里操作引用的时候，就是修改了原值。
    int tmp=a;
    a=b;
    b=tmp;
}
void main(){
	int a=1,b=2;
    myswap(a,b);
    printf("%d %d",a,b); // 2 1
    return 0;  
}

在这里指针传递和引用传递都可以交换两个变量的值。
但是其实有所区别，指针变量可以理解为指向变量的地址空间，而地址空间中储存着地址值，利用指针变量将变量改变实际上是指针指向的空间的地址值改变，即地址值指向要变成的那个值的地址。
而引用则是无法改变地址的，引用指向一个地址空间，该地址空间无法改变，只可以改变地址空间中的值。
C++中自带的swap函数属于引用传递

void main(){
	int a=1,b=2;
    swap(a,b);
    printf("%d %d",a,b); // 2 1
    return 0;  
}

sort

Sort函数有三个参数：
（1）第一个是要排序的数组的起始地址。

（2）第二个是结束的地址的下一个地址

（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。

例一：sort函数没有第三个参数，实现的是从小到大

#include<iostream>
 
#include<algorithm>
 
using namespace std;
 
int main()
 
{
 
 int a[10]={9,6,3,8,5,2,7,4,1,0};
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
sort(a,a+10);
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
 return 0;
 
}

例二：用bool进行判断实现从大到小排序

#include<iostream>
 
#include<algorithm>
 
using namespace std;
 
bool compare(int a,int b)
 
{
 
 return a>b;
 
}
 
int main()
 
{
 
 int a[10]={9,6,3,8,5,2,7,4,1,0};
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
 sort(a,a+10,compare);//在这里就不需要对compare函数传入参数了，//这是规则
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
 return 0;
 
}

例三：可以直接用C++标准库中的函数
less<数据类型>()//从小到大排序

greater<数据类型>()//从大到小排序

#include<iostream>
 
#include<algorithm>
 
using namespace std;
 
int main()
 
{
 
 int a[10]={9,6,3,8,5,2,7,4,1,0};
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
sort(a,a+10,less<int>());
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
 return 0;
 
}
 
 
 
 
#include<iostream>
 
#include<algorithm>
 
using namespace std;
 
int main()
 
{
 
 int a[10]={9,6,3,8,5,2,7,4,1,0};
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
 sort(a,a+10,greater<int>());
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
 return 0;
 
}

例四：利用sort函数还可以实现对字符的排序
即对字符ASCII码的排序

#include<iostream>
 
#include<algorithm>
 
using namespace std;
 
int main()
 
{
 
 char a[11]="asdfghjklk";
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
 sort(a,a+10,greater<char>());
 
 for(int i=0;i<10;i++)
 
 cout<<a[i]<<endl;
 
 return 0;
 
}

cin和getline

C++中使用cin和cout比较方便，但是输入输出效率比scanf和printf低，故有些算法题如果对时间复杂度要求高，可以将cin和cout改成scanf和printf。

使用cin可以输入数字或字符，字符串，但是接受字符串时遇到“空格”“TAB”“回车”就会结束，因此需要cin.getline()或者getline

cin.getline()为istream流

#include <iostream>
using namespace std;
main ()
{
char m[20];
cin.getline(m,5);
cout<<m<<endl;
}

输入：jkljkljkl
输出：jklj

接收5个字符到m中，其中最后一个为’\0’，所以只看到4个字符输出；
1、cin.getline()实际上有三个参数，cin.getline(接收字符串的变量,接收字符个数,结束字符)
2、当第三个参数省略时，系统默认为’\0’
3、如果将例子中cin.getline()改为cin.getline(m,5,‘a’);当输入jlkjkljkl时输出jklj，输入jkaljkljkl时，输出jk

getline()为string流
用法：接收一个字符串，可以接收空格并输出，需包含“#include”

#include<iostream>
#include<string>
using namespace std;
main ()
{
string str;
getline(cin,str);
cout<<str<<endl;
}

输入：jkljkljkl
输出：jkljkljkl

输入：jkl jfksldfj jklsjfl
输出：jkl jfksldfj jklsjfl

注意：getline()不读取换行符，默认遇到换行符或EOF结束，（也可以在括号中第三个位置设置结束标志）所以如果在使用getline()之前有用scanf输入或者用scanf()，则需要用getchar()吃掉换行符才能继续输入。
注意：如果前面有cin输入，后面有getline，可以用**cin.ignore()**清除掉缓冲区的符号，否则后面的getline会读取缓冲区的回车键。

for循环一些看法

最普通的for循环如下

for ( int i = 0; i < 10; i++){
	//cout<<i<<endl;
}

for循环的执行逻辑如下

  1. 初始化变量，int i = 0
  2. 判断i < 10
  3. 执行循环体内的代码
  4. 变量自增，i++或者++i

那么，不难看出，不管使用++i还是i++，对最终的计算结果其实是没有区别的。

bool变量

bool变量有两个值，true和false，而C++把所有非0的数解释为true，0解释为false，所以直接赋值⼀个数字给 bool 变量也是可以的～它会⾃动根据 int 值是不是零来决定给 bool 变量赋值 true 还是 false

bool flag = true;
bool flag2 = -2; // flag2为true
bool flag3 = 0; // flag3为false

const

const是C++特有的用const这个限定符定义常量，这样做有个好处就是可以定义常量的类型，⽐如 int 类型的常量 a 这样定义：

const int a = 99999999;

C++结构体和C的一些区别

定义好结构体 stu 之后，使⽤这个结构体类型的时候，C语⾔需要写关键字 struct ，⽽C++⾥⾯可以省略不写：

struct stu {
 int grade;
 float score;
};
struct stu arr1[10]; // C语⾔⾥⾯需要写成struct stu
stu arr2[10];// C++⾥⾯不⽤写struct，直接写stu就好了～

C++的引用&和传值的区别

&在C语言中是取址运算符，而在C++中是引用，即引用变量。

void func(int &a) { // 传⼊的是n的引⽤，相当于直接对n进⾏了操作，只不过在func函数中换了个名
字叫a
 a = 99;
}
int main() {
 int n = 0;
 func(n); // n由0变成了99
}

void func(int a) {// 传⼊的是0这个值，并不会改变main函数中n的值
 a = 99;
}
int main() {
 int n = 0;
 func(n);// 并不会改变n的值，n还是0
}

strlen

strlen()函数用于求字符串的长度。且只能求到“\0”字符串前面的字符串(不包括“\0”)，(C语言规定，字符串必须以’\0’字符作为最后一个字符，表示字符串的结束字符)。
定义字符串数组后，一定要初始化。
为什么呢，看一下例子：

#include<bits/stdc++.h>
using namespace std;
int main()
{
    char test[50];
    for(int i=0;i<26;i++)
    {
        test[i]='A'+i;
        cout<<test[i]<<" ";
    }
    cout<<strlen(test)<<endl;
}

在这里插入图片描述
这里没有初始化char数组，输出的strlen值为27，并不是我们想要的26。

#include<bits/stdc++.h>
using namespace std;
int main()
{
    char test[50]={0};
    for(int i=0;i<26;i++)
    {
        test[i]='A'+i;
        cout<<test[i]<<" ";
    }
    cout<<strlen(test)<<endl;
    return 0;
}

在这里插入图片描述
初始化了之后，就能得到正确的结果啦
最后一个点就是，strlen函数得到的是一个无符号的整型，即不小于0的整数。

min和max

用法：min(a,b), max(a,b)
注意：直接调用min和max函数只能比较两个数！！！若比较两个以上会报错，可以用max(max(a,b),c)这样的方法或者自己定义函数(自己定义函数要注意，C++是从上往下执行的，所以main函数如果要调用自己定义的max或min函数应该将max或min函数的代码块写在main的上面，下面才可以调用)

lower_bound( )和upper_bound( )

lower_bound( )和upper_bound( )都是运用二分查找的方法进行查找，作用的对象都是已经排好序的数组。

在从小到大的排序数组中：

  • lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。
  • upper_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。

在从大到小的排序数组中：

  • lower_bound( begin,end,num,greater() ):从数组的begin位置到end-1位置二分查找第一个小于或等于num的数字，找到返回该数字的地址，不存在则返回end。
  • upper_bound( begin,end,num,greater() ):从数组的begin位置到end-1位置二分查找第一个小于num的数字，找到返回该数字的地址，不存在则返回end。

通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

accumulate

accumulate用来做累加或者累乘操作。
有三个参数：

  • _First：指定范围内第一个迭代的值或者结合操作选项使用。
  • InputIterator _Last：指定范围内最后一个迭代值或者结合操作项使用。
  • _Val：要计算的初始值。
  • _Binary_op：运用于指定范围内所有元素和前面计算得到结果的参数。

需要注意的是：第三个参数是什么类型，即初始值是什么类型，返回的结果就是什么类型。

这样直接看有点抽象，直接用例子来理解。

求和

#include<bits/stdc++.h>
using namespace std;
int main()
{
    vector<int>v;
    vector<int>::iterator iter;
    int i;
    for(i=0;i<21;i++)
    {
        v.push_back(i);
    }
    for(iter=v.begin();iter!=v.end();iter++)
    {
        cout<<*iter<<" ";
    }
    int total;
    total=accumulate(v.begin(),v.end(),0);
    cout<<endl<<total<<endl;
}

在这里插入图片描述
求前n项和

#include<bits/stdc++.h>
using namespace std;
int main()
{
    vector<int>v1,v2(20);
    vector<int>::iterator iter1,iter2;
    int i;
    for(i=0;i<21;i++)
    {
        v1.push_back(i);
    }
    int j=0,partotal;
    for(iter1=v1.begin()+1;iter1!=v1.end();iter1++)
    {
        partotal=accumulate(v1.begin(),iter1,0);
        v2[j++]=partotal;
    }
    for(iter2=v2.begin();iter2!=v2.end();iter2++)
    {
        cout<<*iter2<<" ";
    }
    //for(int k=0;k<j;k++)
    //{
    //    cout<<v2[k]<<" ";
    //}
    return 0;
}

在这里插入图片描述
求积

#include<bits/stdc++.h>
using namespace std;
int main()
{
    vector<int>v1;
    vector<int>::iterator iter1;
    int i;
    for(i=1;i<11;i++)
    {
        v1.push_back(i);
    }
    int ptotal;
    ptotal=accumulate(v1.begin(),v1.end(),1,multiplies<int>());
    cout<<ptotal<<endl;
    return 0;
}

在这里插入图片描述
求前n项的积

在这里插入代码片

max_element和min_element

max_element和min_element用来求vector或数组的最大值最小值，返回的是迭代器或指针，可以用*来获取值。
数组

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int a[]={3,6,8,2};
    int len=sizeof(a)/sizeof(int);
    //求出数组a的长度
    cout<<*max_element(a,a+len)<<endl;
    cout<<max_element(a,a+len)<<endl;
    cout<<*min_element(a,a+len)<<endl;
    cout<<min_element(a,a+len)<<endl;
    return 0;
}

在这里插入图片描述

vector容器

#include<bits/stdc++.h>
using namespace std;
int main()
{
    vector<int>v;
    v.push_back(7);v.push_back(4);
    v.push_back(2);v.push_back(9);
    cout<<*max_element(v.begin(),v.end())<<endl;
    cout<<*min_element(v.begin(),v.end())<<endl;
    return 0;
}

在这里插入图片描述
注意：vector数组时，不能输出指针地址，只能输出指针的值。

string和int相互转换

string转换为int
这个是把string转化为char p再转化为int

string str;
const char*p=str.c_str();
int i=atoi(p);

这个直接把string转化为int，更方便

string str;
int i=stoi(str);

int转换为string

int n;
string s=to_string(n);

stoi,stoll,stof,stod

stoi将string转化为int
stoll将string转化为long long
stof将string转化为float
stod将string转化为double
用法见上个标题

char和string

  1. char是字符型变量，string是字符串型变量，字符串是由各个字符组成的，char默认最后一位是“\0”，而string没有这个默认。
  2. 字符用单引号‘ ’，字符串用双引号“ ”。
  3. 如果只写字符数组，代表的其实是该字符数组的首地址。
  4. 用占位符时，“&d”为int类型，“&s”为字符串类型，“&c”为字符类型.

?:三目运算符

真的超级方便超级好用的运算符！！！
用法：表达式1？表达式2：表达式3
如果表达式1为真，则执行表达式2，否则执行表达式3
但是在具体操作时应注意运算的优先级，<<的优先级是大于？的，所以在使用时记得加括号加括号！！

cout<<((grade < 60) ?  "fail" :  "pass");//输出pass或者fail
cout<<(grade < 60 ) ?  "fail" :  "pass" ;//输出0或者1
cout<<grade < 60 ?  "fail" :  "pass" ; //错误的，这个代码试图比较cout和60

上面代码中第二条语句等价于：

cout<<(grade < 60 ) ?  "fail" :  "pass" ;//输出0或者1
//等价于：
cout<< (grade < 60 ) ;//输出0或者1 （0表示真，1表示假）
cout ？ "fail" : "pass" ; //根据cout的值是真还是假产生对应的字面值

上面代码中第三条语句等价于：

cout<<grade < 60 ?  "fail" :  "pass" ; //错误的，这个代码试图比较cout和60
//等价于：
cout<< grade ; // 小于运算符的优先级低于移位运算符，所以先输出grade 
cout << 60 ? "fail" : "pass" ;//比较cout和60错误的

ASCII相加减

用来处理字符串中的数字超级方便

string s="123456";
int i=s[4]+'0';
int j=s[5]-'2';

这里的加减实际上是ASCII码的相加减，i就等于5（理解为5+0），j等于4（理解为6-2），这样就超级方便啦，不用像本篇上面所做笔记将string转化为char再利用atoi转化为int。不过只限于单个位的好像…

字符串一些函数

isalpha

真就返回1，否则返回0

toupper和tolower

顾名思义，就是转化为大写和小写，用在单个字符这个维度

do while

可以用来表示至少执行一次，先执行再判断

do
	循环语句;
while(表达式);
//while后面有分号
不想离开床
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++二分查找相关函数用法总结
pipi糖的博客
04-17 3305
一、lower_bound()函数 函数lower_bound(begin,end,num)在begin和end中的前闭后开区间，进行二分查找。返回从begin开始的第一个大于或等于val的元素的地址。如果所有元素都小于val，则返回end的地址。 注意： 如果所有元素都小于val，则返回end的位置，且end的位置是越界的！！ 数组必须是排好序的数组(升序)。 #include<algorithm> // lower_bound(a.begin(), a.end(), 11) 等同于 a.
二分查找函数的使用
Wuko666的博客
11-25 900
二分查找函数的使用 lower_bound( )和upper_bound( )都是利用二分查找的方法在一个排好序的数组中进行查找的。 在从小到大的排序数组中， lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。 upper_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大
彻底搞懂二分查找区间
学习者的博客
02-12 581
是不是一直烦恼于二分查找区间是小于，还是小于等于，这次帮你彻底搞懂~~
详解二分查找，包括左闭右闭，左闭右开，以及其他变种问题
lyx7762的博客
01-15 1650
详解二分查找，包括左闭右闭，左闭右开，以及其他变种问题
39、【查找】二分查找：数的范围和查找某个数（C/C++版）
STAR GAME
04-19 3283
算法思想 二分查找（折半查找） 是针对有序序列的一种快速查找方式，与高中时候数学中学的二分法有异曲同工之处。通过不断缩小目标值所在区间的范围实现快速查找到目标值。每次将目标值与区间内的中位数进行比较，比中位数小则在中位数的做区间内再查找，如果比中位数大则在中位数的有区间内再查找，以相同的规则作用于缩小后的区间，以此类推最终便可找到结果。 本质上二分查找是针对某种序列划分出具有不同性质的两种区间，当mid落在在不同性质区间内，对区间进行相应的变化，从而找到我们需要的目标。 不仅仅可针对有单调性的序列，同时对于
C++的函数重载
02-27
——每个现象后面都隐藏一个本质，关键在于我们是否去挖掘写在前面：函数重载的重要性不言而明，但是你知道C++中函数重载是如何实现的呢（虽然本文谈的是C++中函数重载的实现，但我想其它语言也是类似的）？...
C++Sleep函数用法
10-15
C++Sleep函数用法，很详细，有头文件，不懂可以私信我
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
c++内置函数
04-03
谭浩强老师c++课本第一章内置函数例题，c++内置函数使用用例。
浅析C++ 仿函数
08-24
主要介绍了C++ 仿函数的相关资料，帮助大家更好的理解和学习c++，感兴趣的朋友可以了解下
二分查找算法函数功能： 二分查找
11-27
C 语言中效率最高的查找方式，非常实用。经常用于一些嵌入式算法中。函数名称： int BinarySearch(int *a, int num) 函数功能： 二分查找 入口参数： 待查找有序表的首地址 int *a 待查找的数据 int num 出口参数： 查找成功返回数据在有序表中的位置0 ~ n-1，不成功返回 -1
关于二分查找变体的笔记：查找小于等于目标值的数的个数、查找严格小于目标值的数的个数
qq_41888672的博客
08-19 186
关于二分查找变体的笔记：查找小于等于目标值的数的个数、查找严格小于目标值的数的个数
数的范围-二分查找的实现
jeazim的博客
02-27 183
二分查找是一个非常常用的算法，但在写二分代码时经常容易出现错误。
二分查找（C语言）
ikun10001的博客
04-17 7011
二分查找，又称为折半查找，是一种在有序数组中查找指定目标的搜索算法。该算法通过将目标值与数组中间的元素进行比较来逐步缩小搜索范围，直到找到目标元素或发现其不存在为止。
preNoip|CSP-S1中时间复杂度的计算
nan
10-03 714
特征方程法解一阶线性代数递推式 数列{ana_nan​}满足a1=b,an+1=can+da_1=b,a_{n+1}=ca_n+da1​=b,an+1​=can​+d，求该数列的通项公式 针对递推关系式作出一个特征方程x=cx+dx=cx+dx=cx+d 定理：设上述递推关系式的特征方程根为x0x_0x0​ 当x0=a1x_0=a_1x0​=a1​时，an=a1a_n=a_1an​=a1​ ...
704二分查找法--搜索区间
qq_44733706的博客
12-28 2818
二分查找法是算法学习中很基础的算法，但是其也是很重要的算法，将二分查找法搞明白对后续算法的学习有着事半功倍的作用。本体难点：二分的判断。
用函数实现二分查找(C语言)
qq_63920363的博客
12-31 356
二分查找的算法思想：每次取数组下标的中间值，然后查找下标对应的值对比查找数的大小，然后确定第二次查找范围，再取中间下标，再对比下标所对应的值和想查找的值，一直循环，直到下标对应值与查找值相同。 注意：二分查找只适用于有序整数数组。 先定义函数，实现查找，找到返回数组下标值，找不到返回-1。 注意： 函数在传数组时不会把数组全部传上去，而是把首元素地址传上去，所以要求元素个数时，要在主函数（main）内求，然后再传给函数，如果在自定义函数求形参数组元素个数时，结果数组元素是1.会导致左下标（left）等
小朋友学C++（46）： lower_bound()和upper_bound()
小树学信奥
02-05 286
lower_bound( )和upper_bound( )都是利用二分查找的方法在一个排好序的数组中进行查找的。 在从小到大的排序数组中， lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。 upper_bou...
lower_bound()函数与upper_bound()函数
Coding
09-17 1075
二分查找 lower_bound() 返回的是位置 查找第一个不小于目标的数/查找最后一个小于目标的数 int find(vector<int>&arr,int target){ int left=0,right=arr.size();//左闭右开 while(left<right){ int mid=left+(right-left)/2; if(arr[m...
devc++时间函数
最新发布
06-03
Dev-C++ 是一个基于MinGW的C/C++语言集成开发环境，它内置了一些基本的时间函数。下面是一些常用的Dev-C++时间函数： 1. time()函数：返回当前系统时间（自1970年1月1日0时起的秒数），其返回值类型为time_t。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值