STL库--算法

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量40 收藏
点赞数
分类专栏： STL C++ 文章标签： 算法 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45704263/article/details/131513910
版权
C++ 同时被 2 个专栏收录
59 篇文章 0 订阅
订阅专栏
STL
23 篇文章 0 订阅
订阅专栏
本文详细介绍了C++标准库中的几种常见算法，包括遍历（如for_each）、查找（如find、find_if、adjacent_find）、排序（如sort、stable_sort）、部分排序（如partial_sort）以及集合操作（如set_intersection、set_union）。这些算法提高了代码效率，简化了编程任务。
摘要由CSDN通过智能技术生成

头文件#include<algorithm>

常用的遍历算法

for_each()

作用：遍历指定范围内的元素，并对每个元素调用传入的操作函数。

函数原型

        template <class InputIterator, class Function>

        Function for_each(InputIterator first, InputIterator last, Function fn);

参数

        InputIterator：是输入迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器（不包含在范围内）。

        fn：是要执行的操作函数。操作函数可以是普通函数、函数对象或lambda表达式。该函数没有返回值，仅用于执行操作

例：

#include <iostream>

#include <vector>

#include <algorithm>



void print(int num) {

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

}



int main() {

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



    std::for_each(nums.begin(), nums.end(), print);



    return 0;

}

//1 2 3 4 5

transform()

作用：将指定容器区间元素搬运到另一容器中

函数原型

        template <class InputIterator, class OutputIterator, class UnaryOperation>

        OutputIterator transform(InputIterator first1, InputIterator last1, OutputIterator result, UnaryOperation op);

参数：

        InputIterator是输入迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first1是指向输入范围起始位置的迭代器。

                last1是指向输入范围结束位置的迭代器（不包含在范围内）。

        OutputIterator是输出迭代器类型，用于指定存储结果的范围的起始位置。

                result是指向输出范围起始位置的迭代器。

        op是要应用的操作函数，可以是函数指针、函数对象或lambda表达式。

注意：

        1.transform 不会给目标容器分配内存， 所以需要我们提前分配好内存

        2.容器类型要相同

例：

		#include <iostream>
		#include <vector>
		#include <algorithm>
		
		int doubleValue(int num) {
		    return num * 2;
		}
		
		int main() {
		    std::vector<int> nums = {1, 2, 3, 4, 5};
		    std::vector<int> doubledNums(nums.size());
		
		    std::transform(nums.begin(), nums.end(), doubledNums.begin(), doubleValue);
		
		    for (int num : doubledNums) {
		        std::cout << num << " ";
		    }
		
		    return 0;
		}
		//2 4 6 8 10

常用查找算法

find()

作用：查找区间[begin，end)中是否存在元素。若有，则返回该位置的迭代器，若没有，则返回end()

函数原型

        template <class InputIterator, class T>

        InputIterator find(InputIterator first, InputIterator last, const T& value);

参数

        InputIterator是输入迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器（不包含在范围内）。

        T是要查找的值的类型。

                value是要查找的值。

例：对普通成员  

int main()
{
    vector<int> v1;
    v1.push_back(18);
	v1.push_back(28);
	v1.push_back(19);
	v1.push_back(38);
		
	vector<int>::iterator ret;
	ret=find(v1.begin(),v1.end(),28);
	if(ret != v1.end()) cout<<"找到的数据为:"<<*ret<<endl;
	else cout<<"未找到"<<endl;
	return 0;
}

  例：对自定义成员

class Person
{
public:
	string name;
	int age;
	Person(string name,int age){
		this->name=name;
		this->age=age;
	}
	bool operator==(const Person &ob){
		if(this->name==ob.name && this->age==ob.age)    return true;
		return false;
	}
};

int main()
{
	vector<Person> v2;
	v2.push_back(Person("德玛西亚",18));
	v2.push_back(Person("小法",19));
	v2.push_back(Person("小炮",20));
	v2.push_back(Person("牛头",21));

	Person tmp("小炮",20);
	vector<Person>::iterator ret;
	ret=find(v2.begin(),v2.end(),tmp);
	if(ret != v2.end()) cout<<"找到的数据为:"<<(*ret).name<<" "<<(*ret).age<<endl;
	else cout<<"未找到"<<endl;
	return 0;
}

