刷题过程中，那些总也记不住的语法_sort(vet.begin(), vet.end(), greater<int>())-优快云博客

本文链接：https://blog.youkuaiyun.com/Scarlett_Guan/article/details/104059714

这篇文章中的内容，只是采用我比较熟悉的方式进行记录，内容零散，格式混乱，请多包涵。

大致分了类：

一、与vector相关的

1、sort（不光用于vector）

（1）Sort函数有三个参数：（第三个参数可不写）

第一个是要排序的数组的起始地址。

第二个是结束的地址（最后一位要排序的地址）

第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。

sort(vect.begin(), vect.end(), less<int>() ); 默认从小到大排序

sort(vect.begin(), vect.end(), greater<int>() ); 从大到小排序

（2）对于sort快排第三个参数的处理方法：

何时可以省略：只要有定义小于运算的都能省略，包括自己定义的类型有小于运算的。
何时不能省略：没有定义小于运算的，或者想排序的方式和默认小于运算不同的时候。
如果没有规定运算规则的话，需要自己写排序函数，不能省略。

（3）自定义排序时，sort中的比较函数cmp要声明为静态成员函数或全局函数，不能作为普通成员函数，否则会报错：invalid use of non-static member function。

    static bool cmp(Interval a, Interval b){
        if(a.start != b.start)
            return a.start<b.start;
        else
            return a.end<b.end;
    }

2、把一个vector直接装到一个队列中

queue<ListNode *>q{lists};

3、把一个vector装到一个set中

classSolution {
public:
    boolcontainsDuplicate(vector<int>& nums) {
        return nums.size() >unordered_set<int>(nums.begin(),nums.end()).size();
    }
};

4、vector删除元素

vector.clear(); //移除容器的所有数据
vec.erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
vec.erase(pos); //删除pos位置的数据，返回下一个数据的位置。

5、vector插入元素

  iterator insert( iterator loc, val );       //在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器
  void insert( iterator loc, num, val );  //在指定位置loc前插入num个值为val的元素
  void insert( iterator loc, input_iterator start, input_iterator end ); //在指定位置loc前插入区间[start, end)的所有元素

6、unique

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        return unique(nums.begin(), nums.end())!=nums.end();
    }
};

二、与字符串相关的

7、字符串的常用函数

数字转字符串：to_string 字符串转数字stoi

8、

9、string 类有多个构造函数，用法示例如下：

string(nums[i], i+'0')

10、string的erase函数

11、find

IP.find('.') != string::npos

等价于IP.find('.') != -1

12、string. find_first_of string. find_last_of

（1）size_type find_first_of( const basic_string& str, size_type pos = 0 ) const;

寻找等于给定字符序列中字符之一的首个字符。搜索只考虑区间 [pos, size()) 。若区间中不存在字符，则返回-1 。

（2）size_type find_last_of( const basic_string& str, size_type pos = npos ) const;

寻找等于给定字符序列中字符之一的最后字符。搜索只考虑区间 [0, pos] 。若区间中不存在这种字符，则返回-1。

class Solution {
public:
    string reverseVowels(string s) {
        int i=0, j=s.size()-1;
        while(i<j){
            i=s.find_first_of("aeiouAEIOU", i);
            j=s.find_last_of("aeiouAEIOU", j);
            if(i<j) swap(s[i++], s[j--]);
        }
        return s;
    }
};

三、与字符串流相关的

13、stringstream

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        map<char, int> m1;
        map<string, int> m2;
        stringstream ss(str);
        string temp;
        for(int i=0; i<pattern.size(); ++i){
            ss>>temp;
            if(m1[pattern[i]]!=m2[temp])
                return false;
            m1[pattern[i]]=m2[temp]=i+1;
        }
        return !(ss>>temp);
    }
};

14、istringstream，ostringstream 449题

class Codec {
private:
    void serialize(TreeNode *root, ostringstream &out){
        if(root){
            out<<root->val<<' ';
            serialize(root->left, out);
            serialize(root->right, out);
        }
        else{
            out<<"# ";
        }
    }
 
    TreeNode * deserialize(istringstream &in){
        string temp;
        in>>temp;
        if(temp=="#")   return nullptr;
        TreeNode *root=new TreeNode(stoi(temp));
        root->left=deserialize(in);
        root->right=deserialize(in);
        return root;
    }
    
public:
    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        ostringstream out;
        serialize(root, out);
        return out.str();
    }
 
    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        istringstream in(data);
        return deserialize(in);
    }
};

15、getline

getline()的原型：

头文件：#include <string>
istream& getline ( istream &is , string &str , char delim );
其中，istream &is 表示一个输入流，譬如cin；
string&str表示把从输入流读入的字符串存放在这个字符串中
char delim表示定界符，在不设置的情况下系统默认该字符为'\n'，也就是回车换行符（遇到回车停止读入）。

class Solution {
public:
    string validIPAddress(string IP) {
        istringstream is(IP);
        if (IP.find('.') != string::npos){//IPv4
        //if (IP.find('.') != -1){作用一样的
            string s;
            int cnt1 = 0;
            while (getline(is, s, '.')){
                cnt1++;
                for (int i = 0; i<s.size(); ++i){
                    if (i>2 || !(s[i] >= '0'&& s[i] <= '9')) return "Neither";
                }
                if (cnt1>4 || s.empty() || stoi(s)>255 || s.size()>1 && s[0] == '0' ) return "Neither";
            }
            if(cnt1==4 && IP.back() != '.') return "IPv4";
        }
        else{
            istringstream is(IP);
            string s;
            int cnt2 = 0;
            while (getline(is, s, ':')){
                cnt2++;
                for (int i = 0; i<s.size(); ++i){
                    if (i>3 || !(s[i] >= '0'&& s[i] <= '9' || s[i] >= 'a' && s[i] <= 'f' || s[i] >= 'A' && s[i] <= 'F')) return "Neither";
                }
                if (cnt2>8 || s.empty()) return "Neither";
            }
            if(cnt2==8 && IP.back() != ':') return  "IPv6";
        }
        return "Neither";
    }
};

四、其他

16、自定义结构体的格式

//定义双向链表
struct DListNode{
    int key, val;
    DListNode *pre, *rear;
    DListNode(int x, int y):key(x), val(y), pre(nullptr), rear(nullptr){}
};

17、hypot(a,b)的返回值为double类型，相当于sqrt(a*a+b*b) 447题

hypot英文单词本身表示计算一直角三角形的斜边长度。

18、移位、按位与、按位或运算

class Solution {
public:
    vector<string> findRepeatedDnaSequences(string s) {
        vector<string> re;
        unordered_map<int, int>m;
        int i=0, t=0;
        while(i<9){
            t=(t<<3) | (s[i++] &7);
        }
        for(int i=9; i<s.size(); ++i){
            t= (t & 0x7ffffff)<<3 | (s[i] &7);//取出后27位，左移三位，加上当前字符的后三位
            m[t]++;
            if(m[t]==2){
                re.push_back(s.substr(i-9, 10));
            }
        }
        return re;
    }
};

19、优先队列的定义：

priority_queue<int>q; //通过操作，按照元素从大到小的顺序出队

priority_queue<int, vector<int>, greater<int> >q; //通过操作，按照元素从小到大的顺序出队

eg：priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> >q;