C++中STL库基本算法

前言

标准模板库 STL（Standard Template Library），是 C++ 标准库的一部分，不需要单独安装，只需要#include 头文件。

C++ 语言的核心优势之一就是便于软件的复用。

C++ 语言有两个方面体现了复用：

• 面向对象的继承和多态机制
• 通过模板的概念实现了对泛型程序设计的支持

C++中的模板，就好比英语作文的模板，只换主题，不换句式和结构。对应到C++模板，就是只换类型，不换方法。

STL六大部件

• 容器（Containers）
• 分配器（Allocators）
• 算法（Algorithm）
• 迭代器（Iterators）
• 适配器（Adapters）
• 仿函数（Functors）

常见的容器

1.1 vector

vector（矢量），是一种「变长数组」，即“自动改变数组长度的数组”。

值得一提的是，vector可以用来以邻接表的方式储存图，非常友好，非常简洁。

要使用vector，需要添加头文件：

#include <vector>
using namespace std;

1.2vector的定义

像定义变量一样定义vector变量：

vector<类型名> 变量名;

类型名可以是int、double、char、struct，也可以是STL容器：vector、set、queue。

vector<int> name;
vector<double> name;
vector<char> name;
vector<struct node> name;
vector<vector<int> > name;//注意：> >之间要加空格

注意：vector<vector<int> > name; >>之间要加空格。

vector数组就是一个一维数组,如果定义成vector数组的数组，那就是二维数组。

vector<int> array[SZIE]; //二维变长数组

在此，我送你一句话非常受用的话：低维是高维的地址。

二维数组中，它的一维形式就是地址。例如：

#include <iostream>
using namespace std;

int main(){
    int arr[3][2];//定义一个3行2列的地址
    cout<<arr[0]<<endl; //输出arr第1行的地址
    cout<<arr[1]<<endl; //输出arr第2行的地址
    cout<<arr[2]<<endl; //输出arr第3行的地址
    return 0;
}

输出：

0x61fe00 //arr第1行的地址
0x61fe08 //arr第2行的地址
0x61fe10 //arr第3行的地址

所以，vector容器也可以这样理解。

1.3vector容器内元素的访问

vector一般有两种访问方式：

（1）通过下标访问

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> vi;
    vi.push_back(1);
    cout<<vi[0]<<endl;
    return 0;
}

输出：

1

（2）通过迭代器访问

迭代器（iterator）可以理解为指针：

vector<类型名>::iterator 变量名;

例如：

vector<int>::iterator it;
vector<double>::iterator it;

举个栗子：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    //v.begin()返回v的首元素地址
    vector<int>::iterator it=v.begin();
    for (int i = 0; i < v.size(); i++)
    {
       cout<<it[i]<<" ";
    }
    return 0;
}

输出：

0 1 2 3 4

for循环迭代部分也可以写成：

    vector<int>::iterator it=v.begin();
    for (int i = 0; i < v.size(); i++)
    {
       cout<<*(it+i)<<" ";
    }

也即是

it[i] = *(it+i) //这两个写法等价

这是简单的常识，以后不再提及。

与此同时，迭代器与for循环还有一种优雅的写法。

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    //vector的迭代器不支持it<v.end()的写法，因此循环条件只能it!=v.end()
    for (vector<int>::iterator it=v.begin(); it!=v.end();it++)
    {
        cout<<*it<<" ";
    }
    return 0;
}

此种写法与遍历字符串有异曲同工之妙：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    string str;
    str="Hello World";
    for (int i = 0; str[i]!='\0'; i++)
    {
        cout<<str[i]<<" ";
    }
    return 0;
}

输出：

H e l l o   W o r l d

1.4vector常用函数实例解析

• push_back()
• pop_back()
• size()
• clear()
• insert()
• erase()

（1）push_back()

void std::vector<int>::push_back(const int &__x)

见名知意，push_back(item)就是在vector后面添加一个元素item。

用例：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    return 0;
}

以前还要为定长数组内存分配而苦恼时，现在只需要无脑push_back()就好了。

（2）pop_back()

