C++【算法】 | 【algorithm】常用方法

最新推荐文章于 2024-03-31 20:21:58 发布
最新推荐文章于 2024-03-31 20:21:58 发布
阅读量2.7k 收藏 40
点赞数 7
分类专栏： 算法 文章标签： 算法 stl algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45926547/article/details/123668199
版权

文章目录

all_of ：所有元素是否都

src


/**
* @func: 如果pred返回true；
* 		范围内的所有元素[first,last)或范围为空，则返回；
* 		否则返回false；
*/
template<class InputIterator, class UnaryPredicate>
  bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (!pred(*first)) return false;
    ++first;
  }
  return true;
}

案例

/* 判断范围内是否都满足func */
void test_all_of() {
	std::vector<int> vc = {1, 3, 4, 5, 6};
 	bool rt = std::all_of(vc.begin(), vc.end(), [](int i){
 		 	return i != 0;
 		});
	std::cout << "vc 中是否都没有0：" << (rt ? "是" : "否") << std::endl;
}

在这里插入图片描述

any_of ：所有元素是否存在

src

template<class InputIterator, class UnaryPredicate>
  bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (pred(*first)) return true;
    ++first;
  }
  return false;
}

案例

void test_any_of() {
	std::vector<int> vc = {1, 3, 4, 5, 6};
	bool rt = std::any_of(vc.begin(), vc.end(), [](int i){
	 	return i != 0;
	});
	std::cout << "vc 中是否存在0：" << (rt ? "否" : "是") << std::endl;
}

在这里插入图片描述

none_of ：是否都没有满足条件

src

template<class InputIterator, class UnaryPredicate>
  bool none_of (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (pred(*first)) return false;
    ++first;
  }
  return true;
}

案例

void test_none_of() {
	std::vector<int> vc = {1, 3, 14, 15, 6};
	bool rt = std::none_of(vc.begin(), vc.end(), [](int i){
	 	return i > 9;
	});
	std::cout << "vc 中是否都大于9：" << (rt ? "是" : "否") << std::endl;
}

for_each：将自定义函数用于指定范围

src

template<class InputIterator, class Function>
  Function for_each(InputIterator first, InputIterator last, Function fn)
{
  while (first!=last) {
    fn (*first);
    ++first;
  }
  return fn;     
}

案例

void test_for_each() {
	std::vector<int> vc = {1, 3, 14, 15, 6};
	std::for_each(vc.begin(), vc.end(), [](int& i){
	 	i += 2;
	});
	for(auto& i : vc)
		std::cout << i << " ";
	std::cout << std::endl; 
}

find ：查找指定范围内的值

若没有找到返回end();

src

template<class InputIterator, class T>
  InputIterator find (InputIterator first, InputIterator last, const T& val)
{
  while (first!=last) {
    if (*first==val) return first;
    ++first;
  }
  return last;
}

案例

void test_find() {
	std::vector<int> vc = {1, 3, 14, 15, 6};
	auto i = std::find(vc.begin(), vc.end(), 3);
	std::cout << *i; 
}

find_if ：获取自定义函数查找指定范围内的第一个元素

  • find_if_not：条件相反；
  • find_end：从后面查找；

src

template<class InputIterator, class UnaryPredicate>
  InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (pred(*first)) return first;
    ++first;
  }
  return last;
}

案例

void test_find_if() {
	std::vector<int> vc = {1, 3, 14, 15, 6};
	auto i = std::find_if(vc.begin(), vc.end(), [](int i){
			return i > 4;
		});
	std::cout << *i; 
}

adjacent_find：查找范围内相等的相邻元素

src

	
template <class ForwardIterator>
   ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class BinaryPredicate>
   ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last,
                                  BinaryPredicate pred);

案例

void test_adjacent_find() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	auto it = std::adjacent_find(vc.begin(), vc.end());
	std::cout << *it; 
}

count：统计该范围内出现的次数

  • count_if：阔以使用自定义函数进行统计；

src

template <class InputIterator, class T>
  typename iterator_traits<InputIterator>::difference_type
    count (InputIterator first, InputIterator last, const T& val)
{
  typename iterator_traits<InputIterator>::difference_type ret = 0;
  while (first!=last) {
    if (*first == val) ++ret;
    ++first;
  }
  return ret;
}

