c++数据结构

c++

• 标准库函数
• 输入输出
• • 输入
  • 输出
• 顺序容器
• • [数组 Vector](#数组 Vector)
  • • vector
    • string
    • [string与vector < < <char > > >互转](#string与vector < < <char > > >互转)
  • [链表 List](#链表 List)
  • • 单向链表
    • 双向链表
  • [双端队列 Deque](#双端队列 Deque)
• 关联容器
• • [集 Set](#集 Set)
  • • 有序集合
    • 无序集合
  • [哈希表 Map](#哈希表 Map)
  • • 有序表
    • 无序表
• 容器适配器
• • [队列 Queue](#队列 Queue)
  • [栈 Stack](#栈 Stack)
  • [优先队列 Priority Queue](#优先队列 Priority Queue)

标准库函数

//max_element:查找一个范围内的最大元素的迭代器，*取值
*max_element(mun.begin(), mun.end());

//排序
sort(begin, end);
//稳定排序，不改变相等元素相对位置
stable_sort(begin, end);

//返回范围内等于 val 的元素数量
count(begin, end, val);

//计算范围内元素的累加值，init是初始值，一般为0
accumulate(begin, end, init);

//反转范围内的元素顺序
reverse(begin, end);

#include <limits>
//获得int最小值
int min_int = std::numeric_limits<int>::min();

#include <algorithm> 
//取较小值
int min_val = min(a, b);

输入输出

#include <iostream>

输入

//输入几个字符: a b c
cin >> a >> b >> c; 

//输入一串字符
string s;
cin >> s;

//输入多行
cin >> a >> b >> c;  // 输入 "2 3 c"，空格、制表符或换行符作为分隔都行
cin.ignore();        // 忽略换行符
getline(cin, s);     // 读取第二行

输出

cout << n 
cout << endl; //换行

顺序容器

数组 Vector

c++中的 int[ ], char[ ] 类型基本被vector, string取代

vector

动态数组容器，类似于Java中的ArrayList

谨慎将 v[] 与 v.erase 混合使用

#include <vector> 
//定义
vector<int> v; 

//初始化大小为 5 的 vector
vector<int> v(5); 
vector<int> v = {1, 2, 3, 4, 5};
vector<int> v2(v);  //v和v2必须同种类型
vector<long> m(nums.begin(),nums.end());//vector<int> nums
//二维vector
vector<vector<bool>> visited(n, vector<bool>(m, false));

//通过索引访问
cout << v[0]; 
cout << v.at(0); 
cout << v.front();cout << v.back();//访问第一个和最后一个元素
//添加元素
v.push_back(4); //末尾添加4
v.insert(v.begin() + 1, 10); //在索引 1 的位置插入 10
//删除元素
v.pop_back(); //删除最后一个元素
v.erase(v.begin() + 1);  //删除指定位置的元素
v.clear(); //清空
//获取大小和容量
v.size();
v.capacity(); //当前分配的内存空间能够容纳的元素个数，可以使用 reserve() 预先分配空间，或使用 shrink_to_fit() 缩容
v.empty();
v.assign(n); //重新赋值

string

std::string 是字符串类，支持动态扩展和修改

#include <string>
//定义
string s;
//读取
char ch = s[6];  // 获取索引 6 的字符
char ch = s.at(6); 
//添加
s += "Hello";
s.insert(5, " C++"); // 在索引 5 的位置插入字符串 " C++"
//删除
s.erase(5, 6); //删除从索引 5 开始的 6 个字符
//分割，提取从 pos 开始、长度为 len 的子字符串
s.substr(i, j - i + 1);

string与vector < < <char > > >互转

//string 转 vector<char>
string s = "Hello World!";
vector<char> v(s.begin(), s.end());

//vector<char> 转 string
vector<char> v = {'H', 'e', 'l', 'l', 'o'};
string s(v.begin(), v.end()); 

链表 List

单向链表

struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}
      ListNode(int x) : val(x), next(nullptr) {}
 };
 //新建节点
 ListNode* headNew = new ListNode(val);

//使用 head->next 而不是 head.next

双向链表

struct DLinkedNode {
    int value;
    DLinkedNode* prev;
    DLinkedNode* next;
    DLinkedNode(): value(0), prev(nullptr), next(nullptr) {}
    DLinkedNode(int _value): value(_value), prev(nullptr), next(nullptr) {}
};

也可以用链表容器，原理也是双向链表

#include <list>
list<int> data; 

双端队列 Deque

std::deque是一个双端队列容器类型，通过分块数组结构实现（比较复杂），支持下标访问，手动实现可使用vector或双向链表

#include <deque>

std::deque<int> dq;
dq.push_back(1);  // 添加到尾部
dq.push_front(2); // 添加到头部

dq.pop_back(); // 删除尾部元素
dq.pop_front(); // 删除头部元素

int front = dq.front(); // 获取头部元素
int back = dq.back(); // 获取尾部元素

关联容器

集 Set

元素需要唯一

#include <set>
#include <unordered_set>

有序集合

用于进行范围查询，插入删除，查找时间复杂度 O ( l o g n ) O(logn) O(logn)

// std::set (有序集合，基于红黑树)
std::set<int> s; // 默认升序
std::set<int, std::greater<int>> s_desc; // 降序

s.insert(3); //插入
s.erase(3); //删除
auto it = s.find(10); // 查找 10
if (it != s.end()) {
    // 元素存在
} else {
    //元素不存在
}

无序集合

用于快速查找、插入和删除，时间复杂度平均 O ( 1 ) O(1) O(1)，最坏 O ( n ) O(n) O(n)

// std::unordered_set (无序集合，基于哈希表)
std::unordered_set<int> us;
//其它操作与有序集合相同

哈希表 Map

Map<K, V>

#include <map>
#include <unordered_map>

有序表

// std::map (有序映射，基于红黑树)
std::map<std::string, int> m;

m.insert({"banana", 2});  //插入
m["apple"] = 1; //更新，如果key不存在则新增，存在则更新value

int value = m["apple"]; //读取
int value = m.at("apple");

m.erase("banana"); //移除

auto it = m.find("apple"); //查找key
if (it != m.end()) {
    int i=it->second;//找到了
} else {
    //没查找到
}

m.count(key);//判断map里是否存在该key，如果存在返回1，否则返回0

for (auto& entry : m) { //遍历map
    int num = entry.first;
    int count = entry.second;
}

无序表

// std::unordered_map (无序映射，基于哈希表)
std::unordered_map<std::string, int> um;
//其它操作与有序表相同

容器适配器

将已有容器改造成特定功能

队列 Queue

先进先出，默认基于std::deque，手动实现可使用vector或链表（链表用list或手动实现）

#include <queue>

std::queue<int> q;
q.push(1); //入队
q.pop(); //出队
q.front(); //读取队首元素
q.back(); //读取队尾元素
if(q.empty()) //判断是否为空

栈 Stack

先进后出，默认基于std::deque，手动实现可使用vector或链表（链表用list或手动实现）

#include <stack>

std::stack<int> stack;

stack.push(10); //压入
stack.pop(); //弹出
if(stack.empty()) //判断是否为空

优先队列 Priority Queue

基于std::vector，手动实现可使用动态数组vector或链表

#include <queue>

std::priority_queue<int> pq;//最大堆
std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;//最小堆
priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> q(cmp);//自定义小顶堆
//参数分别是：<队列中存储的元素类型，底层容器，比较函数> 堆名(传入比较函数名)

pq.push(30); //插入元素
pq.emplace(num, count);//插入{num,count}元素，避免临时对象
pq.pop(); //弹出优先级最高的元素
pq.top(); //访问优先级最高的元素

自定义比较器

static bool cmp(pair<int, int>& m, pair<int, int>& n) {
    return m.second > n.second;  // 按 second 降序排序
}