void std::vector<int>::pop_back()

push和pop时一对反义词，学过数据结构的人都知道，栈元素的压入和弹出就是push和pop。

须知，pop_back()一次弹出一个元素，vector容器就会减少一个预算。

之所以叫容器，就是能往里面装一个一个的元素。

用例：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    cout<<"pop_back前:"<<endl;
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    cout<<endl;
    v.pop_back();
    cout<<"pop_back后:"<<endl;

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

输出：

pop_back前:
0 1 2 3 4
pop_back后:
0 1 2 3

（3）size()

std::size_t std::vector<int>::size()

szie()返回vector中所含元素的个数，时间复杂度为O(1)。

用例：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    cout<<v.size()<<endl;
    return 0;
}

输出：

5

（4）clear()

void std::vector<int>::clear()

clear()用于一键清空vector中的所有元素，时间复杂度为O(N)，其中N为vector中原属和元素的个数。

用例：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    v.clear();
    cout<<endl;
    cout<<"size = "<<v.size()<<endl;
    return 0;
}

输出：

0 1 2 3 4 
size = 0

（5）insert()

insert(__position,__x);
insert(要插入的地址，要插入的元素);

参数：
__position：– A const_iterator into the %vector.
__x:– Data to be inserted.

与push_back()无脑在尾部添加元素不同的是，insert()是根据指定位置在vector中插入元素。

用例：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    v.insert(v.begin()+2,-1); //将-1插入v[2]的位置
    cout<<endl;
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    return 0;
}

输出：

0 1 2 3 4 
0 1 -1 2 3 4

（6）erase()

erase(__position);

同样，与clear()简单粗暴清空vector不同的是erase()，删除指定位置的元素。

erase()有两种用法：

• 删除一个元素
• 删除一个区间内的元素

1.删除一个元素

erase(__position);

用例：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    //删除v[3]
    v.erase(v.begin()+3);
    cout<<endl;
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    return 0;
}

输出：

0 1 2 3 4 
0 1 2 4

2.删除一个区间内的元素

erase(__positionBegin,__positionEnd);

即是删除[ __positionBegin,__positionEnd )区间内的元素，注意：是左闭右开！

用例：

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> v;
    for (int i = 0; i < 5; i++)
    {
        v.push_back(i);
    }
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    //删除v[1]到v[4]的元素
    v.erase(v.begin()+1,v.begin()+4);
    cout<<endl;
    for (int i = 0; i < v.size(); i++)
    {
        cout<<v[i]<<" ";
    }
    return 0;
}

输出：

0 1 2 3 4 
0 4

1.5vector常见用途

（1）储存数据

vector本身可以作为数组使用，而且在一些元素个数不确定的场合可以很好地节省空间。

（2）用邻接表存储图

使用vector实现邻接表，更为简单。

2.1 set

set（集合），是一个内部自动有序且不含重复元素的容器。

set可以在需要去重复元素的情况大放异彩，节省时间，减少思维量。

要使用set，需要添加头文件：

#include <set>
using namespace std;

2.2set的定义

像定义变量一样定义set变量：

set<类型名> 变量名;

类型名可以是int、double、char、struct，也可以是STL容器：vector、set、queue。

用例：

set<int> name;
set<double> name;
set<char> name;
set<struct node> name;
set<set<int> > name;//注意：> >之间要加空格

set数组的定义和vector相同：

set<类型名> array[SIZE];

例如：

set<int> arr[10];

2.3set容器内元素的访问

set只能通过迭代器(iterator)访问：

set<int>::iterator it;
set<char>::iterator it;

这样，就得到了迭代器it，并且可以通过*it来访问set里的元素。

注意：

除了vector和string之外的STL容器都不支持*(it+i)的访问方式，因此只能按照如下方式枚举：

#include <iostream>
#include <set>
using namespace std;

int main()
{
    set<int> st;
    st.insert(5);
    st.insert(2);
    st.insert(6);
    for (set<int>::iterator it = st.begin(); it != st.end(); it++)
    {
        cout << *it << endl;
    }
    return 0;
}

