C/C++常用刷题技巧，简单易懂

注：本文是浏览B站视频的笔记

1. 自带的宏常量

   int N = INT_MIN;
   int N = INT_MAX;
   const int INF = 0x3f3f3f3f; //通常用来代替最大值，防止运算过程中溢出 0x16进制
   

2. 字符判断函数

   isdigit(c);  //判断字符是否为数字
   isalpha(c);  //判断字符是否为字母
   isalnum(c);  //判断字符是否为数字或者字母
   tolower(c);  //将字符转换为小写 注意并不改变原来的字符c，需要写为char b = toupper(c)
   							//才实现了字符的大写转换
   toupper(c);  //将字符转换为大写；
   

3. 字符串和数值间的转换

   int num = 100;
   string str = to_string(num); //将整数转换为字符串
   int number = stoi(str); //将字符串转换为整数  stol()是将字符串转换为长整型
   

4. 迭代器的二分

   #include <algorithm>
   vector<int> nums{1,2,34,44,99};
   vector<int>::iterator k = lower_bound(nums,begin(), nums.end(), 56); //第一个大于等于目标的迭代器的位置
   int id = k - nums.begin();  //寻找该位置的数组下标
   
   vector<int>::iterator k = upper_bound(nums,begin(), nums.end(), 56); //找到第一个大于目标的迭代器的位置
   

5. 字符串的大小写转换

   /**op作用的范围[str1.begin(), str1.end], 作用完成后，存储位置的开头为：str2.begin()，op为toupper/tolower*/
   transform(str1.begin(), str1.end(), str2.begin(), ::toupper);
   transform(str1.begin(), str1.end(), str2.begin(), ::tolower);
   

6. 小根堆：排序的应用

   priority_queue<int, vector<int>, less<int>> pq;  //默认是大根堆
   priority_queue<int> pq; //大根堆的简写模式
   priority_queue<int, vector<int>, greater<int>> pq;  //小根堆
   

   • 实例演示

     #include <queue>
     int a[] = {1,3,2,4,7,6};
     priority_queue<int, vector<int>, greater<int>> pq;
     for(int i = 0; i < 6; i++)
     {
         pq.push(a[i]);   //向堆中输入元素,注意与vector的push_back的不同书写方法
     }
     
     for(int j = 0; j < 6; j++)
     {
         cout << pq.top() << endl;  //pq.top()代表输出当前优先级最高的数值
         pq.pop();                  //pq.pop()代表删除当前优先级最高的数值，如果没有该操作，那么堆一直输出某一个最大数
     }
     

7. 快速初始化数组

   #include <cstring>   //导入
   int num[5];
   memset(num, 0, sizeof(int)*5);     //统计字节的多少，使用该方法更好
   memset(num, -1, sizeof(int)*5);    //初始化0，-1更好，如果使用1初始化，数组内保存的是16843009(0000 0001)
   memset(num, 0x3f, sizeof(int)*5);  //初始化INT_MAX
   

8. 常用的两个数据结构

   unordered_map<int, int> map;
   unordered_set<int> set;
   

9. 字符串分割:空格分割

   #include <sstream>
   string a = "he he1"
   stringstream ss(a);   //定义了ss的stringstream类,在该构造函数中默认是以空格区分字符串的，也就是说会将输入字符串按空格分						为不同的子字符串，之后输出就实现了空格的分割
   string s;
   while(ss >> s)
   {
       cout << s << endl;
   }
   

   • 字符串流：stringstream对内存的消耗巨大，所以通常会使用以下两种方法进行内存释放。

     stringstream.clear();
     
     stringstream.str("");
     

10. 四舍五入保留小数

    double num = 3.1415;
    string str;
    sprintf(str, "%.2f", num);    //将num保留两位小数后输入str中，之后只需要再将字符串转换为double类型，就完成了小数点后的								精确   
    

11. 相同字符的字符串

    string s(10, 'a');  //生成10个相同的'a'，最终生成的字符串为:"aaaaaaaaaa"
    

12. 字符串按格式拆分

    string a = "12:59:36";
    char str2[100];
    memcpy(str2, a.c_str(), strlen(a.c_str()));  //将字符串转换为字符数组，之后copy到str2中
    int u, v, w;
    sscanf(str2, "%d:%d:%d", &u, &v, &w);       //sscanf是用来解析字符数组的，利用后续的"%d:%d:%d"。之后将格式中的数字单	独提出来即可。
    cout<<u<<" "<<v<<" "<<w<<endl;
    
    

13. 排序：结构体排序和优先队列定义排序，重点在于比较规则的书写

    • 结构体排序

      /**
      在结构体中重载<号,规定比较的规则,之后使用sort函数,即可完成结构体排序
      */
      struct node{
          int a, b;
          // 从小到大排序
          bool operator < (const node& node_)const{
              if(a != node_.a) return a < node_.a;   //比较规则定为先比较第一个数的大小，如果相同，则比较第二个数的大小
              return b < node_.b;
          }
      };
      int main(){
          vector<node> tt;
          tt.push_back({2,3});
          tt.push_back({2,1});
          sort(tt.begin(), tt.end());
          for(auto node: tt){
              cout<<node.a<<" "<<node.b<<endl;
          }
          return 0;
      }
      

    • 优先队列定义排序 与上面相同

      struct node{
          int a, b;
          // 在优先队列中，跟排序的规则是反的，这里是指a大的排在前面，a相同时，b大的排在前面
          bool operator < (const node& node_)const{
              if(a != node_.a) return a < node_.a;
              return b < node_.b;
          }
      };
      int main(){
          priority_queue<node> pq;
          pq.push({1,5});
          pq.push({2,3});
          pq.push({2,5});
          while(!pq.empty()) {
              cout<<pq.top().a<<" "<<pq.top().b<<endl;
              pq.pop();
          }
          return 0;
      }