🗒️LeetCode常用C++语法

type
status
date
slug
summary
tags
category
icon
password

C++ 常用基础语法

初始化

修饰符

循环遍历

数组

字符与字符串

在C++中,字符通常用char类型表示,而字符串可以用char数组或std::string类来表示。以下是字符和字符串的一些常用操作:
字符(char)的常用操作:
  1. 字符比较
      • 使用关系运算符(==, !=, <, >, <=, >=)比较两个字符。
  1. 字符转换
      • 使用tolowertoupper函数将字符转换为小写或大写。
  1. 字符ASCII值
      • 使用static_cast<int>(ch)获取字符的ASCII值。
 
字符串(char数组和std::string)的常用操作:
对于char数组:
  1. 初始化
      • 使用字符串字面量初始化字符数组,例如char str[] = "Hello";
  1. 字符串长度
      • 使用strlen函数获取字符串的长度。
  1. 字符串连接
      • 使用strcat函数将一个字符串追加到另一个字符串的末尾。
  1. 字符串比较
      • 使用strcmp函数比较两个字符串。
  1. 字符串复制
      • 使用strcpy函数复制一个字符串到另一个字符串。
对于std::string
  1. 初始化
      • 直接使用字符串字面量初始化std::string对象,例如std::string str = "Hello";
  1. 字符串长度
      • 使用lengthsize成员函数获取字符串的长度。
  1. 字符串连接
      • 使用+运算符或append成员函数将一个字符串追加到另一个字符串的末尾。
  1. 字符串比较
      • 使用==, !=, <, >, <=, >=运算符比较两个字符串。
  1. 字符串复制
      • 使用赋值运算符=assign成员函数复制一个字符串。
  1. 子字符串
      • 使用substr成员函数获取字符串的子字符串。
  1. 查找字符或子字符串
      • 使用find成员函数查找字符或子字符串在字符串中的位置。
  1. 替换子字符串
      • 使用replace成员函数替换字符串中的子字符串。
  1. 插入字符或字符串
      • 使用insert成员函数在字符串的指定位置插入字符或子字符串。
  1. 删除子字符串
      • 使用erase成员函数删除字符串中的子字符串。
  1. 字符串流
      • 使用std::stringstream可以将字符串作为流来读取和写入。

其他

C++常用STL及函数

List容器