输出：

2
5
6

我们可以看到，原本无序的元素，被插入set集合后，set内部的元素自动递增排序，并且自动去除了重复元素。

2.4set常用函数实例解析

（1）insert()

插入元素十分简单。

#include <iostream>
#include <set>
using namespace std;

int main()
{
    set<char> st;
    st.insert('C');
    st.insert('B');
    st.insert('A');
    for (set<char>::iterator it = st.begin(); it != st.end(); it++)
    {
        cout << *it << endl;
    }
    return 0;
}

（2）find()

find(value)返回的是set中value所对应的迭代器，也就是value的指针（地址）。

#include <iostream>
#include <set>
using namespace std;
int main()
{
    set<int> st;
    for (int i = 1; i <= 3; i++)
    {
        st.insert(i);
    }

    set<int>::iterator it = st.find(2); //在set中查找2，返回其迭代器
    cout << *it << endl;

    // 以上可以直接x携程
    cout << *(st.find(2)) << endl;
    return 0;
}

输出：

2
2

（3）erase()

erase()有两种用法：删除单个元素、删除一个区间内的所有元素。

1.删除单个元素

删除单个元素有两种方法：

• st.erase(it)，其中it为所需要删除元素的迭代器。时间复杂度为O(1)。可以结合find()函数来使用。

#include <iostream>
#include <set>
using namespace std;

int main()
{
    set<int> st;
    st.insert(100);
    st.insert(200);
    st.insert(100);
    st.insert(300);
    // 删除单个元素
    st.erase(st.find(100)); //利用find()函数找到100,然后用erase删除它
    st.erase(st.find(200));
    for (set<int>::iterator it = st.begin(); it != st.end(); it++)
    {
        cout << *it << endl;
    }
    return 0;
}

输出：

300

• st.erase(value)，value为所需要删除元素的值。其时间复杂度为O(logN)，N为set内的元素个数。

#include <iostream>
#include <set>
using namespace std;

int main()
{
    set<int> st;
    st.insert(100);
    st.insert(200);
    st.insert(100);
    st.insert(300);
    // 删除单个元素
    st.erase(100);
    for (set<int>::iterator it = st.begin(); it != st.end(); it++)
    {
        cout << *it << endl;
    }
    return 0;
}

输出：

200
300

2.删除一个区间内的所有元素

st.erase(iteratorBegin , iteratorEnd)可以删除一个区间内的所有元素。

其中iteratorBegin为所需要删除区间的起始迭代器

iteratorEnd为所需要删除区间的结束迭代器的下一个地址

也即是[iteratorBegin,iteratorEnd)

#include <iostream>
#include <set>
using namespace std;

//2.删除一个区间内的所有元素

int main()
{
    set<int> st;
    st.insert(100);
    st.insert(200);
    st.insert(100);
    st.insert(300);
    set<int>::iterator it = st.find(200);
    st.erase(it, st.end());
    for (it = st.begin(); it != st.end(); it++)
    {
        cout << *it << endl;
    }
    return 0;
}

输出：

100

（4）size()

不难理解，szie()用来实时获得set内元素的个数，时间复杂度为O(1)。

#include <iostream>
#include <set>
using namespace std;
int main()
{
    set<int> st;
    st.insert(2);
    st.insert(5);
    st.insert(4);
    cout << st.size() << endl;
    return 0;
}

输出：

3

3.1string声明

string s;
string ss[10];

3.2初始化

使用等号的初始化叫做拷贝初始化，不使用等号的初始化叫直接初始化。

#include<iostream>
#include<string>

using namespace std;

int main(){
    string s;               //  默认初始化，一个空白的字符串
    string s1("ssss");      // s1是字面值"ssss"的副本
    string s2(s1);          // s2是s1的副本
    string s3 = s2;         // s3是s2的副本
    string s4(10, '4');     // s4初始化
    string s5 = "Andre";    // 拷贝初始化
    string s6 = string(10, 'c');    // 可拷贝初始化，生成一个初始化好的对象，拷贝给s6

    char cs[] = "12345";
    string s7(cs, 3);       // 复制字符串cs的前三个字符到s当中

    string s8 = "abcde";
    string s9(s8, 2);

    string s10 = "asdsfasdgf";
    string s11(s10, 3, 4);  // s4是s3从下标s开始4个字符的拷贝，超出s10.size出现未定义
    return 0;
}

