文章目录

• 一、STL基础概念
• • 1、容器
  • 2、算法
  • 3、迭代器
• 二、vector
• • 1、vector定义及数据存放
  • 2、遍历
  • • a.使用迭代器for循环
    • b.使用for_each循环
    • c.索引历遍
  • 3、vector构造函数
  • 4、vector赋值
  • 5、vector容量和大小
  • 6、vector插入和删除
  • 7、vector数据读取
  • 8、特殊的操作
• 三、string
• • 1、基本概念
  • 2、string构造函数
  • 3、基本操作
  • • a、赋值
    • b、拼接
    • c、查找和替代
    • d、比较
    • e、插入和删除
  • 4、子串
• 四、deque
• • 1、基本概念
  • 2、构造函数
  • 3、插入和删除
  • 4、排序
• 五、stack
• • 1、基本概念
  • 2、常用接口
  • • a、构造函数
    • b、赋值
    • c、数据存放
    • d、大小操作
• 六、queue
• • 1、基本概念
  • 2、常用接口
  • • a.构造函数
    • b、数据存取
    • c、大小操作
• 七、list
• • 1、list的基本概念
  • 2、构造函数
  • 3、赋值和交换
  • 4、大小操作
  • 5、插入和删除
  • 6、反转和排序

一、STL基础概念

1、容器

• 序列是容器：每个元素位置固定
• 关联式容器：二叉树，图

2、算法

• 质变算法：拷贝，删除
• 非质变算法：遍历

3、迭代器

​ 每个容器专属，类似指针

二、vector

1、vector定义及数据存放

定义：单端数组

#include <iostream>
#include <vector>
int main()
{

	vector<int> v;
	v.push_back(10);
	return 0;
}

2、遍历

a.使用迭代器for循环

#include <iostream>
#include <vector>
int main()
{

	vector<int> v;
	v.push_back(10);
    v.push_back(200);
    v.push_back(39);
    vector<int>::iterator itbegin=v.begin();  //指向第一个
    vector<int>::iterator itend=v.end();      //指向最后一个的下一个
    while(itbegin!=itend)
    {
        std::cout<<*itbegin<<std::endl;
        itbegin++;
    }
	return 0;
}

b.使用for_each循环

#include <iostream>
#include <vector>
#include <for_each>

void print(int x)
{
	std::cout<<x<<std::endl;
}
int main()
{

	vector<int> v;
	v.push_back(10);
    v.push_back(200);
    v.push_back(39);
 	for_each(v.begin(),v.end(),print);   //这里的print没有括号   
    return 0;
}

c.索引历遍

#include <iostream>
#include <vector>
#include <for_each>

int main()
{

	vector<int> v;
	v.push_back(10);
    v.push_back(200);
    v.push_back(39);
	for(int i=0;i<v.size();i++)
    {
        std::cout<<v[i]<<std::endl;
    }
    return 0;
}

3、vector构造函数

vector<T> v;   //默认构造函数
vector(v.begin(),v.end());     //拷贝元素
vector(n,elem)   //构造n个elem

4、vector赋值

vector& operator=(const vector &vec);   //等号的运算符重载
assign(begin,end);                      //类似于拷贝元素

5、vector容量和大小

empty()   //判断是否为空
capacity()   //返回其容量
size()    //返回元素个数   size()<=capacity()
resize(int x,elem)   //重新指定大小

6、vector插入和删除

push_back(ele)    //尾部插入
pop_back()       //删除尾部的元素
insert(const_iterator pos,ele);   //在迭代器位置插入元素
erase(const_iterator pos);    //删除迭代器位置的元素
clear()    //清空元素

这里特别注意erase的用法

v.erase(v.begin()+i);   //删除下标为i的元素

7、vector数据读取

at(int index)   //读取索引的数据
[]              //运算符重载
back()          //读取最后一个数据

8、特殊的操作

swap(vec);   //互换元素
reserve(int len)  //预留空间

三、string

string 实质是一个保存字符串的类

1、基本概念

特点：

1. 内部封装了很多成员方法
2. 为char *型的容器

2、string构造函数

string();    //空字符串
string(const char* s);
string(const string& str);
string(int n,char c); //n个c的初始化