案例

void test_count() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	int it = std::count(vc.begin(), vc.end(), 8);
	std::cout << it << std::endl; 
}

equal：两个范围内的元素是否相等

也阔以传入自定义函数；

src

template <class InputIterator1, class InputIterator2>
  bool equal (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2);
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  bool equal (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);

案例

void test_equal() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	std::vector<int> vc1 = {1, 3, 3, 15, 15, 8};
	bool it = std::equal(vc.begin(), vc.end(), vc1.begin());
	std::cout << it << std::endl;
}

is_permutation：判断范围是否是另一个排列【与顺序无关】

src

template <class ForwardIterator1, class ForwardIterator2>
   bool is_permutation (ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2);
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
   bool is_permutation (ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, BinaryPredicate pred);

案例

void test_is_permutation() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	std::vector<int> vc1 = {1, 3, 8, 15, 3, 15};
	bool it = std::is_permutation(vc.begin(), vc.end(), vc1.begin());
	std::cout << it << std::endl;
}

search：子序列的搜索范围

search_n：指定位置搜索特定值出现的个数；

src

template <class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, ForwardIterator2 last2);
{
  if (first2==last2) return first1;  // specified in C++11
  
  while (first1!=last1)
  {
    ForwardIterator1 it1 = first1;
    ForwardIterator2 it2 = first2;
    while (*it1==*it2) {    // or: while (pred(*it1,*it2)) for version 2
        ++it1; ++it2;
        if (it2==last2) return first1;
        if (it1==last1) return last1;
    }
    ++first1;
  }
  return last1;
}

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
   ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, ForwardIterator2 last2,
                            BinaryPredicate pred);

案例

void test_search () {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	std::vector<int> vc1 = {1, 3};
	auto it = std::search (vc.begin(), vc.end(), vc1.begin(), vc1.end());
	std::cout << "vc1在vc中第一次出现的位置：" << it - vc.begin() << std::endl;
}

copy：复制指定范围元素

  • copy_if：自定义函数指定复制；
  • copy_backward：向后复制；

src

template<class InputIterator, class OutputIterator>
  OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
{
  while (first!=last) {
    *result = *first;
    ++result; ++first;
  }
  return result;
}

案例

void test_copy() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	std::vector<int> vc1;
	vc1.resize(vc.size());
	std::copy(vc.begin(), vc.end(), vc1.begin());
	for(auto& i:vc){
		std::cout << i << std::endl;
	}
}

move：元素移动

使用该方法移动是，原对象无效；
src

template<class InputIterator, class OutputIterator>
  OutputIterator move (InputIterator first, InputIterator last, OutputIterator result)
{
  while (first!=last) {
    *result = std::move(*first);
    ++result; ++first;
  }
  return result;
}

案例

void test_move() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	std::vector<int> vc1;
	std::vector<int> vc2;
	vc2.resize(vc.size());
	vc1.resize(vc.size());
	std::move(vc.begin(), vc.end(), vc1.begin());
	for(auto& i:vc1){
		std::cout << i << " ";
	}
	std::cout << std::endl;
	vc2 = std::move(vc1);
	for(auto& i:vc2){
		std::cout << i << " ";
	}
}

swap：交换两个对象的值

src

template <class T> void swap ( T& a, T& b )
{
  T c(a); a=b; b=c;
}

transform：处理指定范围的值

src

template <class InputIterator, class OutputIterator, class UnaryOperator>
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperator op)
{
  while (first1 != last1) {
    *result = op(*first1);  // or: *result=binary_op(*first1,*first2++);
    ++result; ++first1;
  }
  return result;
}

template <class InputIterator1, class InputIterator2,
          class OutputIterator, class BinaryOperation>
  OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, OutputIterator result,
                            BinaryOperation binary_op);

案例

void test_transform() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	std::vector<int> vc2;
	vc2.resize(vc.size());
	
	std::transform(vc.begin(), vc.end(), vc2.begin(), [](int &i) {
			return i*2;
		});
	for(auto& i:vc2){
		std::cout << i << " ";
	}
	std::cout << std::endl;
}