find_if()

作用：在指定范围内查找满足指定条件的元素，并返回指向该元素的迭代器。

函数原型：

        template <class InputIterator, class UnaryPredicate>

        InputIterator find_if(InputIterator first, InputIterator last, UnaryPredicate pred);

参数：

        InputIterator是输入迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器（不包含在范围内）。

        UnaryPredicate是一个一元谓词（接受一个参数并返回一个bool值的函数对象或函数指针），用于指定要满足的条件。

                pred是一个一元谓词，用于指定要满足的条件。

例：普通函数

bool myGreaterThan20(int val)

{

    return val>20;

}



int main()

{

    vector<int> v2;

    v2.push_back(10);

    v2.push_back(20);

    v2.push_back(30);

    v2.push_back(40);



    vector<int>::iterator ret;

    ret=find_if(v2.begin(),v2.end(),myGreaterThan20);

    if(ret != v2.end()) cout<<"找到的数据为:"<<*ret<<endl;

    else cout<<"未找到"<<endl;

    return 0;

}

例：仿函数

class MyGreaterThan20{

public:

    bool operator()(int val)

    {

        return val>20;

    }

};



int main()

{

    vector<int> v2;

    v2.push_back(10);

    v2.push_back(20);

    v2.push_back(30);

    v2.push_back(40);



    vector<int>::iterator ret;

    ret=find_if(v2.begin(),v2.end(),MyGreaterThan20());

    if(ret != v2.end()) cout<<"找到的数据为:"<<*ret<<endl;

    else cout<<"未找到"<<endl;

    return 0;

}

adjacent_find()

作用：在指定范围内查找相邻的重复元素，并返回指向第一个重复元素的迭代器。

函数原型：

        template <class ForwardIterator>

        ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);

参数：

        ForwardIterator是前向迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器（不包含在范围内）。

例1：普通数据

int main()

{

    vector<int> v1;

    v1.push_back(10);

    v1.push_back(20);

    v1.push_back(20);

    v1.push_back(40);

    v1.push_back(50);

    v1.push_back(50);



    vector<int>::iterator ret;

    ret=adjacent_find(v1.begin(),v1.end());

    if(ret!=v1.end())   cout<<"寻找到重复元素:"<<*ret<<endl;

    return 0;

}

例2：自定义数据（对==进行运算符重载）

class Person

{

public:

    string name;

    int age;

    Person(string name,int age){

        this->name=name;

        this->age=age;

    }

    bool operator==(const Person &ob){

        if(this->name==ob.name && this->age==ob.age)    return true;

        return false;

    }

};



int main()

{

    vector<Person> v2;

    v2.push_back(Person("德玛西亚",18));

    v2.push_back(Person("小法",19));

    v2.push_back(Person("小法",19));

    v2.push_back(Person("牛头",21));



    vector<Person>::iterator ret;

    ret=adjacent_find(v2.begin(),v2.end());

    if(ret != v2.end()) cout<<"找到的数据为:"<<(*ret).name<<" "<<(*ret).age<<endl;

    else cout<<"未找到"<<endl;

    return 0;

}

binary_search 

作用：在已排序的范围内，通过二分查找法查找指定的元素，并返回一个bool值表示是否找到。

函数原型：

        template <class ForwardIterator, class T>

        bool binary_search(ForwardIterator first, ForwardIterator last, const T& value);

参数

        ForwardIterator是前向迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器（不包含在范围内）。

        T是要查找的元素的类型。

                value是要查找的元素。

注意：容器必须有序

例：

int main()

{

    vector<int> v1;

    v1.push_back(10);

    v1.push_back(20);

    v1.push_back(30);

    v1.push_back(40);

    v1.push_back(50);



    bool ret=binary_search(v1.begin(),v1.end(),30);

    if(ret==true)   cout<<"找到"<<endl;

    else    cout<<"未找到"<<endl;

    return 0;

}

count

作用：遍历输入范围内的元素，统计等于给定值的元素的个数，并返回结果。

