cpp刷题常用数据结构

模板

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
class Solution {
public:
    void func1(){
        
    }
};

int main(){
    Solution so;
    so.func1();
}

---

数组 vector

数组

int dp[100][2]={0};//定义一个数组，需要用具体的数字声明其长度

初始化

vector<int> nums={1,2,3};
vector<int> nums={};
vector<int> nums(n,m); // 长度是 n，默认值是 m,如果不给默认值，则默认值是0
vector<vector<int>> dp(n,vector<int>(m,0)); 一个 n 行 m 列二维数组，默认值是0

曾删改查，遍历，大小，是否为空

nums.insert(nums.begin()+1,3)//索引1初插入元素3
nums.push_back(3);// 最后插入元素3
nums.pop_back();//弹出最后一个
nums[1]=3;//索引1元素修改为3
if(find(nums.begin(),nums.end(),target)!=nums.end())cout<<"find";
for(auto c:nums){cout<<c;}//遍历
nums.size();//是无符号数，改成有符号(int)nums.size()
nums.empty();

第一个元素 nums.front(),最后一个元素 nums.back()
排序 sort(nums.begin(),nums.end())在原数组上排序，没有返回值
判断是否有序 is_sorted(nums.begin(),nums.end())
二维数组排序，数组 people[n][m]，根据其第一个属性升序排列，当相同时，按照第二个属性降序排列

sort(people.begin(), people.end(), [](const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0] || (a[0] == b[0] && a[1] > b[1]);
        });

找到最大值*max_element(dp.begin(),dp.end());

不太常用

将2个数字组合 make_pair，然后其第一个是 first,第二个是 second

pair<int,int> people;
people=make_pair(10,1);
cout<< people.first; //10
cout<< people.second;//1
//定义一个2维但是每个有2个属性的数组
vector<vector<pair<int,int>>> dp(n,vector<pair<int,int>>(n,make_pair(0,0)))// 定义一个 n*n 矩阵，每个元素有2个属性，其默认值是0

使用迭代器

 	vector<int>::iterator it1;//迭代器是指针的泛指，用来检查容器内元素并遍历容器元素
    vector<int>::iterator it2;
    it1=nums.begin();//nums.begin是向量的起始元素的迭代器，获取该值，用 *nums.begin()
    it2=nums.end()-1;//同理，如果是numd.end(),表示vector中最后一个元素的下一个，默认值为0
    cout<<*it2;

拷贝向量

    std::vector<int> vec{11,22,33,44,55};
    std::vector<int> copyInit(vec);
    vec[0]=999;//改变原vector的内容并不会修改拷贝后的vector的内容。

---

queue

单向队列，先进先出，可以获取第一个元素，最后一个元素，弹出第一个元素，判断是否为空，添加元素到末尾

基本用法

queue<int>q ;
q.pop(); //似乎没有返回值，只是删除第一个进来的元素，要确保里面有元素，否则会报错
q.back();// 确保有元素
q.front();// 确保有元素
q.empty();
q.push(1); //添加元素1

创建一个元素是pair的队列示例

//创建
    queue<pair<int,int>> points;// 创建了一个队列，队列中每个元素是一个pair
    //添加元素
    points.push({1,2});
    //删除元素，先进先出，所以先删除最先进来的
    points.pop();
    //获取队列中第一个元素（也就是最先进来的元素）
    auto [r,c]=points.front();
    points.back();//队列中的最后一个元素
    //获取队列长度
    points.size();

---

优先队列

//对于基础类型 默认是大顶堆
    priority_queue<int> a; 
    //等同于 priority_queue<int, vector<int>, less<int> > a;
    priority_queue<int, vector<int>, greater<int> > c;  //这样就是小顶堆
    priority_queue<string> c;// 大顶堆 ///cbd abcd abc

deque 双向队列

deque<int>d;//定义
d.push_back(1);//尾追加
d.push_back(2);
d.push_front(0);//放到最前面
for(auto x:d){cout<<x;}
d.pop_front();
d.pop_back();
d.front();
d.back();

stack

