STL相关容器的使用操作

1.vector的常规操作：

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    vector<int> a; //相当于一个长度动态变化的int数组
    vector<int> b[233]; //相当于第一维长度233,第二维长度动态变化的int数组
    vector<int> c({1, 2, 3}); //注意这里添加了分号

    a.size(); //数组实际长度
    a.empty(); //是否为空返回false和true
    a.clear(); //当前数组清空
    //遍历vector 三种遍历方式
    //普通遍历
    for (int i = 0; i < c.size(); i++)
        cout << c[i] << ' ';
    cout << endl;
    //迭代器遍历
    for (auto i = c.begin(); i != c.end(); i++)
        cout << *i << ' ';
    cout << endl;
    //范围遍历
    for (auto x : c)
        cout << x << ' ';
    cout << endl;
    
    c.push_back(4);//在最后加一个元素
      for (int i = 0; i < c.size(); i++)
        cout << c[i] << ' ';
    cout << endl;
    
    c.pop_back();
      c.pop_back();
      
         for (int i = 0; i < c.size(); i++)
        cout << c[i] << ' ';
      

    struct Rec
    {
        int x, y; 
    };

    vector<Rec> d; 

    return 0;
}

vector的定义初始化：

​
vector<char> charVec(10, 'a'); // 创建了一个大小为10的，且内容全为'a'的 char 数组
vector<float> floatVec(8, 3.14f); // 创建了一个大小为8的，且内容全为3.14的 float 数组
vector<bool> boolVec(6, true); // 创建了一个大小为6的，且内容全为true的 bool 数组

int x = 3, y = 4, z = 2;
vector<vector<vector<int>>> threeDVec(x, vector<vector<int>>(y, vector<int>(z))); // 创建了一个大小为3*4*2的三维数组

vector<vector<double>> doubleVec(6, vector<double>(6, 0.0)); // 创建了一个大小为6*6的二维数组，全部元素初始化为0.0

vector<int> arr3(10); // 创建了一个大小为10的 int 数组，元素初始化为默认值（0）
vector<int> arr4(15, 5); // 创建了一个大小为15的 int 数组，元素全部初始化为5

vector<string> str3(3, "hello"); // 创建了一个大小为3的 string 数组，元素全部初始化为"hello"

vector<int> shuzu3 = {2, 4, 6, 8}; // 使用列表初始化创建 vector，shuzu3 初始化为2, 4, 6, 8

​

vector的清空：

/*在 C++ 中，清空 vector 不需要如此麻烦，你可以使用 clear() 函数来清空 vector，这会将 vector 中的所有元素移除，使其变为空 vector，但是内存空间可能仍然保留。如果你想释放内存空间，你可以使用 shrink_to_fit() 函数（在 C++11 及以后版本中）或者使用交换技巧。下面是一个示例：
*/
#include <iostream>
#include <vector>

using namespace std;

int main() {
    // 创建一个包含 50 个元素，每个元素值为 2 的 vector
    vector<int> a(50, 2);
    cout << "Original capacity: " << a.capacity() << "\t" << "Original size: " << a.size() << endl;

    // 使用 clear() 函数清空 vector
    a.clear();
    cout << "After clear() - Capacity: " << a.capacity() << "\t" << "Size: " << a.size() << endl;

    // 使用 shrink_to_fit() 函数释放内存空间
    a.shrink_to_fit();
    cout << "After shrink_to_fit() - Capacity: " << a.capacity() << "\t" << "Size: " << a.size() << endl;

    // 使用交换技巧清空 vector
    vector<int> b(50, 2);
    cout << "Original capacity: " << b.capacity() << "\t" << "Original size: " << b.size() << endl;

    vector<int>().swap(b);
    cout << "After swap() - Capacity: " << b.capacity() << "\t" << "Size: " << b.size() << endl;

    return 0;
}
//总结起来，如果你只是想清空 vector 中的元素而不释放内存，使用 clear() 就足够了。如果你想释放内存，可以使用 shrink_to_fit() 函数或者使用交换技巧。

2.string的常规操作：

#include <iostream>
#include <string>

using namespace std;