replace：替换指定范围内的值

  • replace：自定义函数指定替换；
  • replace_copy：将替换好列表i的复制；

src

template <class ForwardIterator, class T>
  void replace (ForwardIterator first, ForwardIterator last,
                const T& old_value, const T& new_value)
{
  while (first!=last) {
    if (*first == old_value) *first=new_value;
    ++first;
  }
}

案例

void test_replace() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};

	
	std::replace(vc.begin(), vc.end(), 3, 20);
	for(auto& i:vc){
		std::cout << i << " ";
	}
	std::cout << std::endl;
}

在这里插入图片描述

fill：用值填充

src

template <class ForwardIterator, class T>
  void fill (ForwardIterator first, ForwardIterator last, const T& val)
{
  while (first != last) {
    *first = val;
    ++first;
  }
}

案例

void test_fill() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};

	
	std::fill(vc.begin(), vc.begin()+3, 100);
	for(auto& i:vc){
		std::cout << i << " ";
	}
	std::cout << std::endl;
}

在这里插入图片描述

generate：生成

src

template <class ForwardIterator, class Generator>
  void generate ( ForwardIterator first, ForwardIterator last, Generator gen )
{
  while (first != last) {
    *first = gen();
    ++first;
  }
}

案例

void test_generate() {
	std::srand(unsigned(std::time(0)));
	std::vector<int> vc;
	vc.resize(5);
	
	std::generate(vc.begin(), vc.end(), [](){
			return (std::rand()%10);
		});
	for(auto& i:vc){
		std::cout << i << " ";
	}
	std::cout << std::endl;	
}

remove：将指定范围的数值移除，需要修改索引

src

template <class ForwardIterator, class T>
  ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
{
  ForwardIterator result = first;
  while (first!=last) {
    if (!(*first == val)) {
      if (result!=first)
        *result = *first;
      ++result;
    }
    ++first;
  }
  return result;
}

案例

void test_remove() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};

	
	auto it = std::remove(vc.begin(), vc.end(), 3);
	for(auto& i:vc){
		std::cout << i << " ";
	}
	std::cout << std::endl;
	vc.erase(it, vc.end());	// 需要删除后面的索引 
	for(auto& i:vc){
		std::cout << i << " ";
	}
}

unique：删除重复值

src

template <class ForwardIterator>
  ForwardIterator unique (ForwardIterator first, ForwardIterator last)
{
  if (first==last) return last;

  ForwardIterator result = first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for version (2)
      *(++result)=*first;
  }
  return ++result;
}

template <class ForwardIterator, class BinaryPredicate>
  ForwardIterator unique (ForwardIterator first, ForwardIterator last,
                          BinaryPredicate pred);

案例

void test_unique() {
	std::vector<int> vc = {1, 3, 3, 15, 15, 8};
	auto it = std::unique(vc.begin(), vc.end());
	
	vc.erase(it, vc.end());
	for(auto& i:vc){
		std::cout << i << " ";
	}
}

reverse：指定范围反转

src

template <class BidirectionalIterator>
  void reverse (BidirectionalIterator first, BidirectionalIterator last)
{
  while ((first!=last)&&(first!=--last)) {
    std::iter_swap (first,last);
    ++first;
  }
}

案例

void test_reverse() {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	std::reverse(vc.begin(), vc.end());
	
	for(auto& i:vc){
		std::cout << i << " ";
	}
}

rotate：将指定范围旋转

src

template <class ForwardIterator>
  void rotate (ForwardIterator first, ForwardIterator middle,
               ForwardIterator last)
{
  ForwardIterator next = middle;
  while (first!=next)
  {
    swap (*first++,*next++);
    if (next==last) next=middle;
    else if (first==middle) middle=next;
  }
}

案例

void test_rotate() {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	
	// 开头到第二个开始旋转	
	std::rotate(vc.begin(), vc.begin()+2, vc.end());
		
	for(auto& i:vc){
		std::cout << i << " ";
	}
}

在这里插入图片描述

random_shuffle：随机打乱

src

