学习 C++(1 月 21 日)

一.时空复杂度

（一）语句（基本单位）

（二）语句执行次数（反映程序的运行时间）

1.T(x, y,⋯)：语句数

2.注意循环中语句的次数

（三）时间复杂度（衡量程序效率/语句执行次数T的化简结果）

1.T->O(f)化简规则：常数->1；各项系数化为1；只保留最高阶的项；loga n 应化为 log n（即算法的运行时间与输入规模n的对数成正比）

2.时间复杂度（最大时间复杂度）的分类

（1）最大（坏）时间复杂度O(f)

（2）最小（好）时间复杂度Ω(f)

（3）精确时间复杂度Θ(f)

（四）空间复杂度（衡量程序内存占用/变量定义次数的化简结果）

记号和化简规则与时间复杂度完全相同。

二.C++ STL（标准模板库）常用组件

(一）pair：二元组（不同类型或相同类型）

#include //引入 C++ 的标准输入输出流头文件，用于使用 std::cout 进行输出操作。
#include //引入 utility 头文件，这个头文件中包含了 std::pair 模板类的定义。
int main() {
    // 创建一个 std::pair 类型的对象 p1，它包含一个 char 类型和一个 double 类型的数据
    std::pair p1 = {'x', 2.5};
    // 创建一个嵌套的 std::pair 类型的对象 p2，它的第一个元素是 int 类型，第二个元素是另一个 std::pair（即 p1）
    std::pair> p2 = {1, p1};
    // 输出 p2 的第一个元素，即 int 类型的值 1
    std::cout << p2.first << ' ';
    // 输出 p2 的第二个元素中的第一个元素，即 p1 的第一个元素，是 char 类型的 'x'
    std::cout << p2.second.first << ' ';
    // 输出 p2 的第二个元素中的第二个元素，即 p1 的第二个元素，是 double 类型的 2.5
    std::cout << p2.second.second << ' ';
    return 0;
}

1 x 2.5

(二）stack：栈（只允许在栈顶进行插入和删除操作）

top() ：返回栈顶元素 O(1)

empty()：返回是否为空 O(1)

size() ：返回元素个数 O(1)

push(value)：  在栈顶插入v alue O (1)

pop() ： 删除栈顶元素 O (1)

#include 
#include //引入 C++ 的 stack 头文件，用于使用 std::stack 容器类。
int main() {
    //创建一个存储 int 类型元素的栈 s
    std::stack s;
    //向栈 s 中依次压入元素 1、2、3、4 和 5。
    //元素的入栈顺序决定了它们在栈中的存储顺序。
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
    s.push(5);
    // 此时栈 s 中的元素顺序为：{1, 2, 3, 4, 5(top)}，栈顶元素为 5
    s.pop();
    // 弹出栈顶元素 5，此时栈 s 中的元素顺序为：{1, 2, 3, 4(top)}
    //注意：pop 操作只会移除元素，而不会返回被移除元素的值
    while (! s.empty()) {
        // 当栈不为空时，进入循环
        std::cout << s.top() << ' ';//返回栈顶元素但不移除它
        s.pop();//将栈顶元素从栈中移除/弹出
    }
    // 最终栈 s 中的元素被全部弹出，s = {}，即栈为空
    return 0;
}

4 3 2 1

(三）queue：队列（只允许在队尾插入元素，在队头删除元素）

front()：返回队头元素 O(1)

back() ： 返回队尾元素 O (1)

empty() ： 返回是否为空 O (1)

size() ： 返回元素个数 O (1)

push(value):  在队尾插入 value O (1)

pop() : 删除队头元素 O (1)

#include 
#include //这是 C++ 标准库中的队列（queue）容器的头文件，它允许我们使用 std::queue 容器类
int main() {
    // 声明一个存储 int 类型元素的队列 q
    std::queue q;
    // 向队列中添加元素 1
    q.push(1);
    // 向队列中添加元素 2
    q.push(2);
    // 向队列中添加元素 3
    q.push(3);
    // 向队列中添加元素 4
    q.push(4);
    // 向队列中添加元素 5
    q.push(5);
    // 此时队列 q 的元素顺序为：{1(front), 2, 3, 4, 5(back)}
    q.pop();
    // 此时队列 q 的元素顺序为：{2(front), 3, 4, 5(back)}
    while (! q.empty()) {
        std::cout << q.front() << ' ';//返回队首元素但不移除它
        q.pop();//将队首元素移除
    }
    // 最终队列 q 为空，即 q = {}
    return 0;
}

2 3 4 5

(四）priority_queue:优先队列(会自动排序但其内部元素不可见，只允许访问最大的元素)

top() 返回最大的元素 O (1)

empty() 返回是否为空 O (1)

size() 返回元素个数 O (1)

push(value) 往堆中插入 value O (log n )

pop() 删除最大的元素 O (log n )

#include 
#include 
int main() {
    // 创建一个存储 int 类型元素的优先队列 pq
    std::priority_queue pq;
    // 向优先队列中依次插入元素 3、1、2
    pq.push(3);
    pq.push(1);
    pq.push(2);
    // 此时优先队列 pq 中的元素顺序为：{1, 2, 3(top)}，堆顶元素为 3
    while (! pq.empty()) {
        // 当优先队列不为空时，进入循环
        std::cout << pq.top() << ' ';
        // 输出堆顶元素
        pq.pop();
        // 弹出堆顶元素
    }
    // 最终优先队列 pq 中的元素被全部弹出，pq = {}，即队列为空
    return 0;
}

3 2 1

(五）vector：动态数组（能根据需要自动扩容，也能手动调整容量）

1.定义和初始化：

std::vector dq1;
// dq1 = {}
std::vector dq2 = {1, 1, 4, 5, 1, 4};
// dq2 = {1, 1, 4, 5, 1, 4}
std::vector dq3(4, 0.5);
// dq3 = {0.5, 0.5, 0.5, 0.5}

2.成员函数：

assign(count, value) 初始化为 count 个 value O ( n )

at(pos) 返回第 pos 个元素 O (1)

operator [pos] 返回第 pos 个元素 O (1)

front() 返回第一个元素 O (1)

back() 返回最后一个元素 O (1)

begin() 返回头部迭代器 O (1)

end() 返回尾部迭代器 O