/*例子*/
#include <string>
void test()
{
    string s1;   //方法一
    const char* str="Hello";
    string s2(str);   //方法二
    string s3(s2);    //方法三
    string s4(10,'a');
}

3、基本操作

a、赋值

直接使用=对其进行赋值

b、拼接

使用+拼接

c、查找和替代

/*查找*/
int find(const string& str,int pos = 0) const;
int find(const char* str,int pos = 0) const;   //从pos开始查找str返回第一次出现位置
/*替代*/
string& replace(int pos,int n,const string& str);  //替代pos开始n个字符为字符串str

d、比较

直接使用==比较是否相等，>和<可以比较ASCII码

e、插入和删除

insert和erase,同vector

4、子串

string substr(int pos = 0,int n=npos) const;  //返回从pos开始的n个字符的子串

/*与find一起 使用可以做正则运算*/
#include <string>
#include <iostream>
int main()
{
	string a = "ba1caf6289@qq.com"
	int pos = a.find("@");
	string username=a.substr(0,pos);
	std::cout<<username<<'\n';   //通过该方式可以找出username
	return 0;
}

四、deque

1、基本概念

• 功能：双端数组，可以对头部进行插入和删除操作
• 原理：内部存在一个中控器，其中存放每个缓冲区的地址，缓冲区一部分可以前端插入，另外一部分可以后端插入

deque 和 vector 区别:

1. vector 对头部的操作较为低效
2. vector访问内部数据更为高效

2、构造函数

deque<T> deqT

3、插入和删除

push_back(elem);   //在尾部添加数据
push_front(elem);  //在头部添加数据
pop_back();  //删除尾部数据
pop_front(); //删除第一个数据
insert(pos,elem);  //插入
clear();    //清空
erase(pos);   //删除指定位置数据，返回下一个

4、排序

sort(iterator beg,iterator end); //对该区间进行排序

/*实例*/
#include <iostream>
#include <deque>
#include <algorithm>
int main()
{
    deque<int> d;
    d.push_front(10);
    d.push_front(10);
    d.push_front(11);
    d.push_front(13);
    d.push_front(14);
    d.push_back(39);
    d.push_back(32);
    d.push_back(31);
    d.push_back(13);
    d.push_back(59);
    d.push_back(19);
    sort(d.begin(),b.end());
    return 0;
}

五、stack

1、基本概念

特点：先进后出的栈结构，只有顶端元素可以被访问，所以不允许历遍

入栈：push 出栈：pop

2、常用接口

a、构造函数

stack<T> stk;

b、赋值

c、数据存放

push(elem);   //在顶端添加元素
pop();      //移除第一个元素
top();   //返回顶部元素

d、大小操作

empty();   //判断非空
size();    //返回栈的大小

六、queue

1、基本概念

​ 特点：先进先出的数据结构

• 队列允许在一段添加元素，在另外一端删除元素
• 只有队尾和队头可以被外界访问，所以不允许历遍
• 入队：push，出队：pop

2、常用接口

a.构造函数

queue<T> que;

b、数据存取

push(elem);   //队尾添加
pop();    //队头移除
back();   //返回最后一个元素
front();   //返回最后一个元素

c、大小操作

empty();  //判断是否非空
size();   //返回大小

七、list

1、list的基本概念

• 功能：链式存储
• 实质：双向链表

链表组成：一系列结点

结点组成：数据域和指针域

优点：

• 动态存储，不会有内存浪费
• 删除和插入十分的方便

缺点：空间和历遍的时间很大

2、构造函数

list<T> lst;

3、赋值和交换

list& operator=(const list &lst);   //赋值
swap(lst);       //交换

4、大小操作

empty();   //判断非空
size();    //返回栈的大小

5、插入和删除

push_back(elem);   //尾部加入一个元素
pop_back();   //尾端删除
push_front(elem);  //头部加入一个元素
pop_front();   //开头移除第一个元素
insert(pos,n,elem);  //在pos位置插入n个elem
erase(pos);   //删除pos位置的元素
remove(elem);   //删除所有elem元素

6、反转和排序

reverse(); //反转链表
sort();   //链表排序