C++中的STL学习

+## 指针
申明指针 int *p
p=&n
(*p)为其中的值

STL介绍

• 万能头文件#include<bits/stdc++.h>

• using namespace std;避免命名与标准库的命名存在冲突，本来访问namespace中的对象，需要std::cout<<n;，引入std后，直接cout<<n即可

• STL架构

• • 容器
• • 算法
• • 迭代器
• • 函数

算法

1. swap（a,b）
2. sort(a,b,cmp)

• bool cmp(int a,int b){return a>b;}

  升序：sort(begin,end,less());
  降序：sort(begin,end,greater()).

• 结构体排序：相当于cmp中return a.c>b.c

struct node{
	int a,b,c;
	bool operator<(const node &_)const{
		return this->c > _c;
	}
}

• 升序 sort(a,b,greater())
• 降序sort(a,b,less())

3. reverse(a,a+n) [a,b)
4. unique(a,a+n) 把重复的数值放在后面

a[ ]={1,1,1,2,2,1,1,4,3}
unique(a,a+n)
a[ ]={1,2,1,4,3,1,4,3}

• 一般使用sort+unique进行排序加去重
• int length=unique(a,a+n)-a;
• int len=unique(v.begin(), v.end())-v.begin();

5. 二分查找 x_bound/binary search

• 前提是容器有序
• lower_bound(l,r,val)返回[l,r)中第一个>=val的元素所在的迭代器（指针）
• upper_bound(l,r,val)返回[l,r)中第一个>val的元素所在的迭代器（指针）
• binary_search(l,r,val)返回是否存在一个值为val

vector 向量 “变长数组”

• 定义： vector name;
• vector数组 ：vector arrayname[size];
• vecotor的访问：
  –下标
  – 迭代器：vecot::iterator it;得到迭代器it，通过*it访问

只有vector和string支持 vi.begin()+3

• 添加元素 vi.push_back(x)
• 删除尾元素vi.pop_back()
• vi.size()
• 清除所有元素 vi.clear()
• vi.insert(it,5)
• 删除 erase（x） erase(a,b)//[a,b)

deque

  deque容器为一个给定类型的元素进行线性处理，像向量一样，它能够快速地随机访问任一个元素，并且能够高效地插入和删除容器的尾部元素。但它又与vector不同，deque支持高效插入和删除容器的头部元素，因此也叫做双端队列。deque类常用的函数如下。

(1) 构造函数

deque():创建一个空deque

deque(int nSize):创建一个deque,元素个数为nSize

deque(int nSize,const T& t):创建一个deque,元素个数为nSize,且值均为t

deque(const deque &):复制构造函数

(2) 增加函数

void push_front(const T& x):双端队列头部增加一个元素X

void push_back(const T& x):双端队列尾部增加一个元素x

iterator insert(iterator it,const T& x):双端队列中某一元素前增加一个元素x

void insert(iterator it,int n,const T& x):双端队列中某一元素前增加n个相同的元素x

void insert(iterator it,const_iterator first,const_iteratorlast):双端队列中某一元素前插入另一个相同类型向量的[forst,last)间的数据

(3) 删除函数

Iterator erase(iterator it):删除双端队列中的某一个元素

