C++ STL学习

Vector

简单的遍历

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int main()
{
    vector<int> v1(5,42);//生成一个具有5个42的vector
    v1.push_back(1);//add
    for(int k = 0 ; k<v1.size() ; k++){//遍历
        cout<<v1[k]<<"\n";
    }
    return 0;
}

迭代器遍历

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int main()
{
    vector<int> v1;
    vector<int>:: iterator iter;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);
    cout<<v1.front()<<"\n";//返回第一个元素
    cout<<v1.back()<<"\n";//返回最后一个元素
    for(iter = v1.begin() ; iter!=v1.end() ; iter++){//使用迭代器的方式进行vector的遍历
        cout<<*iter<<"\n";
    }
    v1.clear();//清空元素
    bool b = v1.empty();//判断元素是否为空
    return 0;
}

使用erase进行删除指定元素

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int main()
{
    vector<int> v1;
    vector<int>:: iterator iter;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);

    for(iter = v1.begin();iter!=v1.end();iter++){
        if(*iter%2==0){
            v1.erase(iter);//erase删除指定vector的元素，入参必须得是迭代器
            v1.insert(iter,1,100);//在指定位置插入，
            //第一个参数的val的迭代器，第二个是插入数量，第三个是插入的val
        }
    }
    for(iter = v1.begin();iter!=v1.end();iter++){

        cout<<*iter<<"\n";
    }
    return 0;
}
/**
1
100
3
100
5
*/

vector求交并集，去重

去重

int main()
{
    vector<int>v1;
    vector<int>::iterator iter;
    v1.push_back(2);
    v1.push_back(1);
    v1.push_back(0);
    v1.push_back(11);
    v1.push_back(11);
    v1.push_back(199);
    v1.push_back(199);
    sort(v1.begin(),v1.end());
    iter = unique(v1.begin(),v1.end());//获取需要去重的迭代器
    if(iter!=v1.end()){
        v1.erase(iter,v1.end());//删除重复的迭代器
    }
    for (iter = v1.begin(); iter != v1.end(); iter++)
    {
        cout<<*iter<<"\n";
    }
    
    return 0;
}

交集

vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        vector<int> v;
        set_intersection(nums1.begin(),nums1.end(),nums2.begin(),nums2.end(),back_inserter(v));
        return v;
    }

并集

vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        vector<int> v;
		set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),back_inserter(v));
		return v;
    }

转化

vector转数组

vector<int> previousPermuation(vector<int> &nums)
{
    // write your code here
    char charArr[nums.size()];
    memcpy(charArr,&nums[0],nums.size()*sizeof(nums[0]));
}

数组转vector

vector<int> v(N)
memcpy(&V[0], array, sizeof(array))

map

map底层基于红黑树，会自动按照key的大小进行升序排序，map相当于java的TreeMap，unordered_map相当于java的HashMap。
以下介绍一下map的几种常用操作

插入

map的插入有三种方法

1. 使用pair进行插入

int main()
{
    map<int,string>::iterator iter;
    map<int,string> map1;
    map1.insert(pair<int,string> (1,"张三"));
    map1.insert(pair<int,string> (2,"张三"));
    for (iter = map1.begin(); iter !=map1.end(); iter++){
        cout<<iter->first<<" "<<iter->second<<"\n";
    }
}

另说一点，插入成功的前提条件是key不能一样，不然会被覆盖。

2. 使用value_type进行插入

int main()
{
    map<int,string>::iterator iter;
    map<int,string> map1;
    map1.insert(map<int,string>::value_type (1,"张三"));
    map1.insert(map<int,string>::value_type (2,"张三"));
    for (iter = map1.begin(); iter !=map1.end(); iter++){
        cout<<iter->first<<" "<<iter->second<<"\n";
    }
}

3. 使用数组进行插入

int main()
{
    map<int,string>::iterator iter;
    map<int,string> map1;
    map1[1] = "张三";
    map1[2] = "张三";
    for (iter = map1.begin(); iter !=map1.end(); iter++){
        cout<<iter->first<<" "<<iter->second<<"\n";
    }
}

查找

查找的方法两种：

1. map的count函数，可以统计key的数量，因为key是唯一的，所以只会有1和0，但是我们无法找到其迭代器的位置，当然了，map是有序进行insert的。

int main()
{
    map<int,string>::iterator iter;
    map<int,string> map1;
    map1.insert(map<int,string>::value_type (1,"张三"));
    map1.insert(map<int,string>::value_type (2,"张三"));

    int num = map1.count(1);
    cout<<num<<endl;//1

    // for (iter = map1.begin(); iter !=map1.end(); iter++){
    //     cout<<iter->first<<" "<<iter->second<<"\n";
    // }
}

