STL

  1 //****************STL*************
#include <vector> // 向量：用于存储连续的元素，类似数组
#include <set> // 集合
#include <queue> // 队列
#include <stack> // 栈
#include <map> // 映射：相当于一个坐标无限大的数组
#include <list> // 列表：类似于链表
using namespace std;
int main() 
{
    min(x, y)//：取两者中的较小值
    max(x, y)//：取两者中的最大值
    swap(x, y)//：交换两者的值

    sort(first, last)//：对于在 [first, last) 中的元素进行排序
    sort(first, last, comp)//：对于在 [first, last) 中的元素进行排序，其中 comp 为比较器

    int a[10] = {5, 2, 1, 3, 4};
    sort(a, a+5);// a = [1, 2, 3, 4, 5, ...] 普通排序
    int cmp(int x, int y) 
    {
        return x > y;   // 比较器
    }
    sort(a, a+5, cmp);// a = [5, 4, 3, 2, 1, ...] 从大到小排序

    lower_bound(first, last, element)
    int a[10] = {5, 2, 1, 3, 4, 3, 2, 4};
    sort(a, a+8); // a = [1, 2, 2, 3, 3, 4, 4, 5] 已从小到大排好序
    int p2 = lower_bound(a, a+8, 2) - a; // p2 = 1// a中最前的不比 2 小的元素是: a[1] = 2

    int p4 = lower_bound(a, a+8, 4) - a; // p4 = 5// a中最前的不比 4 小的元素是: a[5] = 4

    int p0 = lower_bound(a, a+8, 0) - a; // p0 = 0// a中最前的不比 0 小的元素是: a[0] = 1

    int p6 = lower_bound(a, a+8, 6) - a; // p6 = 8// a中没有不比 6 小的元素，所以返回最后的一个位置 a[8]

    // 注意:a[8] 中并没有值，是数组的最末端
//*********向量************

//向量 (vector)：用于存储连续的元素，类似数组；并且可以动
//态改变数组的大小(不必提前声明数组大小)   

// vector 声明

    vector<int> a; // 声明一个空的 vector
    vector<int> b(5, 0); // 声明 vector 中有 5 个元素，并且初始值都为 0
  
    // vector 访问
    
    for(int i=0; i<5; i++) b[i] = i; // vector 中下标从 0 开始
    // ! a[0] = 1; 非法操作：a 还是空的，没有第一个位置
    // ! a[5] = 5; 非法操作：b 没有第六个位置
    
    // vector 添加元素
    
    for(int i=0; i<5; i++) a.push_back(i * i); // 在 a 最后增加一个元素
    for(int i=0; i<5; i++) cout << a[i] << "?"; // 输出 vector a
    // 输出结果: 0 1 4 9 16 

    // vector 设定长度
    
    vector<int> c;
    c.resize(5); // 设置 c 的大小为 5，下标 [0-4]
    c[4] = -4; // c[4] 是可以被访问的
    
    // vector 长度 (数组大小)
    
    int len = c.size(); // len = 5
    
    // vector 清空
    
    c.clear(); // 清空 c 数组
    // !c[4] = -4; 非法操作：数组已经被清空，长度变为 0

//****************二元组*********** 

//二元组 (pair)：用于存储二元组 (x,y)(并且 x,y 类型可以不相同)

    #include <algorithm>
    
    // pair 声明
    
    pair<int, int> a; // 声明一个二元组 a，用尖括号括起来
    pair<int, int> b(3, 4); // 声明一个二元组 b， x=3, y=4
    typedef pair<int, int> PI; // 使用类型定义
    PI c(5, 6); // 声明一个二元组 c
    
    // pair 访问
    
    int x = c.first, y = c.second; // x = 5, y = 6
    PI d = c; // 相同类型的二元组可以直接赋值
    c = PI(7, 8); // 重新赋值二元组
    d = make_pair(9, 10); // 另一种赋值方式

//二元组 (pair)的一个优点是可以直接比较大小；它会先比较第一关键字(x)，再比较第二关键字(y)。

    PI arr[10];
    
    for(int i=0; i<5; i++) arr[i] = PI(5 - i, i * i);
    
    sort(arr, arr+5);
    
    for(int i=0; i<5; i++)
    
    cout << "First?element:" << arr[i].first << "?"<< "Second?element:" << arr[i].second << endl;
    
/*输出结果：
First element:1 Second element:16
First element:2 Second element:9
First element:3 Second element:4
First element:4 Second element:1
First element:5 Second element:0*/

    typedef pair<int, PI> PII; // 定义三元组
    
    PII p = PII(2, PI(4, 8)); // 嵌套定义三元组
    cout << p.first << "," << p.second.first << ","<< p.second.second << endl; // 嵌套输出
    typedef pair<string, int> People; // 定义字符串 -整数二元组
    
    People pa("Edward", 16);
    People pb("Bob", 17);
    
    if(pa > pb) swap(pa, pb); // 比较大小
    cout << pa.first << ":" << pa.second << endl; // 输出较小值

//*********set(集合)*********

//在集合 (set)中，可以像普通的集合一样，保存所有不同的数：

    set<int> S; // 定义一个整型类型的 set
    
    for(int i=0; i<10; i++) S.insert(i*i); // 把 0-9 的平方数加入集合中
    
    set<int>::iterator p; // iterator：迭代器，相当于一个指针
    
    p = S.find(4); // 指针 -- 找到 4 所在位置
    
    cout << *p << endl; // 输出这个位置的值 -- 4
    
    ++p; // 指针后移
    
    cout << *p << endl; // 输出后一个平方数的值 -- 9
/*输出结果：
4
9*/

//在集合 (set)中，可以支持查找一个数的位置：

    p = S.find(5); // 假如我们想要找一个集合中没有的数
    cout << "Notice?:?(5?is?not?a?square?number)?" << *p << endl;
    cout << (p == S.end()) << endl;
    
// 就会返回一个特殊的指针：S.end() 结尾的指针
// C++ 中的容器都是左闭右开的：
// S.begin() 头指针 - 存放数据，S.end() 尾指针 - 不存放数据

//在集合 (set)中，还有另一种方式查看一个数是否在集合中：

    for(int i=0; i<10; i++)
    
    if(S.count(i)) cout << i << "?is?an?element?of?S." << endl;
    
    else cout << i << "?is?not?an?element?of?S." << endl;
    
    // count(x)，如果 x 存在则返回 1，不存在则返回 0
    
/*输出结果：
0 is an element of S.
1 is an element of S.
2 is not an element of S.
3 is not an element of S.
4 is an element of S.
5 is not an element of S.
6 is not an element of S.
7 is not an element of S.
8 is not an element of S.
9 is an element of S.*/

//在集合 (set)中，亦可以直接支持lower_bound 操作：


    p = S.lower_bound(20); // 假如我们想要找一个集合中不小于 20 的数
    
    cout << "The?first?element?not?lower?than?20:?" << *p << endl;
    
    S.delete(p); // 删除一个数：使用指针的方式
    p = S.lower_bound(20); // 再次寻找
    cout << "The?first?element?not?lower?than?20:?" << *p << endl;
    
    p = S.lower_bound(100); // 假如我们想要找一个集合中不小于 100 的数
    cout << (p == S.end()) << endl; // 假如没有数比它大，则返回尾指针

/*输出结果：
The first element not lower than 20: 25
The first element not lower than 20: 36
1*/

    vector<int>::iterator vi; // 定义迭代器，直接在后面加::iterator
    vector<int> V; // 定义容器
    
    for(int i=1; i<10; i++) V.push_back(i * 3 - 2); // 新增值
    for(vi = V.begin(); vi != V.end(); ++vi) cout << *vi << "?";
    
    cout << endl; // 按顺序输出容器中的值

// 特殊的迭代器：V.begin(), V.end()(左闭右开)
// 迭代器可以自增：往后挪一位
// 不同容器的迭代器存在着区别

/*输出结果：
1 4 7 10 13 16 19 22 25*/

// STL 中每个容器都有对应的迭代器。
    set<int> S; // 定义容器
    set<int>::iterator p; // 定义迭代器
    
    for(int i=0; i<10; i++) S.insert(i * i); // 插入平方数
    p = S.begin(), ++p;
    S.erase(p); // 第一种删除方式（迭代器） ：删除第二个元素
    S.erase(49); // 第二种删除方式（值删除） ：删除 49
    cout << "The?Sequence?:?";
    
    for(p = S.begin(); p != S.end() ; ++p) cout << *p << "?";
    cout << endl; // 顺序输出
    
/*输出结果：
The Sequence : 0 4 9 16 25 36 64 81*/

}

相信你会收获许多******

想继续收获，请搜索 “数据结构” 与本园