3.3string类型的读入

string s;
cin >> s;   //不能读入空格，以空格，制表符，回车符作为结束标志
getline(cin, s); //可以读入空格和制表符，以回车符作为结束的标志

3.4字符串末尾添加字符

可以用+号和append()函数在函数的末尾添加字符。

string s;
s += 'a';
s.append('a');

3.5sting类型变量的访问

string字符串变量访问可以采用at, operator[]来访问指定index对应的字符。其中at有越界检查,如果index越界，无论Debug还是在Release编译的环境下，程序异常跳出执行；operator[]无越界检查，如果index越界，则会取得不可预知的字符。

string s("abcd");
cout << s[0] << s.at(2) << endl;

3.6string类型的长度

string s = "Hello, world!"
int len = s.size();
int len = s.length();   //这两种方式是等价的

3.7查找字符串的子字符串

string s = abcdefg, subs = "efg";
int pos = s.find(subs); // 如果找到子字符串则返回首次匹配的位置，否则返回-1

3.8指向首字符和末尾字符的迭代器（begin,end）

string s("abcdefg");
for(string::iterator it = s.begin(); it != s.end(); it++)
{
    cout << *it;
}

//逆向迭代器
for (string::iterator it = s.rbegin(); it != s.rend(); it++)
   { cout << *it;  } 

//采用auto实现迭代器

for(auto itr : s)
{
    cout << itr << endl;
}

3.9empty(), clear()

empty()可以用来检查字符串是否为空，clear()用来清空字符串。

string s1 = "012345";
if(!s1.empty()){
    cout << s1.length << endl;
    s1.clear();
}

3.10insert()在指定index处插入字符或字符串

// insert原型函数，在index插入count个字符ch。
// insert(size_type index, size_type count, char ch)

string s1 = "abc";
s1.insert(1, 2, 'D')    // "aDDbc"

3.11erase()删除字符

erase()函数有三个原型:

string& erase(size_t pos = 0, size_t n = npos);
iterator erase(iterator position);
iterator erase(iterator first, iterator last);

因此erase()总共有三种用法:

erase(pos, n);      //删除从pos开始的n个字符,比如erase(0, 1)就是删除第一个字符
erase(position);    //删除从position处的一个字符(position是个string类型的迭代器)
erase(first, last); //删除从first到last之间的字符(first和last都是迭代器)

应用实例：

string str ("This is an example phrase.");
string::iterator it;

// 第(1)种用法
str.erase (10,8);
cout << str << endl;        // "This is an phrase."

// 第(2)种用法
it=str.begin()+9;
str.erase (it);
cout << str << endl;        // "This is a phrase."

// 第(3)种用法
str.erase (str.begin()+5, str.end()-7);
cout << str << endl;        // "This phrase."

3.12获取子字符串substr()

• 函数原型: string substr(size_t pos = 0, size_t len = npos) const;
• 功能: 从子字符串中获取想要的子字符串
• 参数：
  • pos: 想要获取的子字符串的第一个字符的位置，如果pos等于字符串长度，则该函数返回一个空字符串，如果等于字符串长度，则该函数返回一个空的字符串，如果该长度大于字符串长度，则抛出一个out_of_range。 注：第一个字符的下标从0开始。
  • len： 子字符串中要包含的字符数, string::npos的值表示知道字符串末尾的所有字符。
  
  
• 返回值：带有对象子字符串的字符串对象。

应用实例:

string s1 = "Hello World"
string s2 = s1.substr(3, 5);
string s3 = s1.substr(3, str::npos); //截取从下标3到结束的子字符串

 以上只是介绍了一点C++中STL库中的两个容器和一些基本算法，以后博主还会更新后续的容器算法，敬请期待。