函数原型：

        template <class InputIterator, class T>

        typename iterator_traits<InputIterator>::difference_type count(InputIterator first,                 InputIterator last, const T& value);

参数：        

        InputIterator是输入迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器。

        T是要计数的元素的类型。

                value是要计数的元素。

例

int main()

{

    vector<int> v1;

    v1.push_back(10);

    v1.push_back(20);

    v1.push_back(30);

    v1.push_back(40);

    v1.push_back(50);



    cout<<count(v1.begin(),v1.end(),10)<<endl;

    return 0;

}

count_if

作用：遍历输入范围内的元素，统计满足指定条件的元素的个数，并返回结果。

函数原型：

        template <class InputIterator, class UnaryPredicate>

        typename iterator_traits<InputIterator>::difference_type count_if(InputIterator first,

                InputIterator last, UnaryPredicate pred);

参数              

        InputIterator是输入迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器。

        UnaryPredicate是一个一元谓词（即接受一个参数并返回一个bool值的函数对象或函数指针），用于指定判断条件。

                pred是用于判断元素是否满足条件的谓词函数。

例：统计大于10的元素出现的次数

bool myGreaterThan10(int val)

{

    return val>10;

}



class MyGreaterThan10

{

public:

    bool operator()(int val){

        return val>10;

    }

};



int main()

{

    vector<int> v1;

    v1.push_back(10);

    v1.push_back(20);

    v1.push_back(30);

    v1.push_back(40);

    v1.push_back(50);



    //普通函数

    cout<<count_if(v1.begin(),v1.end(),myGreaterThan10)<<endl;

    //函数对象

    cout<<count_if(v1.begin(),v1.end(),MyGreaterThan10())<<endl;

    //内建函数对象

    cout<<count_if(v1.begin(),v1.end(),bind2nd(greater<int>(),10))<<endl;

    return 0;

}

max_element

作用：遍历输入范围内的元素，找到最大的元素，并返回指向该元素的迭代器。

函数原型：

        template <class ForwardIterator>

        ForwardIterator max_element(ForwardIterator first, ForwardIterator last);

参数

        ForwardIterator是前向迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器。

例：

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

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



    auto maxIt = std::max_element(nums.begin(), nums.end());



    std::cout << "Max element: " << *maxIt << std::endl;



    return 0;

}

min_element

作用：遍历输入范围内的元素，找到最小的元素，并返回指向该元素的迭代器。

函数原型：

        template <class ForwardIterator>

        ForwardIterator min_element(ForwardIterator first, ForwardIterator last);

参数：

        ForwardIterator是前向迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器。

例：

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

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



    auto minIt = std::min_element(nums.begin(), nums.end());



    std::cout << "Min element: " << *minIt << std::endl;



    return 0;

}

minmax_element

作用：在给定范围内查找最小值和最大值的迭代器。

函数原型：

        template <class ForwardIt>

        std::pair<ForwardIt, ForwardIt> minmax_element(ForwardIt first, ForwardIt last);

参数

        ForwardIterator是前向迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器。

例：

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

    std::vector<int> values = {5, 3, 9, 2, 7};



    auto minmaxIt = std::minmax_element(values.begin(), values.end());



    std::cout << "Min value: " << *minmaxIt.first << std::endl;

    std::cout << "Max value: " << *minmaxIt.second << std::endl;



    return 0;

}

nth_element

作用：对给定范围内的元素进行部分排序。使得nth之前的元素都小于等于它，nth之后的元素都大于等于它，而第n小的值恰好在nth位置上。

函数原型：

        template <class RandomIt>

        void nth_element(RandomIt first, RandomIt nth, RandomIt last);

参数

        RandomIt是迭代器类型，用于指定要排序的范围。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器。

        nth是迭代器，表示要将第n个元素放置的位置。

例

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

    std::vector<int> values = {5, 3, 9, 2, 7};



    std::nth_element(values.begin(), values.begin() + 2, values.end());



    std::cout << "Third element: " << values[2] << std::endl;



    return 0;

}

常用排序算法

is_sorted

作用：检查给定范围内的元素是否按升序排序。