int main() {
    string s1;             // 默认初始化，s1是一个空字符串
    string s2 = s1;        // s2是s1的副本，s2只是与s1的值相同，不是指向同一段地址
    string s3 = "hiyaaaa"; // s3是该字符串字面值的副本

    string s4(10, 'c');            // s4的内容是"cccccccccc";

    string str2(s3, 3, 5);         // 将str2初始化为s3中从第3位置到第5为止的字符
    string str3(s3, 3);            // 将str3初始化为s3中从第3位置到末尾的字符

    string str4("hellonihao", 5);  // 将str4初始化为从字符串常量开头往后5字节的内容（会输出hello)

    // 输出字符串
    cout << "s1: " << s1 << endl;
    cout << "s2: " << s2 << endl;
    cout << "s3: " << s3 << endl;
    cout << "s4: " << s4 << endl;
    cout << "str2: " << str2 << endl;
    cout << "str3: " << str3 << endl;
    cout << "str4: " << str4 << endl;

    return 0;
}

string的输入输出：

#include <iostream>
#include <string>

using namespace std;

int main() {
    string s1 = "Hello";
    string s2 = "World";

    // 比较操作
    bool equal = s1 == s2;
    bool not_equal = s1 != s2;
    bool less_than = s1 < s2;
    bool greater_than = s1 > s2;

    cout << "s1 == s2: " << equal << endl;
    cout << "s1 != s2: " << not_equal << endl;
    cout << "s1 < s2: " << less_than << endl;
    cout << "s1 > s2: " << greater_than << endl;

    // 字面值和字符串相加
    string ss1 = "Hello";
    string ss2 = "World";
    string ss3 = ss1 + ", " + ss2 + "!";
    cout << "Concatenated string: " << ss3 << endl;

    // empty() 函数和 size() 函数
    string arr1, arr2 = "1231";
    cout << "arr1 is empty: " << arr1.empty() << endl; // 输出 1 表示 true
    cout << "arr2 is empty: " << arr2.empty() << endl; // 输出 0 表示 false

    cout << "Size of arr1: " << arr1.size() << endl; // 输出 0
    cout << "Size of arr2: " << arr2.size() << endl; // 输出 4

    return 0;
}

string的清空：

//彻底清空string 容器的函数（.clear()并不会释放内存空间，只会把size()清零
s1.clear();		//使用shrink_to_fit()函数前，先用clear()清空
s1.shrink_to_fit();		//将s1多余的空间（未使用)释放
cout << "Capacity after shrink_to_fit() is " << s1.capacity()<< " and size is " << s1.size() << '\n';
 
 
string().swap(s3);		//将s3清零并释放
cout << "Capacity after swap() is " << s3.capacity() << " and size is " << s3.size() << '\n';

3.queue的常规操作:

先进先出，讲究队尾插入，队头输出

#include <iostream>
#include <queue>

using namespace std;

int main() {
    // 创建一个整型队列
    queue<int> q;

    // 向队列中插入一些元素
    q.push(10);
    q.push(20);
    q.push(30);
    q.push(40);

    // 输出队列的大小
    cout << "队列的大小: " << q.size() << endl;

    // 访问队列的头部和尾部元素
    cout << "队头元素: " << q.front() << endl;
    cout << "队尾元素: " << q.back() << endl;

    // 弹出队头元素
    q.pop();

    // 再次输出队头元素
    cout << "弹出一个元素后，队头元素: " << q.front() << endl;

    return 0;
}

优先队列的操作理解：

push    // 把元素插入堆
pop     // 删除堆顶元素
top     // 查询堆顶元素（最大值）

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct ps1
{
	int a;
	int b;
	bool operator <(const ps1& j)const		//重载小于号
	{
		return a < j.a;
	}
 
};
int main()
{	//优先队列里没有.front()以及.back()
	priority_queue<int>q;				//优先队列，默认大根堆，即堆顶元素为最大值
	priority_queue<int, vector<int>, greater<int>>p;	//小根堆
	priority_queue<ps1>ps;				//优先队列，类型为结构体，默认大根堆，要重载小于号,
	ps.push({ 2, 3 });				//把结构体元素插入堆
	ps.push({ 22,33 });
	cout << ps.size() << endl;		//.size()输出元素长度
	cout << ps.top().b << endl;		//.top()查询堆顶元素(默认大根堆的话，就是最大值)
	ps.pop();						//.pop()删除堆顶元素
	cout << ps.top().b << endl;
	cout << ps.empty() << endl;		//.empty()判断是否为空
 
	//队列的清空，队列没有.clear()函数
	ps = priority_queue<ps1>();		//可以让队列等于一个空队列，来清空里面的值
	cout << ps.empty() << endl;		//.empty()判断是否为空
	priority_queue<ps1>().swap(ps);			//通过与空队列交换来释放空间
 
	return 0;
}

