C++

起始算法有很多，或者说太多，这里不写了，主要写一写在 vector deque stack queue set map 中出现过的算法，其他算法，以后在此补充！

这些算法使用时候，包含：#include<algorithm>

其余算法参考：https://blog.csdn.net/tick_tock97/article/details/71316372

在线手册：http://www.cplusplus.com/reference/algorithm

首先，总结下，博客中各个容器自带的算法：

string： http://www.cplusplus.com/reference/string/string/?kw=string

erase  find  copy  data 

vector：http://www.cplusplus.com/reference/vector/vector/

erase clear 

stack queue 略

list: http://www.cplusplus.com/reference/list/list/remove/

erase clear sort remove (removeif unique merge)

set / multiset : http://www.cplusplus.com/reference/set/set/

erase clear find count 

map / multimap: http://www.cplusplus.com/reference/map/map/  

erase clear find count 

一、sort

没有返回值；

std::sort
default (1)    
template <class RandomAccessIterator>
  void sort (RandomAccessIterator first, RandomAccessIterator last);
custom (2)    
template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

// sort algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::sort
#include <vector>       // std::vector

bool myfunction (int i,int j) { return (i<j); }

struct myclass {
  bool operator() (int i,int j) { return (i<j);}
} myobject;

int main () {
  int myints[] = {32,71,12,45,26,80,53,33};
  std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33

  // using default comparison (operator <):
  std::sort (myvector.begin(), myvector.begin()+4);           //(12 32 45 71)26 80 53 33

  // 仿函数不必多言
  std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)

  // using object as comp
  std::sort (myvector.begin(), myvector.end(), myobject);     //(12 26 32 33 45 53 71 80)

  // print out content:
  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '
';

  return 0;
}

Output:
myvector contains: 12 26 32 33 45 53 71 80

二、find

返回改元素迭代器【没找到则返回 .end()】

自带该算法的容器有：

string【还带有rfind】： https://www.cnblogs.com/winslam/p/9405673.html

std::find
template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val);

可以看到，find的返回值是一个同输入类型的迭代器。一般地，如果找到了该元素，就会返回该元素地泛型指针，如果没找到就默认返回该容器的 .end()。

find算法的底层实现如下：

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;
}

例如：

vector<int> vec;
it = find(vec.begin(), vec.end(), val);
if(it != vec.end()) // 代表找到了
{
   cout << "*found" << endl;
}
else  // 代表 it = vec.end() 也就是没找到
{
   cout << "not found" << endl;
}

// find example
#include <iostream>     // std::cout
#include <algorithm>    // std::find
#include <vector>       // std::vector

int main () {
  // using std::find with array and pointer:
  int myints[] = { 10, 20, 30, 40 };
  int * p;

  // <1>在数组中查找
  p = std::find (myints, myints+4, 30);
  if (p != myints+4) // 注意这里写法
    std::cout << "在数组中找到元素：" << *p << '
';
  else
    std::cout << "Element not found in myints
";

  // <2>在容器中查找
  std::vector<int> myvector (myints,myints+4);//数组初始化容器
  std::vector<int>::iterator it;

  it = find (myvector.begin(), myvector.end(), 30);
  if (it != myvector.end())
    std::cout << "在容器中找到元素: " << *it << '
';
  else
    std::cout << "容器中没有这个元素
";

  return 0;
}

三、count

返回元素出现的次数

std::count
template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type
count (InputIterator first, InputIterator last, const T& val);

实现如下：

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;
}

// count algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::count
#include <vector>       // std::vector

int main () {
  // 统计元素在数组中出现次数
  int myints[] = {10,20,30,30,20,10,10,20};   // 8 elements
  int mycount = std::count (myints, myints+8, 10);
  std::cout << "10 appears " << mycount << " times.
";

  //  统计元素在容器中出现次数
  std::vector<int> myvector (myints, myints+8);
  mycount = std::count (myvector.begin(), myvector.end(), 20);
  std::cout << "20 appears " << mycount  << " times.
";
  return 0;
}

四、remove（参考《STL源码剖析》Page356）

自带该算法的容器有：

list  https://www.cnblogs.com/winslam/p/9416335.html

1、执行remove之后，对象size不变，【不是和erase一样真的删除了】

2、remove是将相同元素，移动到容器后端；例如：

vec ： 10 20 30 20 30 10

执行：vector<int>::iterator pend =   remove（vec.begin(), vec.end(), 20）;

vec:    10  30  30  10  ？  ？

                                   ^

                                   |

itr指向---------------------

例如：

// remove algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::remove
#include<vector>

using namespace std;

int main() {
    int myints[] = { 10,20,30,30,20,10,10,20 };      // 10 20 30 30 20 10 10 20

    vector<int> vec(myints, myints + sizeof(myints)/sizeof(int));
    // bounds of range:
    //int* pbegin = myints;                         
    //int* pend = pbegin + sizeof(myints) / sizeof(int);

    //pend = std::remove(pbegin, pend, 20);         // 10 30 30 10 10 ?  ?  ?                                
    //std::cout << "range contains:";
    //for (int* p = pbegin; p != pend; ++p)
    //    std::cout << ' ' << *p;
    //std::cout << '
';

    //================================================================

    vector<int>::iterator pend = remove(vec.begin(), vec.end(), 20);
    // 执行remove之后 vec的size不变
    // vec = 10 30 30 10 10 ?  ?  ?        至于后面三个，是残余数据不确定的
    for(vector<int>::iterator itr = vec.begin(); itr != pend; itr++ )
    {
        cout << *itr << " "; // 10 30 30 10 10
    }
    cout << endl;
    vec.erase(pend, vec.end()); // 你可以再加一步，完成删除操作   10 30 30 10 10


    return 0;
}

有关 remove_copy remove_if remove_copy_if 暂时不更新；用什么学什么，就是这个原则。