函数原型：

        template <class ForwardIt>

        bool is_sorted(ForwardIt first, ForwardIt last);

参数：

        ForwardIterator是前向迭代器类型，用于指定要遍历的范围的起始和结束位置。

                first是指向范围起始位置的迭代器。

                last是指向范围结束位置的迭代器。

例：

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

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



    bool sorted = std::is_sorted(values.begin(), values.end());



    if (sorted) {

        std::cout << "The range is sorted." << std::endl;

    } else {

        std::cout << "The range is not sorted." << std::endl;

    }



    return 0;

}

merge

作用：将两个已排序的容器元素合并， 并存储到另一容器中

注意：每个容器必须有序，不是单纯的追加

函数原型：

        template <class InputIt1, class InputIt2, class OutputIt>

        OutputIt merge(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first);

                InputIt1和InputIt2是迭代器类型，用于指定要合并的两个已排序范围。

                OutputIt是迭代器类型，用于指定合并后的范围的目标位置。

                        first1和last1是迭代器，表示第一个已排序范围的起始和结束位置。

                        first2和last2是迭代器，表示第二个已排序范围的起始和结束位置。

                d_first是迭代器，表示合并后的范围的起始位置。

例：

int main()

{

    vector<int> v1;

    v1.push_back(10);

    v1.push_back(20);

    v1.push_back(30);

    v1.push_back(40);

    v1.push_back(50);



    vector<int> v2;

    v2.push_back(8);

    v2.push_back(9);

    v2.push_back(12);

    v2.push_back(22);

    v2.push_back(58);





    vector<int> v3;

    v3.resize(v1.size()+v2.size());

    merge(v1.begin(),v1.end(),v2.begin(),v2.end(),v3.begin());



    for_each(v3.begin(),v3.end(),[](int val){

        cout<<val<<" ";

    });

    return 0;

}

sort

作用：容器元素排序。

注意：默认使用比较函数来对元素进行排序，如果需要自定义排序的方式，可以将谓词做完第三个参数

函数原型：

        template<class RandomIt>

        void sort(RandomIt first, RandomIt last);

        template<class RandomIt, class Compare>

        void sort(RandomIt first, RandomIt last, Compare comp);

参数：

        RandomIt是一个迭代器类型，用于指向排序范围中的元素。

                first和last参数分别指定了排序范围的起始位置和结束位置。

例：

//对a数组的[1,n]位置进行从小到大排序

sort(a + 1, a + 1 + n);



//对a数组的[0,n-1]位置从大到小排序

sort(a, a + n, greater<int>());

//对a数组的[0,n-1]位置从小到大排序

sort(a, a + n, less<int>());



//自定义排序，定义比较函数

bool cmp1(node x,node y){

    return x.s>y.s;   //定义降序排序（从大到小）

}

bool cmp2(node x,node y){

    return x.k<y.k;   //定义升序排序（从小到大）

}

partial_sort

作用：部分排序，将[beg,mid)之间的元素排序，剩余的元素则不保证有序。

注意：默认使用比较函数来对元素进行排序，如果需要自定义排序的方式，可以将谓词做完第三个参数

函数原型：

        template<class RandomIt>

        void partial_sort(RandomIt first, RandomIt middle, RandomIt last);

        template<class RandomIt, class Compare>

        void partial_sort(RandomIt first, RandomIt middle, RandomIt last, Compare comp);

参数

        RandomIt是一个迭代器类型，用于指向排序范围中的元素。

                first和last参数分别指定了排序范围的起始位置和结束位置。

        middle参数指定了部分排序后的中间位置。

例：

int a[] = {1,2,5,4,7,9,8,10,6,3};

partial_sort(a, a + 5, a + 10);

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

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

//1 2 3 4 5 9 8 10 7 6

//前五个元素都有序



也可以添加自定义排序规则：partial_sort(beg,mid,end,cmp)

int a[] = {1,2,5,4,7,9,8,10,6,3};

partial_sort(a, a + 5, a + 10, greater<int>());

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

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

//10 9 8 7 6 1 2 4 5 3

//前五个元素降序有序

stable_sort

作用：和sort功能一样，特别之处在于stable_sort()能够保证相同元素的相对位置不变（稳定性）。