4.stack：

栈，讲究先进后出，栈顶插入，栈顶弹出  ：

push    // 向栈顶插入
pop     // 弹出栈顶元素
top     // 查询栈顶元素

stack<int> a;			//定义栈a
a.push(50);		//.push()向栈顶插入
a.push(3);
a.push(100);
cout << a.top() << endl;		//.top()查询栈顶元素
a.pop();				//.pop()弹出栈顶元素
cout << a.top() << endl;
cout << endl;
cout << a.size() << endl;
stack<int>().swap(a);			//通过交换空栈来释放空间
cout << a.size() << endl;

关于单调栈：

#include <iostream>

using namespace std;

const int N = 100010;

int n;
int stk[N],tt;
//tt 表示栈顶指针，stk 是一个数组，用来模拟栈。因此，stk[tt] 表示栈顶元素。
int main()
{
    cin >> n;
    for(int i=0;i<n;i++)
    {
        int x;
        cin >> x;//从标准输入流中读入一个整数，赋值给变量x，表示当前处理的数。
        while(tt&&stk[tt]>=x)tt--;
        //从栈顶往里面找，找到第一个比i小的数为止
        //stk[tt]>=x栈顶元素永远都不会用到了
        if(tt)cout << stk[tt] << ' ';
        else cout << -1 << ' ';
        
        stk[++tt]=x;//将当前处理的数x压入栈中。
    }
    return 0;
}

5.deque（双端队列）:

是C++标准库提供的一种数据结构，它允许在两端高效地进行插入和删除操作。deque 的全称是 double-ended queue，它提供了与 vector 类似的功能，但在头部插入和删除元素的操作上更为高效，因为它的内部实现采用了分段连续存储空间的结构。

与 vector 相比，deque 具有以下特点：

• 在头部和尾部的插入和删除操作都是常数时间复杂度 O(1)。
• 支持随机访问，可以通过索引直接访问元素，时间复杂度为 O(1)。
• 在中间位置的插入和删除操作相对较慢，需要移动元素，时间复杂度为 O(n)。

deque 的使用与 vector 类似，你可以在程序中包含 <deque> 头文件，以下是一个简单的例子：

#include <iostream>
#include <vector>
#include <deque>
using namespace std;
 
int main()
{	
	deque<int>q(5, 2);			//初始化双端队列q，元素个数是5，都为2；
	deque<int>p = { 1,2,3 };			//初始化为1,2，3
 
	for (auto k : q)
		cout << k << "  ";
	cout << endl;
 
	for (auto k : p)
		cout << k << "  ";
	cout << endl;
 
	cout << p.front() << endl;	//.front()返回队头元素
	cout << p.back() << endl;	//.back()返回队尾元素
 
	p.push_back(55);			//.push_back()队尾入队
	p.push_front(33);			//.push_front()队头入队
 
	for (auto k = p.begin(); k != p.end(); k++)		//.begin()返回双端队列的头迭代器，.end()返回双端队列的尾迭代器
		cout << *k << "  ";
	cout << endl;
 
	p.pop_back();			//.pop_back()从队尾出队
	for (auto k = p.begin(); k != p.end(); k++)		
		cout << *k << "  ";
	cout << endl;
 
	p.pop_front();			//.pop_front()从队头出队
	for (auto k = p.begin(); k != p.end(); k++)		
		cout << *k << "  ";
	cout << endl;
	
	p[0] = 999;
	for (auto k = p.begin(); k != p.end(); k++)
		cout << *k << "  ";
	cout << endl;
 
	deque<int>().swap(p);			//与空双端队列交换，来释放内存
	cout << p.size() << endl;
	return 0;
}