整理leetcode刷题过程中遇到的常用库函数（c++）

如果有额外的了解需求，可以在微软c++库函数进行了解

以下按照我理解的刷题顺序整理：

数组是刷题的开始，常用的库函数也很简单：
1、在数组的最开始插入一个元素，如数字 1

nums.insert(nums.begin(),1);
nums.begin();//nums[0]

2、表示最后一个元素的后一个元素

nums.end();

3、获得数组的长度

nums.size();

4、重设数组大小

nums.resize(100);    // 此时里面所有元素为 0
cout< 
5、排序从小到大
 
sort(nums.begin(),nums.end());
 
6、翻转数组
 
// 注意下面这个函数是将整个数组翻转,不是排序
// 如果要从大到小排序,需要自定义排序规则
reverse(nums1.begin(),nums1.end());
 
字符串 
构造
 
//构造
string s="123";
char *a="123";
string s = a;
 
1、翻转字符串
 
// result is string
reverse(result.begin(),result.end())
 
2、截取字符串
 
str.substr(start_index,len)
 
3、获得字符串的长度
 
s.length();
 
4、字符串扩容
 
string s(len);
s.resize(len+len2);
 
5、字符串初始化
 
//s="00...00",初始化为n个0
string s(n,'0');
 
6、字符串比较函数
 
int strcmp(string str1,string str2)               //区分字符串中字母大小写地比较
int strcasecmp(string str1,string str2)          //忽略字符串中字母大小写地比较
//str1=str2时，返回0；str1>str时返回1；str1 
7、查找
 
//查找
a.find("12");//返回字串第一个字符的下标，如果没有找到，返回string::npos
 
8、替换
 
//char *a="123";
//替换
a.replace(1,2,"ab"); //ab3
 
9、擦除
 
//char *a="123";
//删除子串
a.erase(1,2); //3
 
10、转化
 
//转成char *
a.c_str();
 
vector 
1、定义
 
//定义：
vector  v;
 
2、访问
 
//访问：
v[i];
 
3、大小
 
//大小
v.size();
 
4、更新
 
//更新
v[i]=a;
 
5、末尾插入
 
//末尾插入
v.push_back(a);
 
6、末尾删除
 
//末尾删除
v.pop_back();
 
7、清空
 
//清空
v.clear();
 
8、空判断
 
//判断空
v.empty();
 
9、排序
 
//排序
sort(v.begin(),v.end());//从小到大
sort(v.rbegin(),v.rend());//从大到小

 
10、翻转
 
//翻转
reverse(v.begin(),v.end());

 
11、自定义排序
 
bool compare(int a,int b) 
{ 
    return a< b; //升序排列，如果改为return a>b，则为降序 
} 
sort(v.begin(),v.end(),compare);
 
12、合并
 
vector.insert(vector.end(),vector1.begin(),vector1.end())
 
哈希表 
1、set
 set主要作用是自动去重，对于期望得到不重复的结果，使用set维护输出列表。由于set，multiset通过平衡二叉树实现，有自动排序功能。set不允许重复，multiset允许重复
 
//定义
set s;
//添加元素
s.insert(i);
//删除元素
s.erase(i);
//查找元素 返回指针
s.find(i);
//大小
s.size();
//遍历
for(set::iterator it=s.begin(); it!=s.end();it++)
{
    cout<<*it< 
2、map
 map是一个使用键值对key-value 模式的容器，map不允许重复键值，而multimap允许重复键值。适用于词频统计类的问题。map的底层是红黑树。
 hashmap操作与map相同，但是底层是hash表，可以在O(1)时间内完成访问操作。
 
//定义
map m;
//插入
m.insert(pair(key,value))
m[key]=value;
//删除 
m.erase(key);
//访问
m[key];//如果没有这个key，则返回0
//遍历
for(map::iterator it=m.begin();it!=m.end();it++)
{
    cout<first<<" "<second< 
map内通过key找value和通过value找key
 
//创建
map aMap;
	

    aMap[0] = 'o';
    aMap[1] = 'a';
    aMap[2] = 'b';
    aMap[3] = 'c';
    aMap[4] = 'd';
    aMap[5] = 'd';//故意弄个重复的value 
    
	int key =2;
	char value='d';
	
	//通过key找value 
	if(aMap.count(key)>0)
	{
    	cout<<"通过key:  "<::iterator it = aMap.begin();it!=aMap.end();it++) 
	{
		if(it->second==value)
			cout<<"通过value:  "<first< 
栈 
1、初始化栈
 
stack s;
 
2、入栈
 
s.push(1);
 
3、出栈
 
s.pop();
 
4、栈空
 
bool b = s.empty()    // 栈空返回true
 
5、得到栈顶元素但不弹出
 
int a = s.top();
 
6、得到栈顶元素并弹出
 
// 没有库函数可以直接既弹出又得到值
int a = s.top();
s.pop();
 
队列 
1、声明一个队列
 
queue q;
 
2、队列长度
 
q.size()
 
3、进队
 
q.push(root);
 
4、出队，并不能获得出队元素
 
q.pop();
 
5、获得队头元素，但不会弹出这个元素
 
TreeNode *temp = q.front();
 
6、取出队头元素并弹出
 
TreeNode *temp = q.front();
q.pop();
 
7、获得队尾元素，但不会弹出这个元素
 
q.back()
 
8、双端队列
 
//定义
deque d;
//增加头元素
d.push_front(i);
//增加尾元素
d.push_back(i);
//访问头元素
d.front();
//访问尾元素
d.back();
//删除头
d.pop_front();
//删除尾
d.pop_back();
//判空
d.empty();
//长度
d.size();

 
树 
1、前序遍历（根，左子，右子）
 
class Solution {
public:
    void preorder(TreeNode* root,vector&res ){
        if(root==nullptr){
            return;
        }
        res.push_back(root->val);
        preorder(root->left,res);
        preorder(root->right,res);
    }
    vector preorderTraversal(TreeNode* root) {
        vector  res;
        preorder(root,res);
        return res;
    }
};
 
2、中序遍历（左子，根，右子）
 
class Solution {
public:
    void inorder(TreeNode*root,vector&res){//记得vector传址
        if(root==nullptr){
            return;
        }
        inorder(root->left,res);
        res.push_back(root->val);
        inorder(root->right,res);
    }
    vector inorderTraversal(TreeNode* root) {
        vectorres;
        inorder(root,res);
        return res;    
    }
};
 
3、后序遍历（左子，右子，根）
 
class Solution {
public:
    void postorder(TreeNode* root,vector&res){
        if(root==nullptr){
            return;
        }
        postorder(root->left,res);
        postorder(root->right,res);
        res.push_back(root->val);
    }
    vector postorderTraversal(TreeNode* root) {
        vectorres;
        postorder(root,res);
        return res;
    }
};
 
以上，就是我个人的一些记录，在我看来，真理无穷，无限进步吧！ 
我是栗子，祝你幸福。