Iterator erase(iterator first,iterator last):删除双端队列中[first,last）中的元素

void pop_front():删除双端队列中最前一个元素

void pop_back():删除双端队列中最后一个元素

void clear():清空双端队列中最后一个元素

(4) 遍历函数

reference at(int pos):返回pos位置元素的引用

reference front():返回首元素的引用

reference back():返回尾元素的引用

iterator begin():返回向量头指针，指向第一个元素

iterator end():返回指向向量中最后一个元素下一个元素的指针（不包含在向量中）

reverse_iterator rbegin():反向迭代器，指向最后一个元素

reverse_iterator rend():反向迭代器，指向第一个元素的前一个元素

(5) 判断函数

bool empty() const:向量是否为空，若true,则向量中无元素

(6) 大小函数

Int size() const:返回向量中元素的个数

int max_size() const:返回最大可允许的双端对了元素数量值

(7) 其他函数

void swap(deque&):交换两个同类型向量的数据

void assign(int n,const T& x):向量中第n个元素的值设置为x

map 映射，任何基本类型映射到任何基本类型

1.定义
map<typename1,typename2> mp;
字符串不可以是char，必须是string
2.访问元素

• mp[‘a’]=30
  键值必须唯一，后一个会覆盖前一个
• 迭代器
  map<typename1,typename2>::iterator it;
  it->first;it->second;
  map以键从小到大顺序自动排序

3.常用函数

• mp.find(‘b’)
• erase()
  删除单个
  map<char,int>::iterator it=mp.find(‘b’);
  mp.erase(it）
  删除区间
  mp.erase(first，last）
• mp.size()映射的对数
• mp.clear()

bitset

构造函数
bitset<4> bitset1;　　//无参构造，长度为４，默认每一位为０

bitset<8> bitset2(12);　　//长度为８，二进制保存，前面用０补充

string s = “100101”;
bitset<10> bitset3(s);　　//长度为10，前面用０补充

char s2[] = “10101”;
bitset<13> bitset4(s2);　　//长度为13，前面用０补充

函数
对于一个叫做bit的bitset：
bit.size() 返回大小（位数）
bit.count() 返回1的个数
bit.any() 返回是否有1
bit.none() 返回是否没有1
bit.set() 全都变成1
bit.set§ 将第p + 1位变成1（bitset是从第0位开始的！）
bit.set(p, x) 将第p + 1位变成x
bit.reset() 全都变成0
bit.reset§ 将第p + 1位变成0
bit.flip() 全都取反
bit.flip§ 将第p + 1位取反
bit.to_ulong() 返回它转换为unsigned long的结果，如果超出范围则报错
bit.to_ullong() 返回它转换为unsigned long long的结果，如果超出范围则报错
bit.to_string() 返回它转换为string的结果

字符串中常用string类，总结常用功能
头文件: #include

set

set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出数据，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序。

set<T> s;
set<T> s(s1);
set<T> s(b, e);

b和e分别为迭代器的开始和结束的标记。

• begin() 　　 ,返回set容器的第一个元素
• end() 　　　　 ,返回set容器的最后一个元素
• clear() 　　 ,删除set容器中的所有的元素
• empty() 　　　,判断set容器是否为空
• max_size() 　 ,返回set容器可能包含的元素最大个数
• size() 　　　　 ,返回当前set容器中的元素个数
• rbegin　　　　 ,返回的值和end()相同
• rend()　　　　 ,返回的值和rbegin()相同

遍历set容器的方法：

1. 使用auto关键字获取迭代器

2. 创建set::iterator it;

#include <iostream>
#include <set>
#include <vector>
using namespace std;
set<int> s;
int main()
{
	for(int i = 0;i < 10;i ++)
		s.insert(i);
	// 第一种方式
	for(auto it = s.begin() ; it != s.end() ;it ++){
		printf("%d ", *it);
	}
	cout << endl;
	// 第二种方式
	set<int>::iterator it;
	for(it = s.begin() ; it != s.end() ; it++){
		cout << *it << " ";
	}
	return 0;
}

链表

• list<数据类型> 链表名称；
• forward_list linklist; //单链表

struct ListNode{ //链表结点
int val;
ListNode* next;
ListNode(int x) : val(x), next(NULL){} //初始化
};
这是构造函数的一种初始化内部成员的方式，叫构造函数初始值列表

字符串构造

    string s1();  // si = ""
    string s2("Hello");  // s2 = "Hello"
    string s3(4, 'K');  // s3 = "KKKK"
    string s4("12345", 1, 3);  //s4 = "234"，即 "12345" 的从下标 1 开始，长度为 3 的子串

assign成员函数

    string s1("12345"), s2;
    s3.assign(s1);  // s3 = s1
    s2.assign(s1, 1, 2);  // s2 = "23"，即 s1 的子串(1, 2)
    s2.assign(4, 'K');  // s2 = "KKKK"
    s2.assign("abcde", 2, 3);  // s2 = "cde"，即 "abcde" 的子串(2, 3)

求字符串的长度

size(),length() 

string对象中字符串的连接

    string s1("123"), s2("abc");
    s1.append(s2);  // s1 = "123abc"
    s1.append(s2, 1, 2);  // s1 = "123abcbc"
    s1.append(3, 'K');  // s1 = "123abcbcKKK"
    s1.append("ABCDE", 2, 3);  // s1 = "123abcbcKKKCDE"，添加 "ABCDE" 的子串(2, 3)

string对象的比较

• 小于 0 表示当前的字符串小；
• 等于 0 表示两个字符串相等；
• 大于 0 表示另一个字符串小。

    string s1("hello"), s2("hello, world");
    int n = s1.compare(s2);
    n = s1.compare(1, 2, s2, 0, 3);  //比较s1的子串 (1,2) 和s2的子串 (0,3)
    n = s1.compare(0, 2, s2);  // 比较s1的子串 (0,2) 和 s2
    n = s1.compare("Hello");
    n = s1.compare(1, 2, "Hello");  //比较 s1 的子串(1,2)和"Hello”
    n = s1.compare(1, 2, "Hello", 1, 2);  //比较 s1 的子串(1,2)和 "Hello" 的子串(1,2)

求 string 对象的子串

s2=s1.substr(开始位置，子串长度）

    string s1 = "this is ok";
    string s2 = s1.substr(2, 4);  // s2 = "is i"
    s2 = s1.substr(2);  // s2 = "is is ok"