2. find函数，实际上就是查询其迭代器的坐标

int main()
{
    map<int,string>::iterator iter;
    map<int,string> map1;
    map1.insert(map<int,string>::value_type (1,"张三"));
    map1.insert(map<int,string>::value_type (2,"张三"));

    iter = map1.find(2);
    if(iter!=map1.end()){
        cout<< iter->first << " " << iter->second << endl;//2 张三
    }

    // for (iter = map1.begin(); iter !=map1.end(); iter++){
    //     cout<<iter->first<<" "<<iter->second<<"\n";
    // }
}

删除

map的删除也是用erase来实现的。

1. 清除整个map

map1.erase(map1.begin(),map1.end());

2. 删除map的某个迭代器

iter = map1.find(2);
map1.erase(iter);

unordered_map

unordered_map和java的hashmap的性质是一样的。

常见成员函数如下：
迭代器
begin 　　返回指向容器起始位置的迭代器（iterator）
end 　　 返回指向容器末尾位置的迭代器
cbegin　 返回指向容器起始位置的常迭代器（const_iterator）
cend 　　 返回指向容器末尾位置的常迭代器
Capacity
size 　　 返回有效元素个数
max_size 返回 unordered_map 支持的最大元素个数
empty 判断是否为空
元素访问
operator[] 　　 访问元素
at 　　 　　　　访问元素
元素修改
insert 　　插入元素
erase　　 删除元素
swap 　　 交换内容
clear　　 清空内容
emplace 　构造及插入一个元素
emplace_hint 按提示构造及插入一个元素
操作
find 　　　　　　通过给定主键查找元素,没找到：返回unordered_map::end
count 　　　　　返回匹配给定主键的元素的个数
equal_range 　　返回值匹配给定搜索值的元素组成的范围
Buckets
bucket_count 　　　返回槽（Bucket）数
max_bucket_count 返回最大槽数
bucket_size 　　　 返回槽大小
bucket 　　　　　　返回元素所在槽的序号
load_factor　　　　 返回载入因子，即一个元素槽（Bucket）的最大元素数
max_load_factor 　 返回或设置最大载入因子
rehash　　　　　　 设置槽数
reserve 　　　　　 请求改变容器容量

int main()
{
    unordered_map<int, string> dict;
    unordered_map<int, string>::iterator iter;

    //插入数据的三种方法
    dict.insert(pair<int, string>(1, "value1"));
    dict.insert(unordered_map<int, string>::value_type(2, "value2"));
    dict[3] = "value3";

    //判断unordered_map内是否为空
    if (dict.empty())
    {
        cout << "空的" << endl;
    }
    else
    {
        cout << "不空" << endl;
    }

    //查找某个键值对是否存在
    if (dict.count(1) == 0)
    {
        cout << "不存在key为1的键值对" << endl;
    }
    else
    {
        cout << "存在key为1的键值对" << endl;
    }
    //确切的查找某个键值对
    if (dict.find(1) != dict.end())
    {
        iter = dict.find(1);
        cout << iter->second << endl;
    }
    else
    {
        cout << "不存在这玩意" << endl;
    }
}

set

set底层基于红黑树，所以自带排序功能，插入进来的数字，不管何时都是自动排序的，并且自带去重功能

int main()
{
    set<int> s1;
    set<int>::iterator iter1;

    s1.insert(5);
    s1.insert(5);
    s1.insert(4);
    s1.insert(4);
    s1.insert(3);
    s1.insert(2);
    s1.insert(1);

    for (iter1 = s1.begin(); iter1 != s1.end(); iter1++)
    {
        cout << *iter1 << "\n"
             << endl;
    }

}

unordered_set

底层基于hash表，所以插入删除的速度都是相当快的，但是存储进来是无序的，无法做到有序存储，也拥有去重功能。

int main()
{
    unordered_set<int> s2;
    unordered_set<int> iter2;

    s2.insert(1);
    s2.insert(90);
    s2.insert(76);
    s2.insert(7);
    s2.insert(11);
    s2.insert(8);
    s2.insert(99);

    //一种船新的遍历方法
    for (const auto &tmp : s2)
    {
        cout << tmp << "\n"
             << endl;
    }
}

Stack

一些常用操作
s.empty() 如果栈为空返回true，否则返回false
s.size() 返回栈中元素的个数
s.pop() 删除栈顶元素但不返回其值
s.top() 返回栈顶的元素，但不删除该元素
s.push() 在栈顶压入新元素

Demo演示

#include <iostream>
#include <vector>
#include <queue>
#include <stack>