函数原型：

        template<class RandomIt>

        void stable_sort(RandomIt first, RandomIt last);

        template<class RandomIt, class Compare>

        void stable_sort(RandomIt first, RandomIt last, Compare comp);

参数：

        RandomIt是一个迭代器类型，用于指向排序范围中的元素。

                first和last参数分别指定了排序范围的起始位置和结束位置。

例：

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

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



    std::stable_sort(numbers.begin(), numbers.end());



    std::cout << "Sorted vector: ";

    for (const auto& num : numbers) {

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

    }

    std::cout << std::endl;



    return 0;

}

shuffle

作用：对指定范围内的元素随机调整次序。

注意：C++11之后应尽量使用shuffle来代替random_shuffle。

        原因：random_shuffle() 函数在重排元素时使用的是默认的随机数生成器，而这个生成器的随机性不够强，容易导致重排结果不够随机。而shuffle() 函数接受一个随机数生成器作为参数，可以使用更强大的随机数生成器来实现随机重排。

函数原型：

        template<class RandomIt>

        void shuffle(RandomIt first, RandomIt last);

        template<class RandomIt, class RandomFunc>

        void shuffle(RandomIt first, RandomIt last, RandomFunc&& rand);

参数：

        RandomIt是一个迭代器类型，用于指向重排范围中的元素。

                first和last参数分别指定了重排范围的起始位置和结束位置。

        rand参数可以指定一个随机数生成函数，该函数应该接受一个整数参数，并返回一个表示随机数的整数值。

例：

#include <iostream>

#include <algorithm>

#include <cstdlib>

#include <ctime>

#include <vector>



int main() {

    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};



    // 使用 srand() 函数设置随机数种子

    std::srand(std::time(0));



    // 使用默认的随机数生成器进行随机重排

    std::shuffle(numbers.begin(), numbers.end(), std::default_random_engine(std::rand()));



    // 输出重排后的数组

    for (const auto& number : numbers) {

        std::cout << number << " ";

    }

    std::cout << std::endl;



    return 0;

}

//为了使用 srand() 作为随机数生成器，我们将 std::rand() 的结果传递给 std::default_random_engine 类，以创建一个默认的随机数生成器

reverse

作用：翻转指定区间内的元素。

函数原型：

        template <class BidirectionalIterator>

        void reverse(BidirectionalIterator first, BidirectionalIterator last);

参数：

        BidirectionalIterator 是一个满足双向迭代器要求的类型

        双向迭代器要求：

                可以使用 ++ 运算符在正向方向上移动迭代器，即可以将迭代器向前移动到容器中的下一个元素。

                可以使用 -- 运算符在反向方向上移动迭代器，即可以将迭代器向后移动到容器中的上一个元素。

                支持解引用操作符 *，可以访问迭代器当前位置的元素。

                支持成员函数 !=，用于比较两个迭代器是否指向不同的元素。

                支持成员函数 ==，用于比较两个迭代器是否指向相同的元素。

        first和last参数分别指定了翻转范围的起始位置和结束位置。

案例

#include <iostream>

#include <algorithm>

#include <vector>



int main() {

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



    // 反转数组的元素

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



    // 输出反转后的数组

    for (const auto& number : numbers) {

        std::cout << number << " ";

    }

    std::cout << std::endl;



    return 0;

}

常用拷贝和替换算法

copy

作用：将范围 [first, last) 中的元素复制到以 result 作为起始位置的目标范围中，并返回复制结束的位置的迭代器。

函数原型：

        template <class InputIterator, class OutputIterator>

        OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);

参数：

        first：指向要复制的范围的起始位置的迭代器。

        last：指向要复制的范围的结束位置的迭代器（不包含在范围内）。

        result：指向复制的目标位置的迭代器。

案例

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

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

    std::vector<int> destination(5); // 目标容器，大小为5



    std::copy(source.begin(), source.end(), destination.begin());



    // 输出目标容器中的元素

    for (const auto& num : destination) {

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

    }

    std::cout << std::endl;



    return 0;

}

replace

作用：将范围 [first, last) 中所有等于 old_value 的元素替换为 new_value。

