迭代器，线性表，队列，集合，映射的使用讲解

迭代器（iterator)

定义：

迭代器是一种检查容器内元素并遍历元素的数据类型。迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围。

迭代器和指针的区别：

容器和string有迭代器类型和返回迭代器的成员。如：容器有成员.begin()和.end()，其中

.begin()成员复制返回指向第一个元素的迭代器，即指向第一个元素的“地址”，而.end()成员返回指向容器尾元素的下一个位置的迭代器。

[1,2,3]

即 .begin() 指向的是第一个合法元素的位置，.end() 指向是容器后第一个不合法元素的地址。

相应的还有容器反向迭代器成员 .rbegin() .rend()，.rbegin() 返回容器的元素前最后一个不合法的地址，rend() 返回容器的最后一个合法地址。

容器

Vectot容器（类）

线性表中有 Vector 顺序表 和 list 链表，两者作用比较相似。

Vector 的主要作用就是可变长度的数组，就把他当成数组使用即可。

至于为什么我们选择讲 Vector 而不是 List，因为 Vector 可以当作数组使用，用起来非常简单，也非常方便。

#include<vector>
vector<int> a;//定义了一个int类型的vector容器
vector<int> b[100];//定义了一个int类型的vector容器b组
struct rec{
...
};
vector<rec> c;//定义了一个rec类型的vector容器c
vector<int>::iterator it;//vector的迭代器，与指针类似

vector容器操作：

a.size() :返回实际长度（元素个数），o(1)复杂度

a.empty():容器为空返回1，否则返回0，o(1)复杂度

a.clear():把vector清空

a.begin():返回指向第一个元素的迭代器,*a.begin()与a[0]作用相同

a.end(): 越界访问，指向vector尾部，指向第n个元素再往后的边界

a.front()：返回第一个元素的值，等价于a.begin()和a[0];

a.back()： 返回最后一个元素的值，等价于*--a.end()和a[size()-1];

a.push_back()：把元素x插入vector尾部

a.pop_back()：删除vecotor中最后一个元素

遍历的方式：

1.迭代器使用与指针类似

for(vector<int>::iterator it=a.begin();it!=a.end();it++)
    cout<<*iterator<<endl;
for(auto it=a.begin();it!=a.end();it++)
    cout<<*iterator<<endl;

2.当成数组使用

for(int i=0;i<a.size();i++)
    cout<<a[i]<<endl;

队列Queue

定义方式：

queue<string> myqueue;
queue<int> myqueue_int;

成员函数：

• front()：返回 queue 中第一个元素的引用。
• back()：返回 queue中最后一个元素的引用。
• push(const T& obj)：在 queue 的尾部添加一个元素的副本。
• pop()：删除 queue 中的第一个元素。
• size()：返回 queue 中元素的个数。
• empty()：如果 queue 中没有元素的话，返回 true。

Map映射

f[x]=t

map 是一个关联容器，它提供一对一的 hash。

• 第一个可以称为关键字(key)，每个关键字只能在 map 中出现一次
• 第二个可能称为该关键字的值(value)

map 以模板（泛型）方式实现，可以存储任意类型的数据，包括使用者自定义的数据类型。Map 主要用于资料一对一映射（one-to-one）的情況，map 在 C++ 的內部的实现自建一颗红黑树，这颗树具有对数据自动排序的功能。在 map 内部所有的数据都是有序的。

比如，像是管理班级内的学生，Key 值为学号，Value 放其他信息的结构体或者类。

C++中的Map

定义方式：

map<char,int> mymap1;

map<string,int>mymap2;

一般用法：

1. 看容量。

int map.size();//查询map中有多少对元素
bool empty();// 查询map是否为空

    2.插入

map.insert(make_pair(key,value));
//或者
map.insert(pair<char,int>(key,value));
//或者
map[key]=value;

      3.取值

map<int,string> map;
cout<<map[2233]<<endl;
如果map中没有关键字2233，使用[]会导致插入；因此上面的语句不会报错，但会使得输出结果为空

map.at(2016)="Bob";
使用at会进行关键字检查，因此这个语句会报错

    4.遍历操作

