标签：begin end int bound 笔记 lower num c++

c++ fill和memset函数区别

参考

• memset函数
  • 按照字节填充某字符
  • 在头文件cstring里面
• fill函数
  • 按照单元赋值，将一个区间的元素都赋同一个值
  • 在头文件algorithm里面
• 因为memset函数按照字节填充，所以一般memset只能用来填充char型数组，（因为只有char型占一个字节）如果填充int型数组，除了0和-1，其他的不能。因为只有00000000 = 0，-1同理，如果我们把每一位都填充“1”，会导致变成填充入“11111111”
• 而fill函数可以赋值任何，而且使用方法特别简便：
  • fill(arr, arr + n, 要填入的内容);
  • 例如：

#include <cstdio>
#include <algorithm>
using namespace std;
int main() {
    int arr[10];
    fill(arr, arr + 10, 2);
    return 0;
}

• vector也可以：

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main(){
    vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    fill(v.begin(), v.end(), -1);
    return 0;
}    

• 而memset的使用方法是：

#include <iostream>
#include <cstring>
using namespace std;
int main(){
    int a[20];
    memset(a, 0, sizeof a);
    return 0;
}

---

c++ 求和运算

accumulate定义在#include中，作用有两个，一个是累加求和，另一个是自定义类型数据的处理

accumulate(s.begin(), s.end(), 0)

accumulate带有三个形参：头两个形参指定要累加的元素范围，第三个形参则是累加的初值

#include <iostream>
#include <cstring>
#include<set>
#include<numeric>
using namespace std;
int main(){
    int a[5] = {4,1,2,1,2};
    set<int> s(a,a+5);
    set<int> s2;
	cout<< accumulate(s.begin(),s.end(), 0) ;
//	adjacent_difference(s.begin(), s.end(), b);
	for (auto n : s) {
        std::cout << n << ' ';
    }
    return 0;
}

// 实现将 字符拼接成一个string
int main(){
	set<char> v = {'a', 'b' ,'c'};
	string sum = accumulate(v.begin() , v.end() , string(""));
	cout<<sum;
	return 0;
}

// 自定义的数据类型
struct Grade
{
	string name;
	int grade;
};
 
int main()
{
	Grade subject[3] = {
		{ "English", 80 },
		{ "Biology", 70 },
		{ "History", 90 }
	};
 
	int sum = accumulate(subject, subject + 3, 0, [](int a, Grade b){return a + b.grade; });
	cout << sum << endl;
 
	system("pause");
	return 0;
}

---

c++ 中的lower_bound()函数，upper_bound()函数及其应用

C++ Refference

• 默认版本

template <class ForwardIterator, class T>
 ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,
                               const T& val);

• 自定义比较函数版

template <class ForwardIterator, class T, class Compare>
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,
                               const T& val, Compare comp);

第一个first参数是一段连续空间的首地址，last是连续空间末端的地址，val是要查找的值。调用lower_bound()的前提是这段连续的空间里的元素是有序（递增）的。
然后lower_bound()的返回值是第一个大于等于val的值的地址，用这个地址减去first，得到的就是第一个大于等于val的值的下标。

在自定义版本里有一个comp参数，它的用处在于，当你要查找的不是基本数据类型，而是自己定义比较函数。

• 从小到大的排序数组中

lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

upper_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

• 从大到小的排序数组中

lower_bound( begin,end,num,greater() ):从数组的begin位置到end-1位置二分查找第一个小于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

upper_bound( begin,end,num,greater() ):从数组的begin位置到end-1位置二分查找第一个小于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

• 例子