函数原型：

        template<class ForwardIterator, class T>

        void replace (ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);

参数：

        first：指向要替换的范围的起始位置的迭代器。

        last：指向要替换的范围的结束位置的迭代器（不包含在范围内）。

        old_value：要替换的旧值。

        new_value：要替换为的新值。

例：

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

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



    std::replace(numbers.begin(), numbers.end(), 2, 6);



    // 输出替换后的元素

    for (const auto& num : numbers) {

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

    }

    std::cout << std::endl;



    return 0;

}

//1 6 3 6 4 6 5

replace_if

作用：将范围 [first, last) 中所有满足 pred 条件的元素替换为 new_value

函数原型：

        template<class ForwardIterator, class UnaryPredicate, class T>

        void replace_if (ForwardIterator first, ForwardIterator last, UnaryPredicate pred, const T& new_value);

参数：

        first：指向要替换的范围的起始位置的迭代器。

        last：指向要替换的范围的结束位置的迭代器（不包含在范围内）。

        pred：一元谓词函数或函数对象，用于判断元素是否满足替换条件。

        new_value：要替换为的新值。

案例

int main()

{

    vector<int> v1;

    v1.push_back(10);

    v1.push_back(20);

    v1.push_back(30);

    v1.push_back(40);

    v1.push_back(50);



    replace_if(v1.begin(),v1.end(),bind2nd(greater<int>(),30),300);



    for_each(v1.begin(),v1.end(),[](int val){

        cout<<val<<" ";

    });

    cout<<endl;



    //用copy输出

    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));

    return 0;

}

swap

作用：交换两个对象的值

函数原型：

        template<class T>

        void swap (T& a, T& b);

例：

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

    int a = 5;

    int b = 10;



    std::swap(a, b);



    std::cout << "a: " << a << std::endl;

    std::cout << "b: " << b << std::endl;



    return 0;

}

unique

作用：移除连续重复的元素，只保留每个重复元素的第一个副本。返回一个指向不重复元素的末尾位置的迭代器。

函数原型：

        template<class ForwardIt>

        ForwardIt unique(ForwardIt first, ForwardIt last);

参数：

        first：指向要操作的范围的起始位置的迭代器。

        last：指向要操作的范围的结束位置的迭代器。

例如：a[] = {1, 3, 2, 3, 6};

        unique之后a数组为{1, 2, 3, 6, 3}前面为无重复元素的数组，后面则是重复元素移到后面，返回a[4]位置的地址（不重复元素的尾后地址）

注意：消除重复元素一般需要原序列是有序序列

例：

#include <iostream>

#include <vector>

#include <algorithm>



int main() {

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



    auto last = std::unique(nums.begin(), nums.end());



    for (auto it = nums.begin(); it != last; ++it) {

        std::cout << *it << " ";

    }

    std::cout << std::endl;



    return 0;

}

//1 2 3 4 5

常用算数生成算法

accumulate

作用：计算范围内元素的累加和（或其他二元操作的累积结果）

函数原型：

        template<class InputIt, class T>

        T accumulate(InputIt first, InputIt last, T init);

        template<class InputIt, class T, class BinaryOp>

        T accumulate(InputIt first, InputIt last, T init, BinaryOp op);

参数：

        first：指向要操作的范围的起始位置的迭代器。

        last：指向要操作的范围的结束位置的迭代器。

        init：起始值，用于指定累加的初始值。

        op：二元操作函数，用于指定累积操作。

案例1：对普通成员

int main(int argc, char** argv) {

int a[]={1,3,5,9,10};



//对[0,2]区间求和，初始值为0，结果为0+1+3+5=9

int res1 = accumulate(a, a + 3, 0);

cout<<"累加的和为:"<<res1;



//对[0,3]区间求和，初始值为5，结果为5+1+3+5+9=23

int res2 = accumulate(a, a + 4, 5);

cout<<"累加的和为:"<<res2;



}

案例2：对自定义成员

#include <iostream>

#include <vector>

#include <numeric>



int multiply(int x, int y) {

    return x * y;

}