using namespace std;

int main()
{
    stack<int> stack;
    cout<<stack.empty()<<"\n";//1代表true
    stack.push(1);
    stack.push(2);
    stack.push(3);
    stack.push(4);
    stack.push(5);
    cout<<stack.top()<<"\n";//5
    stack.pop();//删除栈顶元素
    cout<<stack.top()<<"\n";//4
    cout<<stack.size()<<"\n";//4
    cout<<stack.empty()<<"\n";//0代表false

}

Queue

一些常用操作
q.empty() 如果队列为空返回true，否则返回false
q.size() 返回队列中元素的个数
q.pop() 删除队列首元素但不返回其值
q.front() 返回队首元素的值，但不删除该元素
q.push() 在队尾压入新元素
q.back() 返回队列尾元素的值，但不删除该元素

#include <iostream>
#include <vector>
#include <queue>
#include <stack>

using namespace std;

int main()
{
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    q.push(5);
    cout << q.front() << "\n";//打印队首元素 1
    cout << q.back() << "\n"; //打印队尾元素 5
    q.pop();//抛出队列首部元素
    cout << q.front() << "\n";// 2
    cout << q.back() << "\n"; // 5

}

一些常用的库Demo

next_permutation/prev_permutation

打印一个数组下一个字典序的排序（prev_permutation同理）

int main()
{
    int a[] = {1,2,3,4};
    sort(a,a+4);
    while(next_permutation(a,a+4)){
        for (int i = 0; i < sizeof(a)/sizeof(a[0]); i++)
        {
            cout<<a[i];
        }
        cout<<"\n";
    }
     
}
1243
1324
1342
1423
1432
2134
2143
2314
2341
2413
2431
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321

count

int main()
{
	//count函数的用法
	vector<int> v(10);
	int a[10] = { 1, 2, 3, 4, 4, 4, 4 };
	v[0] = 1;
	v[1] = 1;
	v[2] = 1;
	v[3] = 1;
	v[4] = 1;
	v[5] = 1;
	v[6] = 6;
	v[7] = 7;
	v[8] = 8;
	v[9] = 9;
 
	//向量计数
	cout << count(v.begin(), v.end(), 1) << endl;
	cout << count(v.begin(), v.end(), 5) << endl;
	cout << count(v.begin(), v.end(), 6) << endl;
	cout << endl;
	//数组计数
	cout << count(a, a + 10, 0) << endl;
	cout << count(a, a + 10, 1) << endl;
	cout << count(a, a + 10, 4) << endl;
 
 
	system("pause");
	return 0;
}

sort

vector排序

int main()
{
    vector<int> v1;
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(1); 
    sort(v1.begin(),v1.end());
    for (int i = 0; i < v1.size(); i++)
    {
        cout<<v1[i];
    }
    
}
123

数组排序

int main()
{
    int nums[] = {3,2,1};
    sort(nums,nums+3);
    for (int i = 0; i < sizeof(nums)/sizeof(nums[0]); i++)
    {
        cout<<nums[i];
    }   
}
123

lower_bound/upper_bound

查找数组中第一个大于等于或者大于x的数字下标
lower_bound（a,a+a.size(),x）
upper_bound同理

int main()
{
    int nums[] = {1,2,3,4,5,6,7};
    cout<<upper_bound(nums,nums+sizeof(nums)/sizeof(nums[0]),3)-nums;   
}
//3

Find

查找，这个在数组中或者vector中都会用到。
基本使用方法就是find(起始迭代器，终点迭代器，查找内容)
然后写两个demo

在字符串中的查找

int main()
{
    find函数返回类型 size_type
    string s("1a2b3c4d5e6f7jkg8h9i1a2b3c4d5e6f7g8ha9i");
    string flag;
    string::size_type position;
    //find 函数 返回jk 在s 中的下标位置
    position = s.find("jk");
    if (position != s.npos) //如果没找到，返回一个特别的标志c++中用npos表示，我这里npos取值是4294967295，
    {
        printf("position is : %ld\n", position);
    }
    else
    {
        printf("Not found the flag\n");
    }
}

在vector中的查找

int main()
{
    vector<int>v1;
    v1.push_back(2);
    v1.push_back(1);
    v1.push_back(0);
    v1.push_back(11);
    v1.push_back(199);
    vector<int>::iterator iter =  find(v1.begin(),v1.end(),0);
    if (iter!=v1.end())
    {
        //获取下标
        cout<<iter-v1.begin()<<endl;
    }
    return 0;
}

其他

求某个数字中二进制的1的个数

int main()
{
    cout<<__builtin_popcount(101);

}
//4