#include<iostream>
using namespace std;
const int maxn=100000+10;
const int INF=2*int(1e9)+10;
#define LL long long
int cmd(int a,int b){
	return a>b;
}
int main(){
	int num[6]={1,2,4,7,15,34}; 
	sort(num,num+6);                           //按从小到大排序 
	int pos1=lower_bound(num,num+6,7)-num;    //返回数组中第一个大于或等于被查数的值 
	int pos2=upper_bound(num,num+6,7)-num;    //返回数组中第一个大于被查数的值
	cout<<pos1<<" "<<num[pos1]<<endl;
	cout<<pos2<<" "<<num[pos2]<<endl;
	sort(num,num+6,cmd);                      //按从大到小排序
	int pos3=lower_bound(num,num+6,7,greater<int>())-num;  //返回数组中第一个小于或等于被查数的值 
	int pos4=upper_bound(num,num+6,7,greater<int>())-num;  //返回数组中第一个小于被查数的值 
	cout<<pos3<<" "<<num[pos3]<<endl;
	cout<<pos4<<" "<<num[pos4]<<endl;
	return 0;	
} 

#include <iostream>
#include <algorithm>
using namespace std;
struct point{
    point(){

    }
    point(int _x, int _y){
        x = _x;
        y = _y;
    }
    int x;
    int y;
};

bool cmp(point a, point b){
    return a.x < b.x;
}
int main(int argc, char *argv[]){
    point a[5];

    a[0].x = 1;
    a[0].y = 100;

    a[1].x = 100;
    a[1].y = 1;

    a[2].x = 30;
    a[2].y = 50;

    a[3].x = 25;
    a[3].y = 120;

    a[4].x = 301;
    a[4].y = 103;
    // 随便赋值
    sort(a, a + 5, cmp);
    // 先排序
    for (int i = 0; i < 5; i++){
        printf("a[%d].x = %d, a[%d].y = %d\n", i, a[i].x, i, a[i].y);
    }
    // 输出会发现他们按照x从小到大排序了
    cout << (lower_bound(a, a + 5, point(1, 1000), cmp) - a) << endl;
    // 第一个x值大于1的元素是(1, 100)这个元素，它的下标为0
    cout << (lower_bound(a, a + 5, point(101, 1000), cmp) - a) << endl;
    // 第一个x值大于101的元素是(301, 103)这个元素，它的下标为4
    cout << (lower_bound(a, a + 5, point(1000, 1000), cmp) - a) << endl;
    // 因为找不到所以返回a + 5，再减a就是5
    
}

• 应用

给定一个已经排序的整数型数组和一个指定的目标值，找出目标值在该数组中出现的起始位置，如果不存在，返回[-1, -1]。例如：输入数组[5, 7, 7, 8, 8, 10] 和 数字8， 输出[3, 4]。

// 使用库函数
class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        const int l = distance(nums.begin(), lower_bound(nums.begin(), nums.end(), target));
        const int u = distance(nums.begin(), prev(upper_bound(nums.begin(), nums.end()
        if (nums[l] != target) // not found
        	return vector<int> { -1, -1 };
        else
        	return vector<int> { l, u };
    }
};

// 使用自定义的函数
public:
    vector<int> searchRange (vector<int>& nums, int target) {
        auto lower = lower_bound(nums.begin(), nums.end(), target);
        auto uppper = upper_bound(lower, nums.end(), target);
        if (lower == nums.end() || *lower != target)
        	return vector<int> { -1, -1 };
        else
        	return vector<int> {distance(nums.begin(), lower), distance(nums.begin(), pre
    }
    template<typename ForwardIterator, typename T>
        ForwardIterator lower_bound (ForwardIterator first,
        	ForwardIterator last, T value) {
        while (first != last) {
            auto mid = next(first, distance(first, last) / 2);
            if (value > *mid) 
                first = ++mid;
            else 
                last = mid;
            }
        return first;
    }
    template<typename ForwardIterator, typename T>
        ForwardIterator upper_bound (ForwardIterator first,
        	ForwardIterator last, T value) {
        while (first != last) {
            auto mid = next(first, distance (first, last) / 2);
            if (value >= *mid) 
                first = ++mid; // 与lower_bound 仅此不同
            else 
                last = mid;
        }
        return first;
    }
};

• 点赞
• 收藏
• 分享
• • 文章举报

小耗子Deng 发布了61 篇原创文章 · 获赞 11 · 访问量 1万+ 私信 关注

标签：begin,end,int,bound,笔记,lower,num,c++
来源： https://blog.csdn.net/HaoTheAnswer/article/details/104417828

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。