int main() {

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



    int product = std::accumulate(nums.begin(), nums.end(), 1, multiply);



    std::cout << "Product: " << product << std::endl;



    return 0;

}

fill

作用：将范围内的所有元素都设置为给定的值。

函数原型：

        template<class ForwardIt, class T>

        void fill(ForwardIt first, ForwardIt last, const T& value);

参数：

        first：指向要填充的范围的起始位置的迭代器。

        last：指向要填充的范围的结束位置的迭代器。

        value：要填充的值。

注意：和memset区别

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

        1.语法和类型安全：fill是C++标准库中的函数，接受迭代器作为参数，可以用于容器和其他可迭代对象。它是类型安全的，可以根据迭代器的类型自动确定要填充的值的类型。而memset是C标准库中的函数，接受指针和字节数作为参数，只能用于原始的内存块，并且需要手动转换为适当的类型。

        2.支持的数据类型：fill可以用于任何支持赋值操作的类型，包括内置类型和用户自定义类型。而memset只能用于字节级别的操作，对于非字符类型的数据，需要手动进行类型转换。

        3.填充值的限制：fill可以接受任何类型的值作为填充值，包括复杂的数据结构。而memset只能使用一个字节的值进行填充，通常是0或-1。

        4.适用范围：fill可以用于任何STL容器（如vector、list、array等）以及普通的数组，可以指定要填充的范围。而memset只能用于连续的内存块，无法指定范围。

例

int main()

{

    vector<int> v1;

    v1.resize(5);

    fill(v1.begin(),v1.end(),100);



    copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));

    return 0;

}

常用集合算法

set_intersection

作用：计算两个有序集合的交集，并将结果存储在另一个集合中。

函数原型：

        template <class InputIterator1, class InputIterator2, class OutputIterator>

        OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,

                                InputIterator2 first2, InputIterator2 last2,

                                OutputIterator result);

例

#include <iostream>

#include <algorithm>

#include <vector>

int main() {

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

    std::vector<int> set2 = {3, 4, 5, 6, 7};

    std::vector<int> intersection;



    std::set_intersection(set1.begin(), set1.end(),

                          set2.begin(), set2.end(),

                          std::back_inserter(intersection));



    for (int num : intersection) {

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

    }



    return 0;

}

//3 4 5

set_union

作用：计算两个有序集合的并集，并将结果存储在另一个集合中。

函数原型：

        template <class InputIterator1, class InputIterator2, class OutputIterator>

        OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,

                         InputIterator2 first2, InputIterator2 last2,

                         OutputIterator result);

例：

#include <iostream>

#include <algorithm>

#include <vector>



int main() {

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

    std::vector<int> set2 = {3, 4, 5, 6, 7};

    std::vector<int> unionSet;



    std::set_union(set1.begin(), set1.end(),

                   set2.begin(), set2.end(),

                   std::back_inserter(unionSet));



    for (int num : unionSet) {

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

    }



    return 0;

}

// 1 2 3 4 5 6 7

set_difference

作用：计算两个有序集合的差集，并将结果存储在另一个集合中（容器1中有的，容器2中没有的）

函数原型：

        template <class InputIterator1, class InputIterator2, class OutputIterator>

        OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,

                              InputIterator2 first2, InputIterator2 last2,

                              OutputIterator result);

例

#include <iostream>

#include <algorithm>

#include <vector>



int main() {

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

    std::vector<int> set2 = {3, 4, 5, 6, 7};

    std::vector<int> diffSet;



    std::set_difference(set1.begin(), set1.end(),

                        set2.begin(), set2.end(),

                        std::back_inserter(diffSet));



    std::cout << "Difference: ";

    for (int num : diffSet) {

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

    }



    return 0;

}