在C++中,list是一个双向链表容器,它提供了高效的插入和删除操作。以下是list的一些常用操作:
  1. 创建和初始化
    1. 插入元素
      1. 删除元素
        1. 访问元素
          1. 遍历元素
            1. 获取列表大小和检查是否为空
              1. 反转列表
                1. 排序列表
                  1. 合并列表
                    1. 清除列表

                      pair容器

                      std::pair 是 C++ 标准库中的一个非常有用的模板类,用于将两个可能不同类型的值组合成一个单一的对象。以下是 std::pair 的一些常用操作:
                      1. 创建 pair 对象
                        1. 访问 pair 中的元素
                          1. 比较 pair 对象
                          当比较两个 pair 对象时,首先比较它们的 first 元素。如果 first 元素相等,则比较 second 元素。
                          1. 使用 std::tie 解包 pair
                          std::tie 可以用于将 pair 的元素解包到单独的变量中。
                          1. 使用结构化绑定解包 pair (C++17 及以上)
                            1. 输出 pair
                            为了方便地输出 pair,你可以重载 operator<<

                            string和char*相互转换

                            随机数

                            map容器

                            在C++中,map是一个关联容器,它存储的元素是键值对(key-value pairs),其中每个键在map中都是唯一的。以下是map的一些常用操作:
                            1. 插入元素
                              1. 删除元素
                                1. 查找元素
                                  1. 访问元素
                                    1. 遍历元素
                                      1. 获取映射大小和检查是否为空
                                        1. 使用自定义比较函数
                                          1. lower_bound 和 upper_bound
                                            1. equal_range

                                              Set容器

                                              在C++中,set是一个关联容器,它包含一组唯一的对象,并且这些对象会自动按键进行排序。以下是set的一些常用操作:
                                              1. 插入元素
                                                1. 删除元素
                                                  1. 查找元素
                                                    1. 遍历元素
                                                      1. 获取集合大小和检查是否为空
                                                        1. 使用自定义比较函数
                                                          1. lower_bound 和 upper_bound
                                                            1. equal_range

                                                              Vector容器

                                                              C++中的vector是一种动态数组,提供了丰富的操作方法。以下是一些常用的vector操作:
                                                              1. 创建和初始化
                                                                1. 添加元素
                                                                  1. 删除元素
                                                                    1. 访问元素
                                                                      1. 获取大小和容量
                                                                        1. 判断是否为空
                                                                          1. 调整大小
                                                                            1. 预留空间
                                                                              1. 交换两个vector
                                                                                1. 使用迭代器遍历
                                                                                  1. 使用范围for循环遍历

                                                                                    Stack容器

                                                                                    在C++中,栈(Stack)是一种后进先出(LIFO)的数据结构,通常使用std::stack来实现。以下是std::stack的一些常用操作:
                                                                                    1. push(x): 将元素x压入栈顶。
                                                                                      1. pop(): 弹出栈顶元素。注意,此操作不会返回被弹出的元素。
                                                                                        1. top(): 查看栈顶元素,但不移除它。
                                                                                          1. empty(): 检查栈是否为空。
                                                                                            1. size(): 返回栈中的元素数量。
                                                                                              1. swap(other_stack): 与另一个栈交换内容。

                                                                                                队列

                                                                                                在C++中,队列(Queue)是一种先进先出(FIFO)的数据结构,通常使用std::queue来实现。以下是std::queue的一些常用操作:
                                                                                                1. 入队操作:将元素添加到队列的末尾。
                                                                                                  1. 出队操作:移除队列的第一个元素。注意,出队操作不会返回被移除的元素。
                                                                                                    1. front访问:查看队列的第一个元素,但不移除它。
                                                                                                      1. back访问:查看队列的最后一个元素,但不移除它。这个操作在std::queue中是C++98/03标准不支持的,但在C++11及以后的版本中是可用的。
                                                                                                        1. 判断队列是否为空:检查队列中是否有元素。
                                                                                                          1. 获取队列的大小:返回队列中元素的数量。
                                                                                                            1. 交换两个队列:使用std::swap可以交换两个队列的内容。
                                                                                                              队列(queue)常用操作
                                                                                                              1. push(x): 在队列尾部插入元素x。
                                                                                                              1. pop(): 删除队列头部的元素。
                                                                                                              1. front(): 返回队列头部的元素。
                                                                                                              1. back(): 返回队列尾部的元素。
                                                                                                              1. empty(): 检查队列是否为空。
                                                                                                              1. size(): 返回队列中的元素数量。
                                                                                                              双端队列(deque)常用操作
                                                                                                              1. push_front(x): 在双端队列的前端插入元素x。
                                                                                                              1. push_back(x): 在双端队列的后端插入元素x。
                                                                                                              1. pop_front(): 删除双端队列前端的元素。
                                                                                                              1. pop_back(): 删除双端队列后端的元素。
                                                                                                              1. front(): 返回双端队列前端的元素。
                                                                                                              1. back(): 返回双端队列后端的元素。
                                                                                                              1. empty(): 检查双端队列是否为空。
                                                                                                              1. size(): 返回双端队列中的元素数量。
                                                                                                              优先队列(priority_queue)常用操作
                                                                                                              1. push(x): 在优先队列中插入元素x。
                                                                                                              1. pop(): 删除优先队列中最大的元素(默认情况下是最大的,可以通过自定义比较函数改变)。
                                                                                                              1. top(): 返回优先队列中最大的元素。
                                                                                                              1. empty(): 检查优先队列是否为空。
                                                                                                              1. size(): 返回优先队列中的元素数量。
                                                                                                              对于优先队列,如果你想改变排序的方向(例如,从大到小排序),你可以提供一个自定义的比较函数,如std::greater<int>
                                                                                                              这些操作提供了对队列、双端队列和优先队列的基本操作,可以满足大多数使用场景的需求。

                                                                                                               

                                                                                                              常用算法

                                                                                                              C++ 标准库包含了许多高效的通用算法,它们不仅可以应用于迭代器,还可以搭配各种容器使用
                                                                                                              1. std::accumulate: 计算指定范围内元素的累加和,或通过提供自定义的二元操作符实现其它累积操作。
                                                                                                                1. std::find: 在指定范围内查找满足特定条件的第一个元素,并返回指向该元素的迭代器。
                                                                                                                  1. std::count: 计算指定范围内满足特定条件的元素数量。
                                                                                                                    1. std::for_each: 对指定范围内的每个元素执行特定操作。
                                                                                                                      1. std::sort: 对指定范围内的元素进行排序,可提供一个自定义的比较函数以实现定制排序规则。
                                                                                                                        1. std::copy: 将一个范围内的元素复制到另一个范围。
                                                                                                                          1. std::replace: 在指定范围内将所有等于特定值的元素替换为另一个值。
                                                                                                                            1. std::merge: 合并两个有序范围,并将结果存储在第三个范围中。
                                                                                                                              1. std::unique: 移除连续重复的元素,并返回新逻辑末尾的迭代器。配合std::vector::erase可以实现真正的删除操作。
                                                                                                                                1. std::lower_bound: 在有序范围内查找第一个不小于给定值的元素,并返回指向该元素的迭代器。
                                                                                                                                  1. std::upper_bound: 在有序范围内查找第一个大于给定值的元素,并返回指向该元素的迭代器。
                                                                                                                                    1. std::binary_search: 在有序范围内查找特定值,判断是否存在。
                                                                                                                                      1. std::nth_element: 对范围内的元素进行部分排序,使得指定位置的元素位于排序后应在的位置,且该位置左侧的元素都不大于它,右侧的元素都不小于它。
                                                                                                                                        1. std::partial_sort: 对范围内的前n个元素进行排序,使其成为有序序列,而不保证剩余元素的顺序。
                                                                                                                                          1. std::partial_sort_copy: 从源范围选取最小的n个元素,对它们进行排序,并将它们复制到目标范围。
                                                                                                                                            1. std::partition: 根据谓词函数对范围内的元素进行划分,使得满足谓词的元素都位于不满足谓词的元素之前。
                                                                                                                                              1. std::stable_partition: 类似std::partition,但保持等价元素之间的相对顺序不变。
                                                                                                                                                1. std::rotate: 将范围内的元素循环移位,使得特定元素成为范围的第一个元素。
                                                                                                                                                  1. std::next_permutation: 计算给定序列的下一个字典序排列。
                                                                                                                                                    1. std::prev_permutation: 计算给定序列的上一个字典序排列。
                                                                                                                                                      1. std::lexicographical_compare: 按字典序比较两个范围。
                                                                                                                                                        1. std::includes: 检查一个已排序范围是否包含另一个已排序范围的所有元素。
                                                                                                                                                          1. std::set_union: 计算两个已排序范围的并集,并将结果存储在第三个范围中。
                                                                                                                                                            1. std::set_intersection: 计算两个已排序范围的交集,并将结果存储在第三个范围中。
                                                                                                                                                              1. std::set_difference: 计算两个已排序范围的差集(属于第一个范围但不属于第二个范围的元素),并将结果存储在第三个范围中。
                                                                                                                                                                1. std::set_symmetric_difference: 计算两个已排序范围的对称差集(只属于其中一个范围的元素),并将结果存储在第三个范围中。
                                                                                                                                                                   
                                                                                                                                                                   
                                                                                                                                                                   
                                                                                                                                                                   
                                                                                                                                                                   
                                                                                                                                                                  大模型问题随手记OOTDiffusion-AI换装虚拟试穿项目
                                                                                                                                                                  • Twikoo