template <class RandomAccessIterator, class RandomNumberGenerator>
  void random_shuffle (RandomAccessIterator first, RandomAccessIterator last,
                       RandomNumberGenerator& gen)
{
  iterator_traits<RandomAccessIterator>::difference_type i, n;
  n = (last-first);
  for (i=n-1; i>0; --i) {
    swap (first[i],first[gen(i+1)]);
  }
}

案例

void test_random_shuffle() {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	
	std::random_shuffle(vc.begin(), vc.end());
		
	for(auto& i:vc){
		std::cout << i << " ";
	}
}

sort：排序

可提供自定义排序规则；
src

template <class RandomAccessIterator>
  void sort (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

案例

void test_sort() {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	
	std::sort(vc.begin(), vc.end());
		
	for(auto& i:vc){
		std::cout << i << " ";
	}
}

merge：合并两个有序的列表

src

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
                        InputIterator2 first2, InputIterator2 last2,
                        OutputIterator result)
{
  while (true) {
    if (first1==last1) return std::copy(first2,last2,result);
    if (first2==last2) return std::copy(first1,last1,result);
    *result++ = (*first2<*first1)? *first2++ : *first1++;
  }
}

案例

void test_merge() {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	std::vector<int> vc2 = {1, 6, 2, 9, 14, 8};
	std::vector<int> vc1;
	vc1.resize(vc.size() + vc2.size());
	std::sort(vc.begin(), vc.end());
	std::sort(vc2.begin(), vc2.end());
	std::merge(vc.begin(), vc.end(), vc2.begin(), vc2.end(), vc1.begin());
	for(auto& i:vc1){
		std::cout << i << " ";
	}
}

在这里插入图片描述

includes：是否包含序列

src

template <class InputIterator1, class InputIterator2>
  bool includes (InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, InputIterator2 last2)
{
  while (first2!=last2) {
    if ( (first1==last1) || (*first2<*first1) ) return false;
    if (!(*first1<*first2)) ++first2;
    ++first1;
  }
  return true;
}

案例


void test_includes() {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	std::vector<int> vc2 = {1, 3, 2};

	bool rt = std::includes(vc.begin(), vc.end(), vc2.begin(), vc2.end());
	std::cout << "vc是否包含vc2" << rt << std::endl;
}

在这里插入图片描述

set_union：求两个序列的并集

src

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 last2,
                            OutputIterator result)
{
  while (true)
  {
    if (first1==last1) return std::copy(first2,last2,result);
    if (first2==last2) return std::copy(first1,last1,result);

    if (*first1<*first2) { *result = *first1; ++first1; }
    else if (*first2<*first1) { *result = *first2; ++first2; }
    else { *result = *first1; ++first1; ++first2; }
    ++result;
  }
}

案例

void test_set_union() {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	std::vector<int> vc2 = {1, 3, 2, 19, 11, 20};
	std::vector<int> vc1;
	vc1.resize(vc.size() + vc2.size());
	
	auto rt = std::set_union(vc.begin(), vc.end(), vc2.begin(), vc2.end(), vc1.begin());
	vc1.resize(rt-vc1.begin());
	
	for(auto& i:vc1){
		std::cout << i << " ";
	}
}

在这里插入图片描述

set_intersection：求两个集合的交集

src

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
                                   InputIterator2 first2, InputIterator2 last2,
                                   OutputIterator result)
{
  while (first1!=last1 && first2!=last2)
  {
    if (*first1<*first2) ++first1;
    else if (*first2<*first1) ++first2;
    else {
      *result = *first1;
      ++result; ++first1; ++first2;
    }
  }
  return result;
}

案例

void test_set_intersection () {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	std::vector<int> vc2 = {1, 3, 2, 19, 11, 20};
	std::vector<int> vc1;
	vc1.resize(vc.size() + vc2.size());
	
	auto rt = std::set_intersection (vc.begin(), vc.end(), vc2.begin(), vc2.end(), vc1.begin());
	vc1.resize(rt-vc1.begin());
	
	for(auto& i:vc1){
		std::cout << i << " ";
	}
}

在这里插入图片描述

set_difference：求两个序列的差异