啊艺要努力
关注
专栏目录
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中的一部分，它提供了丰富的容器、迭代器、算法和函数对象等组件，极大地简化了数据结构和算法的实现。余文溪的《C++ STL--数据结构与算法...
STL库全套-超详解析
09-28
通过学习这些容器和工具，开发者可以更好地理解和利用C++的STL库，提高代码的效率和可读性，同时也为算法设计和数据处理提供了强大的支持。在青少年编程教育中，理解并掌握STL的使用是提升编程能力的重要一步，对于...
STL库--概述
啊艺哥哥的博客
03-14 384
C++标准模板库（Standard Template Library,STL）是泛型程序设计最成功的实例。STL是一些常用数据结构和算法的模板的集合。
STL --- 四、算法 Algorithms
bigger_belief的博客
05-25 1059
介绍了算法，以及算法的分类，时间复杂度和空间复杂度
STL初始---C++
weixin_63685622的博客
02-24 726
/创建一个vector容器---int数组//向容器中插入数据Person p1("唐僧", 30);Person p2("孙悟空", 99999);Person p3("猪八戒", 9999);Person p4("沙和尚", 999);Person p5("白龙马", 99);//通过迭代器访问容器中的数据---以for循环为例it!= v.end();it++)//*it表示的是< >中的类型元素。
c++---STL常用算法
m0_50046535的博客
04-25 3401
概述： 算法主要是由头文件<algorithm><functional><numeric>组成 <algorithm>是所有stl头文件中最大的一个，涉及比较，交换，查找，遍历，复制，修改等操作 <numeric>体积很小，只包括几个在序列上进行简单数学运算的模板函数 <functional>定义了一些类模板，用以声明函数对象 一、常用遍历算法 for_each 遍历容器 transform 搬运容...
C++ STL--vector详解
weixin_62590142的博客
05-03 2219
以上是vector的几种定义方式，
STL---初识
m0_48716770的博客
08-01 64
STL（标准模板库） STL分为：容器、算法、迭代器 容器和算法通过迭代器连接 STL六大组件：容器、算法、迭代器、仿函数、适配器、空间配置器 STL容器：将数据结构表现出来 数据结构：数组、链表、树、栈、队列、集合、映射表 容器：序列式容器、关联式容器 序列式容器：强调值得排序，每个元素有固定的位置 关联式容器：二叉树结构，各个元素没有严格上物理的顺序关系 算法：质变算法、非质变算法 质变算法：改变元素内容 非质变算法：不改变元素内容 迭代器：类似指针（连接 容器
STL--标准模板库--简要概述
mahuifa的博客
08-29 271
STL–标准模板库 #include <vector> //头文件 STL（Standared Template Library） 即标准模板库，惠普实验室开发的一系列软件的统称。他是由Alexader Stepanov、Meng Leng Lee和David R Musser在惠普实验室工作时所开发出来的。 STL主要是一些”容器“ 的集合，这些”容器“ 有list、...
算法-STL（C/C++）
L-China的博客
02-19 1589
STL主要由 container(容器)、algorithm(算法)和 iterator(迭代器)三大部分构成。容器用于存放数据对象（元素），算法用于操作容器中的数据对象。算法和容器之间的关系就是迭代器。容器、算法和迭代器称为STL的三大件。
算法竞赛常用STL库
weixin_51711289的博客
03-24 1035
蓝桥天梯常用STL库，vector,set,map,queue,stack
STL(标准模板库)---算法
2201_75782847的博客
08-23 533
本文将带领大家了解C++ STL（标准模板库）中的算法部分，通过实例讲解常用算法的使用方法，帮助读者掌握STL算法的强大功能，提高编程效率。
STL--源码剖析完整版.zip
04-09
STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它提供了高效、可重用的数据结构和算法。STL的主要组件包括容器（如vector、list、set等）、迭代器、算法和函数对象。侯捷...
STL标准模板库--编程初步视频精讲
06-09
STL（Standard Template Library），即... STL将数据结构和算法的分离，使得STL变得非常通用，体现出了范型编程的特点。本课提供对STL各部分内容的入门介绍，使学习者能够了解STL的概貌，为继续深入学习STL提供支持。
C++标准模板库(STL) -容器
11-05
STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 529
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 313
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1217
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 327
试除法求约数、约数个数、约数之和、最大公约数
STL源码剖析-LSTM算法详解
"这篇文档似乎是一本关于STL(Standard Template Library)的深入解析书籍的摘录，由侯捷撰写。...读者可以通过这个资源深入理解算法的效率、C++中的STL库，以及在机器学习领域中LSTM如何处理序列数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值