STLgrasp

最新推荐文章于 2020-09-23 16:43:18 发布

断线纸鸢s

最新推荐文章于 2020-09-23 16:43:18 发布

阅读量126

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/qq_33521663/article/details/108691746

版权

算法专栏收录该内容

12 篇文章 3 订阅

订阅专栏

use frequently STL grasp

string（字符串）

所有的字符串函数都已经在上面了，下面列几个比较常用的函数：

vector(不定长数组)

1.导入函数库

#include<vector> using namespace std;

2.构造函数
vector<int> v1 ( nums，value);

nums：容量大小 value：值

3.赋值

v1 = v2;

如果v1的容量>=v2的容量，可以将v2的值copy到v1中

assign(start,end);

assign(num, value);

v1.assign(v2.begin(),v2.end()-5);

将v2 中第一个到倒数第五个的数赋值给v1

v1.assign(5,3)

给v1 赋5个值为3的值

4.运算符

v1 == v2;

两个vectors被认为是相等的,如果:
1.它们具有相同的容量
2.所有相同位置的元素相等.

5.常用函数

6.常用函数详解

back() 与 end()的区别

back()函数返回的是最后一个元素的值；

end()函数返回的是最后一个元素的下一个位置（返回类型：迭代器）

迭代器： 迭代器(iterator)是一种检查容器内元素并遍历元素的数据类型。
(1) 每种容器类型都定义了自己的迭代器类型，如vector:
vector::iterator iter;这条语句定义了一个名为iter的变量，它的数据类型是由vector定义的iterator类型。

每个不同的容器有不同迭代器，相当于不同容器内的指针

end()与迭代器（iterator）的应用：

vector<int> a;
vector<int>::iterator ite;
ite = a.end()-1; //只想最后一个元素的位置
cout<<*ite<<endl;//输出最后一个元素的值
//将迭代器当做一个指针使用就行了
/* begin() 和 end() 返回值也是一个迭代器，可以配合应用于对数组的遍历*/
for(vector<int>::iterator i = a.begin();i !+ a.end(); i++){
    cout<<*i<<' ';
}

map（映射）

map是一类关联式容器。它的特点是增加和删除节点对迭代器的影响很小，除了那个操作节点，对其他的节都没有什么影响。

对于迭代器来说，可以修改实值，而不能修改key。

函数：

例题：反片语（Ananagrams, Uva 156)

题目：输入一些单词，找出所有满足如下条件的单词：该单词不能通过字母重排，得到输入文本中的另外一个单词。在判断是否满足条件时，字母不分大小写，但在输出时应保留输入中的大小写，按字典序进行排列（所有大写字母在所有小写字母的前面）。

/* 题目：输入一些单词，找出所有满足如下条件的单词：该单词不能通过字母重排，得到输入文本中的另外一个单词。
 * 在判断是否满足条件时，字母不分大小写，
 * 但在输出时应保留输入中的大小写，按字典序进行排列（所有大写字母在所有小写字母的前面）。
 */
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;

map<string,int> id;
vector<string> page;

//标准化，将所有的单词都转化为小写，并按照顺序排列，如果一个单词由相同字母组成，就会产生重复
string standar(string str){
    string ans = str;
    for(int i = 0; i < ans.length();i++){
        ans[i] = tolower(ans[i]);
    }
    sort(ans.begin(),ans.end());
    return ans;
}

int main(){
    //input
    string str;
    
    while(cin>>str){
        if(str[0] == '#') break;
        //将所有的单词都存进去数组里面
        page.push_back(str);
        //如果map里面原本有这个元素就不会运行，如果没有设置为0进行初始化
        if(!id.count(standar(str)))id[str] = 0;
        //不管有没有都要加一
        id[standar(str)]++;
    }

    //输出格式，筛选
    vector<string> words;//新建一个动态数组存放符合输出条件的数据
    
    //遍历所输入的文章里面所有的单词。判断他们的标准化单词是否有重复，没有重复的存入数组
    for(int i = 0; i < page.size();i++){
        if(id[standar(page[i])] == 1) words.push_back(page[i]);
    }
    //因为要按照字母的顺序还有大小写来输出，所以将要输出的结果再一次排序
    //sort的排序是从小到大的
    sort(words.begin(),words.end());
    for(int i = 0; i < words.size(); i++){
        cout<<words[i]<<endl;
    }

    return 0;
}

这题表现了可以用数组的形式来使用map。第一个参数是key值，第二个参数是value值，输入key可以很快的寻找到value值，他们是一一对应的。形成映射的关系。