stack<int>stack1;
    //加入元素
    stack1.push(1);
    //删除元素
    stack1.pop();
    //取栈顶元素
    stack1.top();
    //获取大小
    stack1.size();

string char

字符 用单引号 char c='a';可以加减
字符串用双引号 string s="student"; 只能加法

 sub1=str1.substr(pos,length)

//定义字符串
   string str1="abc";  //必须用双引号
   str1.length();//获取字符串长度
   string str2="bc";
   str1+str2;//字符串之间可以相加,不可以减法
   char c1='a';//必须用单引号
   //字符可以加减
   char c2='b';
   int m1=c1-c2;//是根据ascii码中的顺序给出的结果
   int m2=c1+c2;//根据ascii码中的数字给出的结果
   char s=str1[0];//取一个字符
   //取子字符串
   sub1=str1.substr(pos,length);//pos表示位置索引，length表示子字符串长度
   // 增加，只能是字符
   str1.push_back('a');
   //获取字符串最后一个元素
   str1.back();
   //遍历
    string s1="abc";
    for(auto c:s1){
        cout<<c<<" ";
    }
   
   

将字符串转成 int

string s1="1"; //双引号是 string,单引号是 Char
int num1=stoi(s1); 

ListNode

定义

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

基本使用

//定义一个新的指针
ListNode *dumpy=new ListNode(0);
//定义一个指针指向某个指针
ListNode *cur=dumpy;
//获取指针的值
dumpy->val;
//获取下一个
dumpy->next;

---

TreeNode

定义

 struct TreeNode {
      int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode() : val(0), left(nullptr), right(nullptr) {}
      TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
      TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };

常用用法

TreeNode * root;
    root->left;
    root->right;
    root->val;
//    定义一个queue，其元素是treenode节点
    queue<TreeNode*> p;
//    新建一个Node节点
    TreeNode* node=new TreeNode();
    //构建一个树
    node->val=1;
    TreeNode* node1=new TreeNode();
    TreeNode* node2=new TreeNode();
    node1->val=2;
    node2->val=3;
    node->left=node1;
    node->right=node2;

set 和unordered_set

set会自动排序，
unordered_set不会自动排序，其增删查平均复杂度是O(1)，最坏是O(N)
unordered_set和set语法相同

# include <set>
set<int> res;
res.insert(1)//插入元素
res.erase(1)//删除元素1
if(res.find(1)!=res.end())//查找元素

将 vector 值复制给 unordered_setunordered_set<int>ret（nums1.begin(),nums1.end()）
将unordered_set值复制给vectorvector<int>(result_set.begin(), result_set.end());

map和unordered_map

map是有序的，对有顺序要求的用这个
unordered_map是无序的，查找快

unordered_map

// 定义一个哈希map
    unordered_map<char ,int > hash;
    //添加元素
    hash['c']=1;
    hash.insert({'b',2});
    //清空
    hash.clear();
    // 删除元素
    hash.erase('c');//删除某个元素，传入参数key

定义一个哈希map

unordered_map<char ,int > hash={{ 5, "张大" },{ 6, "李五" }}

定义一个哈希table

    unordered_map<string, vector<string>> table = {
        {"start", {"start", "signed", "in_number", "end"}},
        {"signed", {"end", "end", "in_number", "end"}},
        {"in_number", {"end", "end", "in_number", "end"}},
        {"end", {"end", "end", "end", "end"}}
    };

查找，并打印其 value

 unordered_map<char ,int > hash;
# 方法一：
if( hash.find(key)!=hash.end()) cout<<"找到"<<hash[key];
# 方法二：
auto it =hash.find(target-nums[i]);  // 这里的 it是指针 
if(it!=hash.end()) cout<<it->second;

遍历

for(auto c:hash){
	cout<<c.first; // 打印 其 key
}

count 用法hash.count(key)>0
默认定义的哈希表 int 值是0

unordered_map <int,int> hash1;//存放 a,b 之和 以及 它的个数
for(auto c1:nums1){
	for(auto c2:nums2){
		++hash1[c1+c2]; //应该是默认是0
	}
}