map<string,string>::iterator it;
for(it=mapSet.begin();it!=mapSet.end();++it)
{
cout<<"key"<<it->first<<endl;
cout<<"value"<<it->second<<endl;
}

   5.查找操作

m.count(key)：//由于map不包含重复的key，因此m.count(key)取值为0，或者1，表示是否包含。
m.find(key)：//返回迭代器，判断是否存在。

Set 使用

在C++中，set是一个基于红黑树实现的关联容器，它可以自动将元素排序并保持唯一性。默认情况下，set使用元素类型的<运算符来比较和排序其元素。如果你想要一个自定义的排序准则，可以在声明set时指定一个比较函数或函数对象。

#include <bits/stdc++.h>
using namespace std;



// 1.set 的定义 set<数据类型> 变量名

set<int> intSet;
set<string> stringSet;

int main()
{
    string s1="测试1";
    string s2="测试2";
    string s3="测试3";

    //2. 插入操作
    stringSet.insert(s3);
    stringSet.insert(s1);

    //5. 返回集合元素数量
    printf("前2次插入操作完成后的元素数量为%d\n",stringSet.size());
    stringSet.insert(s2);
    printf("前3次插入操作完成后的元素数量为%d\n",stringSet.size());

    //6.遍历整个集合，借助迭代器实现
    //定义方式   容器类型< type> ::iterator name
    set<string> ::iterator  setStringIterator;
    for(setStringIterator=stringSet.begin();setStringIterator!=stringSet.end();setStringIterator++)
        cout<<*setStringIterator<<" ";
    puts("");

    //3. 删除操作
    stringSet.erase(s3);
    printf("删除操作完成后的元素数量为%d\n",stringSet.size());

    for(setStringIterator=stringSet.begin();setStringIterator!=stringSet.end();setStringIterator++)
        cout<<*setStringIterator<<" ";
    puts("");

    //4. 判断是否由此元素
    if(stringSet.count(s2)!=0) cout<<"存在元素"<<s2<<endl;
}

运行结果

前两次插入操作完成后的元素数量为2
前两次插入操作完成后的元素数量为3
测试1 测试2 测试3
删除操作完成后的元素数量为2
测试1 测试2
存在元素测试2

Process finished with exit code 0

# set 的定义 变量名=set()
intSet=set()

stringSet=set()


s1 = "测试1"
s2 = "测试2"
s3 = "测试3"

# 2. 插入操作

stringSet.add(s3)
stringSet.add(s2)

#5.返回集合元素数量
print("前2次插入操作完成后的元素数量为%d\n",len(stringSet))
stringSet.add(s1)
print("前3次插入操作完成后的元素数量为%d\n",len(stringSet))


#6.遍历整个集合
for ele in stringSet:
    print(ele,end=' ')
print()

#3. 删除操作
stringSet.discard(s3)

print("删除操作完成后的元素数量为%d\n",len(stringSet))
for ele in stringSet:
    print(ele,end=' ')
print()

# 4. 判断是否由此元素
if  s2 in stringSet:
    print("存在元素")
    
    
 

前2次插入操作完成后的元素数量为%d
 2
前3次插入操作完成后的元素数量为%d
 3
测试1 测试2 测试3 
删除操作完成后的元素数量为%d
 2
测试1 测试2 
存在元素

自定义排序准则：

要使用自定义排序准则，你可以定义一个比较函数或者更常见的是定义一个比较类（比较函数对象），然后将其作为第二个模板参数传递给set。

使用比较类（函数对象）

定义一个比较类通常更灵活，因为它可以持有状态（虽然在大多数排序场景中不需要）。

#include <iostream>
#include <set>

// 比较类
struct Compare {
    bool operator()(const int& a, const int& b) const {
        return a > b; // 降序排序
    }
};

int main() {
    std::set<int, Compare> s;

    s.insert(3);
    s.insert(1);
    s.insert(4);
    s.insert(2);

    for (int x : s) {
        std::cout << x << " ";
    }

    return 0;
}

在这个例子中，set使用提供的比较准则来排序其元素。在第二个例子中，我们定义了一个比较类，并将其作为set的模板参数。