set（集合）

set集合是c++ STL库中自带的一个容器，set具有以下两个特点：

1、set中的元素都是排好序的

2、set集合中没有重复的元素

举例常用的函数：

#include<stdio.h>
#include<set>
using namespace std;
int main()
{
	set<int>s;
	s.insert(3); 
	s.insert(1);
	s.insert(2);
	s.insert(1);
	set<int>::iterator it;            
	for(it=s.begin();it!=s.end();it++)  //使用迭代器进行遍历 
	{
		printf("%d\n",*it);
	}
	return 0;
}
//输出结果 ： 1 2 3     一共插入了4个数，但是集合中只有3个数并且是有序的，可见之前说过的set集合的两个特点，有序和不重复。

当set集合中的元素为结构体时，该结构体必须实现运算符‘<’的重载

#include<iostream>
#include<set>
#include<string>
using namespace std;
struct people{
    string name;
    int age;
    bool operator<(const people p)const{//重载运算符
        return age<p.age;
        //这边 age 相当于小于号左边，p.age相当于小于号右边，如果左边小于右边return true，否则return false；
    }
};
int main(){
    set<people> s;
    s.insert({"张三",14});
	s.insert({"李四",16});
	s.insert({"王二麻子",10});
    set<people>::iterator it;
    for(it = s.begin(); it != s.end();it++){
        cout<<"name:"<<(*it).name<<"age:"<<(*it).age<<endl;
        //迭代器：用*it 来指定访问的元素，相当于指针，it指向对应的地址，*it获取对应地址的元素！
    }
    return 0;
}

algorithm（算法函数）

导入头文件

#include<algorithm>

1. Sort（）函数

sort(start,end);

start：起始位置

end：结束位置

对 start 到 end 之间的数进行从小到大排序

例：

sort(a,a+10);

对a[0]到a[9]之间的数进行排序

sort(v1.begin(),v1.end());

end()返回的是最后一个数的地址+1

2. max() min()函数

1.头文件

#include<algorithm>

2.使用

max（int ,int）;返回较大值

min（int ,int）;返回较小值

3. unique（）函数

该函数的作用是“去除”容器或者数组中相邻元素的重复出现的元素，注意
(1) 这里的去除并非真正意义的erase，而是将重复的元素放到容器的末尾，返回值是去重之后的尾地址。
(2) unique针对的是相邻元素，所以对于顺序顺序错乱的数组成员，或者容器成员，需要先进行排序，可以调用sort()函数

例：

int a[10] = {1,1,2,2,3,4,5,6,6,3};
unique(a,a+10);   //unique返回的是一个地址  a + 6

int end = unique(a,a+10) - a;   //end = 6
for (int i = 0; i < end; i++){
	cout<<a[i]<<' '<<endl;
}

**4. reverse()函数

reverse(it, it2)可以将数组指针在[it, it2)之间的元素或容器的迭代器在[it, it2)范围内的元素
进行反转。示例如下：

输出如下：

对于容器间的迭代器同样如此迭代器：

输出结果：

5. fill()函数的使用

fill()可以把数组或容器中的某一段区间赋为某个相同的值。和memset不同，这里的赋值可以是数组类型对应范围中的任意值。示例如下：

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;

int main(){
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    string s = "abcdefg";
    //迭代器，容器空间
    fill(s.begin()+2,s.begin()+5,'h');
    //数组
    fill(a+1,a+5,0);
    
    cout<<s<<endl;
    //abhhhfg
    
    for(int i = 0; i < 10; i++){
        cout<<a[i]<<' ';
    }
    return 0;
}

注意：只能赋值是数组类型对应的范围中的任意值，不是数组类型，或者超过这个范围都不行

swap()函数

swap(a[0],a[1]);

交换a[0]和a[1]之间的值

参数是两个地址/引用

最大最小值

1.头文件

#include<climits>

2.使用

INT_MAX : int类型的最大值 —>无穷大

cout<<s<<endl;
//abhhhfg

for(int i = 0; i < 10; i++){
    cout<<a[i]<<' ';
}
return 0;

}


**注意：只能赋值是数组类型对应的范围中的任意值，不是数组类型，或者超过这个范围都不行**



**swap()函数**

` swap(a[0],a[1]);`

> 交换a[0]和a[1]之间的值
>
> 参数是两个地址/引用





**最大最小值**

1.头文件

**`   #include<climits> `**

2.使用

INT_MAX : int类型的最大值 —>无穷大

INT_MIN :  int类型的最小值—>无穷小