src

template <class InputIterator1, class InputIterator2, class OutputIterator>
  OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result)
{
  while (first1!=last1 && first2!=last2)
  {
    if (*first1<*first2) { *result = *first1; ++result; ++first1; }
    else if (*first2<*first1) ++first2;
    else { ++first1; ++first2; }
  }
  return std::copy(first1,last1,result);
}

案例

void test_set_difference(){
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	std::vector<int> vc2 = {1, 3, 2, 19, 11, 20};
	std::vector<int> vc1;
	vc1.resize(vc.size() + vc2.size());
	
	auto rt = std::set_difference(vc.begin(), vc.end(), vc2.begin(), vc2.end(), vc1.begin());
	vc1.resize(rt-vc1.begin());
	
	for(auto& i:vc1){
		std::cout << i << " ";
	}
}

在这里插入图片描述

push_heap：将元素推入堆范围

  • pop_heap：删除堆顶；
  • make_heap：创建堆；
  • sort_push：排序；
  • is_heap：是否为堆；

src

template <class RandomAccessIterator>
  void push_heap (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare>
  void push_heap (RandomAccessIterator first, RandomAccessIterator last,
                   Compare comp);

案例

void test_heap(){
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	
	std::make_heap(vc.begin(), vc.end());
	std::cout << "heap top：" << vc.front() << std::endl;

	std::pop_heap(vc.begin(), vc.end());
	vc.pop_back();
	std::cout << "pop after, heap top：" << vc.front() << std::endl;

	
	vc.push_back(300);
	std::push_heap(vc.begin(), vc.end());
	std::cout << "add after, heap top：" << vc.front() << std::endl;
	
	for(auto& i:vc) {
		std::cout << i << " ";
	}
}

在这里插入图片描述

max、min：判断最大或最小

src

template <class T> const T& min (const T& a, const T& b) {
  return !(b<a)?a:b;     // or: return !comp(b,a)?a:b; for version (2)
}

案例

void test_min_max() {
	std::cout << "min: " << std::min(4, 1) << std::endl;
	std::cout << "max: " << std::max(4, 1) << std::endl;
}

在这里插入图片描述

minmax_element：获取序列中的最大最小元素

src

template <class ForwardIterator>
  pair<ForwardIterator,ForwardIterator>
    minmax_element (ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class Compare>
  pair<ForwardIterator,ForwardIterator>
    minmax_element (ForwardIterator first, ForwardIterator last, Compare comp);

案例

void test_minmax_element() {
	std::vector<int> vc = {1, 3, 2, 9, 15, 8};
	auto rt = std::minmax_element(vc.begin(), vc.end());
	
	std::cout << *rt.first << ", " << *rt.second << std::endl;
}

在这里插入图片描述

next_permutation：全排列

src

template <class BidirectionalIterator>
  bool next_permutation (BidirectionalIterator first,
                         BidirectionalIterator last);

template <class BidirectionalIterator, class Compare>
  bool next_permutation (BidirectionalIterator first,
                         BidirectionalIterator last, Compare comp);

案例

void test_next_permutation() {
	std::vector<int> vc = {1, 3, 2};
	std::sort(vc.begin(), vc.end());
	std::cout << "全排列\n"; 
	do {
    	std::cout << vc[0] << ' ' << vc[1] << ' ' << vc[2] << '\n';
  	} while ( std::next_permutation(vc.begin(), vc.end()));
}

在这里插入图片描述

Jxiepc
关注
  • 7
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++ Algorithms库常用算法介绍
qq_27390023的博客
04-12 384
C++ Algorithms 库提供了一系列用于操作容器和其他数据结构的通用算法。这些算法经过严格测试和优化，可以在不同的数据结构上进行高效的操作。这些算法提供了对各种数据结构进行操作的通用方法，使得代码更加简洁和易于理解。在开发中，根据具体需求选择适当的算法可以提高代码的效率和可维护性。
C++算法与泛型算法（algorithm、numeric）
08-25
C++算法与泛型算法 C++算法与泛型算法是一种强大的工具，用于操作容器中的元素。这些算法可以分为三类：只读算法、写算法和重排元素算法。下面将对这些算法进行详细的介绍。 一、算法简介 大多数算法在头文件`...
C++ STL算法库＜algorithm＞常用库函数使用方法
jammyhe2010的博客
08-10 1448
算法部分主要由头文件，和组成。
C++标准库头文件之algorithm
一只小鲤鱼~的博客
07-04 2594
algorithm是C++标准库中的头文件，它提供了许多常用的算法和函数模板，可以用于各种数据结构和容器的处理。algorithm库涵盖了各种排序、搜索、转换、比较、操作和算术等常用的算法和函数，可以大大简化开发过程，提高代码的可读性和可维护性。algorithm库中还有许多其他的函数和算法，涵盖了各种常用的操作和需求。使用algorithm库能够大大简化代码编写过程，提高代码的效率和可维护性。头文件，并通过命名空间std来调用其中的函数和算法。要使用algorithm库，需要在代码中包含。
c++常见算法
qq_51691366的博客
04-16 4697
find 查找自定义数据类型 需要重载==private:int num;public:Person(){}//find 查找自定义数据类型 需要重载==if(ret!cout
C++常见算法大全（自用）
ylh的博客
08-27 6031
集合算法主要是集合上的一些运算，例如集合加法：并集，集合的减法：差集，还有交集。stable_partition: 范围排序，保存原容器顺序。partial_sort_copy:范围排序外加复制操作。next_permutation:下一个排序序列的组合。prev_permutation:上一个排序序列的组合。stable_sort: 排序，保存原容器数据顺序。remove_copy_if:条件删除拷贝到新容器。replace_copy_if:条件替换，结果另存。......
Sort_Algorithm_排序算法_C++_c++algorithmsort_
10-01
同时，合理使用C++的STL（标准模板库）如`<algorithm>`中的`sort()`函数，可以简化排序操作，提高代码效率。 总的来说，掌握排序算法是成为一名优秀程序员的基础。通过学习和实践C++中的冒泡排序、快速排序和直接...
C++实现分水岭算法（Watershed Algorithm）
08-28
本文详细介绍了C++实现分水岭算法（Watershed Algorithm），该算法是一种基于拓扑理论的数学形态学的分割方法。下面是相关的知识点： 1. 分水岭算法的基本思想：将图像看作是测地学上的拓扑地貌，图像中每一点像素...
c++算法入门学习
02-15
C++算法入门学习是编程领域中的重要一环，特别是在解决复杂问题和优化程序效率时，算法扮演着关键角色。C++作为一门强大的静态类型语言，提供了丰富的库支持和高效的执行性能，非常适合进行算法实现。本资源是基于...
你需要的c++常用算法合集，都在这里（一）
qpfxgg的博客
04-06 2371
因为c++算法太多，所以将他分成两篇文章去写，这篇文章主要涉及遍历，查找和排序算法 1、遍历算法 （1）for_each 函数原型 for_each（iterator beg， iterator end ，_func）； 遍历算法遍历容器元素 beg开始迭代器 end 结束迭代器 func 函数或者函数对象 具体运用如下 在这里插入代码片 ...
C++头文件 ＜algorithm＞的 常用函数(详细）
Rock_Lihaoran的博客
01-30 5442
超级方便的函数工具
C++头文件algorithm的一些用法
SJCHEN1221的博客
11-20 2530
转载自https://blog.csdn.net/liuweiyuxiang/article/details/51865991 &lt;algorithm&gt;是c++特有的STL模板的算法头文件 包含了一些特定的算法函数  包括sort(),stable_sort(),partical_sort(),nth_element()等常用的算法函数 一、巡防算法 for_each(容器起始地址，容...
C++常见算法有哪些
最新发布
u013083044的博客
03-31 1298
std::cout << "从节点 " << start << " 到节点 " << i << " 的最短距禿：" << dist[i] << std::endl;std::cout << "目标值在数组中的索引为：" << index << std::endl;std::cout << "目标值在数组中的索引为：" << index << std::endl;std::cout << "最小生成树的总权值为：" << minCost << std::endl;std::cout << "未找到目标值。
algorithm用法
Tizzi的博客
10-17 1437
五、#inlcude < algorithm > 下面介绍的几个函数都作用在序列上，接收两个迭代器（或指针）l,r，对下标处于**前闭后开区间【l,r)**中的元素执行一系列操作。 sort() 快速排序 int n = 3; int a[3] = {3,2,1}; //对[0, n)区间进行排序 sort(a, a + n); 可以在第三个参数传入定义大小比较的函数，或者重载...
通过简单的例子看c程序死循环
weixin_33757911的博客
10-22 782
在解释什么是程序死循环之前，先看一段代码，直观感受一下：事实上，“Welcome to my town”在运行窗口是不断无休止的执行的。单就这个程序来说，每当执行一遍循环时，数组里面的内容被放进了×××数据0，即就是说，arr[0]——arr[9]里放的内容为0。因为数组长度为10，i刚好是数组的下标，数组最后一个元素为arr[9],当i自加到10的时候，按道理应该是arr[...
c++ algorithm
WangNewFIsh的博客
10-18 386
c++ algorithm之分分（partition）合合（merge）
【 C++基础】algorithm 库常用函数
热门推荐
流水猿的博客
07-28 1万+
algorithm 头文件常用函数<1>序列容器遍历操作for_eachfindfind_ifequalcountreplacereplace_if 本文介绍 C++ 的 algorithm 库中常用函数。algorithm是C++标准程序库中的一个头文件，定义了C++ STL标准中的基础性的算法(均为函数模板)。定义了设计用于元素范围的函数集合。任何对象序列的范围可以通过迭代器或指针访问。 <1>序列容器遍历操作 常用参数对照： frist : 起点，为一个迭代器 last :
C++ - 泛型算法（algorithm）
Spike的秃头之路
10-21 292
集合中是否存在某值。搜索范围由iterator[first, last)标出。如果找到目标，find()会返回一个iterator指向该值，否则返回一个iterator指向last。比对某个容器内是否存在某个子序列。若子序列存在则返回一个iterator指向子序列起始处；否则返回一个iterator指向容器末尾。如果搜索到目标，就返回true；否则返回false。需要确保”目标容器“拥有足够空间放置每个即将到来的元素。返回数值相符的元素数目。
c++ algorithm常用函数
08-13
C++标准库中提供了许多常用的算法函数，这些函数可以用于对容器（如vector、list等）中的数据进行排序、查找、遍历等操作。以下是一些常用的C++ algorithm函数： 1. `std::sort`：对容器中的元素进行排序，可以通过自定义比较函数来指定排序方式。 ```cpp std::vector<int> nums = {4, 2, 6, 1, 5}; std::sort(nums.begin(), nums.end()); // 默认升序排序 ``` 2. `std::binary_search`：在已排序的容器中进行二分查找，返回是否找到指定元素。 ```cpp std::vector<int> nums = {1, 2, 3, 4, 5}; bool found = std::binary_search(nums.begin(), nums.end(), 3); // true ``` 3. `std::find`：在容器中查找指定元素，返回第一个匹配元素的迭代器，如果没找到则返回容器末尾的迭代器。 ```cpp std::vector<int> nums = {1, 2, 3, 4, 5}; auto it = std::find(nums.begin(), nums.end(), 3); // 指向元素3的迭代器 ``` 4. `std::count`：统计容器中指定元素的个数。 ```cpp std::vector<int> nums = {1, 2, 2, 3, 2}; int count = std::count(nums.begin(), nums.end(), 2); // 3 ``` 5. `std::accumulate`：计算容器中元素的累加和，可以指定初始值。 ```cpp std::vector<int> nums = {1, 2, 3, 4, 5}; int sum = std::accumulate(nums.begin(), nums.end(), 0); // 15 ``` 6. `std::reverse`：将容器中的元素翻转。 ```cpp std::vector<int> nums = {1, 2, 3, 4, 5}; std::reverse(nums.begin(), nums.end()); // {5, 4, 3, 2, 1} ``` 这些函数只是C++ algorithm库中的一小部分，还有许多其他有用的函数可用于不同的操作。你可以查阅C++标准库文档以获取更详细的信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jxiepc

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值