• 个人简介

    0101直播 密码是0101+(当年日期)。

    荒野头像随便拿。 拿走记得发站内消息跟我吱一声。 这里有很多头像

    image image

    image

    一些游戏。

    https://www.crazygames.com/

    宝玩

    https://cpsgames.org/!

    国际象棋

    超级猫里奥

    植物大战僵尸网页版

    狗狗刺杀

    å∫ç∂´ƒ©˙ˆ∆˚¬µ˜øπœ®ß†¨√∑≈¥Ω 输出26个字母同时按住option键

    (一)定义 栈(Stack)是一种遵循后进先出(Last - In - First - Out,LIFO)原则的线性数据结构。 (二)关键术语 栈顶(Top):栈中可进行插入和删除操作的一端,最新元素所在位置。 栈底(Bottom):栈中固定的一端,最早进入栈的元素所在位置。 入栈(Push):向栈顶添加元素的操作。 出栈(Pop):移除栈顶元素的操作。 栈溢出(Stack Overflow):当栈已满还进行入栈操作时发生的错误。 栈下溢(Stack Underflow):当栈为空还进行出栈操作时发生的错误。 (三)栈的实现 数组实现:

    1. 实现思路 使用数组来存储栈中的元素,通过一个变量 top 记录栈顶的位置。数组大小在创建栈时确定,当 top 达到数组最大下标时栈满,top 为 -1 时栈空。
    2. 代码示例
    #include <iostream>
    using namespace std;
    const int MAX_SIZE = 100;
    class ArrayStack {
    private:
        int arr[MAX_SIZE];
        int top;
    public:
        // 构造函数,初始化栈顶位置
        ArrayStack() : top(-1) {}
    
        // 判断栈是否为空
        bool isEmpty() const {
            return top == -1;
        }
    
        // 判断栈是否已满
        bool isFull() const {
            return top == MAX_SIZE - 1;
        }
    
        // 入栈操作
        void push(int value) {
            if (isFull()) {
                cout << "Stack Overflow!" << endl;
                return;
            }
            arr[++top] = value;
        }
    
        // 出栈操作
        int pop() {
            if (isEmpty()) {
                cout << "Stack Underflow!" << endl;
                return -1;
            }
            return arr[top--];
        }
    
        // 查看栈顶元素
        int peek() const {
            if (isEmpty()) {
                cout << "Stack is empty!" << endl;
                return -1;
            }
            return arr[top];
        }
    };
    
    1. 复杂度分析 入栈(Push):时间复杂度为 O(1),因为只涉及到 top 指针的更新和数组元素的赋值。 出栈(Pop):时间复杂度为 O(1),只需更新 top 指针。 查看栈顶(Peek):时间复杂度为 O(1),直接访问数组元素。空间复杂度:O(n),其中 n是数组的最大容量。 (四)链表实现 1.实现思路 使用链表来存储栈中的元素,链表的头节点作为栈顶。入栈操作相当于在链表头部插入新节点,出栈操作相当于删除链表的头节点。 2.代码示例
    #include <iostream>
    using namespace std;
    // 定义链表节点
    struct Node {
        int data;
        Node* next;
        Node(int value) : data(value), next(nullptr) {}
    };
    
    class LinkedStack {
    private:
        Node* top;
    public:
        // 构造函数,初始化栈顶指针
        LinkedStack() : top(nullptr) {}
    
        // 判断栈是否为空
        bool isEmpty() const {
            return top == nullptr;
        }
    
        // 入栈操作
        void push(int value) {
            Node* newNode = new Node(value);
            newNode->next = top;
            top = newNode;
        }
    
        // 出栈操作
        int pop() {
            if (isEmpty()) {
                cout << "Stack Underflow!" << endl;
                return -1;
            }
            int value = top->data;
            Node* temp = top;
            top = top->next;
            delete temp;
            return value;
        }
    
        // 查看栈顶元素
        int peek() const {
            if (isEmpty()) {
                cout << "Stack is empty!" << endl;
                return -1;
            }
            return top->data;
        }
    
        // 析构函数,释放链表内存
        ~LinkedStack() {
            while (!isEmpty()) {
                pop();
            }
        }
    };
    
    1. 复杂度分析 入栈(Push):时间复杂度为 O(1),主要是创建新节点和更新指针。 出栈(Pop):时间复杂度为 O(1),包含指针更新和节点内存释放。 查看栈顶(Peek):时间复杂度为 O(1),直接访问头节点数据。 空间复杂度:O(n),其中 n 是栈中元素的数量。 (五)、栈的常见操作及使用示例 (1)入栈(Push) // 以数组实现的栈为例
    ArrayStack stack;
    stack.push(10);
    stack.push(20);
    

    (2)出栈(Pop)

    int poppedValue = stack.pop();
    if (poppedValue != -1) {
        cout << "Popped value: " << poppedValue << endl;
    }
    

    (3)查看栈顶(Peek)

    int topValue = stack.peek();
    if (topValue != -1) {
        cout << "Top value: " << topValue << endl;
    }
    

    (4)判断栈空(IsEmpty)

    if (stack.isEmpty()) {
        cout << "Stack is empty." << endl;
    } else {
        cout << "Stack is not empty." << endl;
    }```
    
    三、set 容器介绍
    (一)基本概念
    set 是一个有序的集合容器,它基于红黑树(一种自平衡的二叉搜索树)实现。元素在 set 中会按照一定的顺序自动排序,默认是升序。
    (二)头文件包含
    要使用 set,需要包含 头文件,示例代码如下:
    #include <set>
    (三)声明和初始化
    以下是一个声明并初始化 set 容器,然后插入元素并遍历的示例:
    
    #include <iostream>
    #include <set>
    using namespace std;
    int main() {
        // 声明一个存储整数的 set
        set<int> mySet;
    
        // 插入元素
        mySet.insert(3);
        mySet.insert(1);
        mySet.insert(2);
    
        // 遍历 set
        for (auto it = mySet.begin(); it != mySet.end(); ++it) {
            cout << *it << " ";
        }
        cout << endl;
    
        return 0;
    }
    (四)输出结果
    上述代码的输出结果为:
    1 2 3
    可以看到,元素会自动按照升序排列。
    四、set 的常见操作
    (一)插入元素
    使用 insert 方法向 set 中插入元素,示例如下:
    
    set<int> mySet;
    mySet.insert(5);
    mySet.insert(10);
    (二)查找元素
    使用 find 方法查找元素,若找到则返回指向该元素的迭代器,若未找到则返回 end() 迭代器,示例如下:
    
    auto it = mySet.find(5);
    if (it != mySet.end()) {
        cout << "Element found!" << endl;
    } else {
        cout << "Element not found!" << endl;
    }
    (三)删除元素
    使用 erase 方法删除元素,示例如下:
    
    mySet.erase(5);
    (四)获取元素数量
    使用 size 方法获取 set 中元素的数量,示例如下:
    
    size_t size = mySet.size();
    五、unordered_set 容器介绍
    (一)基本概念
    unordered_set 是一个无序的集合容器,它基于哈希表实现。元素在 unordered_set 中没有特定的顺序,插入和查找操作的平均时间复杂度为 。
    (二)头文件包含
    要使用 unordered_set,需要包含 <unordered_set> 头文件,示例代码如下:
    
    #include <unordered_set>
    (三)声明和初始化
    以下是一个声明并初始化 unordered_set 容器,然后插入元素并遍历的示例:
    
    #include <iostream>
    #include <unordered_set>
    
    int main() {
        // 声明一个存储整数的 unordered_set
        unordered_set<int> myUnorderedSet;
    
        // 插入元素
        myUnorderedSet.insert(3);
        myUnorderedSet.insert(1);
        myUnorderedSet.insert(2);
    
        // 遍历 unordered_set
        for (auto it = myUnorderedSet.begin(); it != myUnorderedSet.end(); ++it) {
            cout << *it << " ";
        }
        cout << endl;
    
        return 0;
    }
    (四)输出结果
    元素输出顺序不确定,例如可能是:
    3 1 2
    六、unordered_set 的常见操作
    (一)插入元素
    使用 insert 方法向 unordered_set 中插入元素,示例如下:
    
    unordered_set<int> myUnorderedSet;
    myUnorderedSet.insert(5);
    myUnorderedSet.insert(10);
    (二)查找元素
    使用 find 方法查找元素,若找到则返回指向该元素的迭代器,若未找到则返回 end() 迭代器,示例如下:
    
    auto it = myUnorderedSet.find(5);
    if (it != myUnorderedSet.end()) {
        cout << "Element found!" << endl;
    } else {
        cout << "Element not found!" << endl;
    }
    (三)删除元素
    使用 erase 方法删除元素,示例如下:
    
    myUnorderedSet.erase(5);
    (四)获取元素数量
    使用 size 方法获取 unordered_set 中元素的数量,示例如下:
    
    size_t size = myUnorderedSet.size();
    七、set 和 unordered_set 的性能比较
    205f200699571ff292bff0be89f81adf.png
    性能分析
    set 基于红黑树,插入、查找和删除操作的时间复杂度为
    ?
    (
    ?
    ?
    ?
    ?
    )
    O(logn) ,但元素是有序的。
    unordered_set 基于哈希表,插入、查找和删除操作的平均时间复杂度为
    ?
    (
    1
    )
    O(1) ,但元素是无序的,且在最坏情况下(哈希冲突严重)时间复杂度会退化为 
    ?
    (
    ?
    )
    O(n)。
    八、选择合适的容器
    (一)需要有序元素
    如果需要元素按照一定的顺序存储,例如升序或降序,应该选择 set。
    
    set<int> sortedSet;
    sortedSet.insert(3);
    sortedSet.insert(1);
    sortedSet.insert(2);
    // 元素会自动按升序排列
    (二)对性能要求高
    如果对插入、查找和删除操作的性能要求较高,且不关心元素的顺序,应该选择 unordered_set。
    
    unordered_set<int> fastSet;
    fastSet.insert(3);
    fastSet.insert(1);
    fastSet.insert(2);
    // 插入和查找操作平均时间复杂度为 O(1)
    九、实际案例:去重
    (一)使用 set 去重
    
    #include <iostream>
    #include <set>
    #include <vector>
    
    int main() {
        vector<int> numbers = {1, 2, 2, 3, 3, 3};
        set<int> uniqueNumbers(numbers.begin(), numbers.end());
    
        for (auto num : uniqueNumbers) {
            cout << num << " ";
        }
        cout << endl;
    
        return 0;
    }
    (二)使用 unordered_set 去重
    
    #include <iostream>
    #include <unordered_set>
    #include <vector>
    
    int main() {
        vector<int> numbers = {1, 2, 2, 3, 3, 3};
        unordered_set<int> uniqueNumbers(numbers.begin(), numbers.end());
    
        for (auto num : uniqueNumbers) {
            cout << num << " ";
        }
        cout << endl;
    
        return 0;
    }
    
    高精度加法: 1.读入数据:将两个大整数以字符串形式读入,并且逆序存储到两个整数类型的数组 
    2.初始化结果数组,进位设置为0 
    3.逐位相加:从最低位开始,逐位将两个数相加,并加上前一位的进位,将 和的个位保留,存到结果数组,并且将和的十位保留下来 
    4.处理最高位进位 :如果最后以为相加仍然有进位,结果数组被填满,不需要去除前导 反之,没有产生进位需要去除 
    5.去除前导0 6.输出结果(逆序输出)
    
    #include<bits/stdc++.h>
    using namespace std;
    /*
    memset(void *arr,int val,size_t_size)
    arr 填充内容的起始位置 
    val 设置的值 (0,-1)
    size_t_size 填充的字节数(sizeof(arr))
    
    */	
    int main(){
    	int a[5];
    	memset(a,0,sizeof(a));
    	memset(&a[0],0,sizeof(a));
    	memset(a,0,5*sizeof(int));
    	
    	int arr1[5][5];
    	memset(arr1,0,sizeof(arr1));
    	memset(arr1[0],0,sizeof(arr1));
    	memset(&arr1[0][0],0,sizeof(arr1));
    	memset(arr1,0,25*sizeof(int));
    	
    	int a[5];
    	fill(a, a + 5, 0);
    	fill(&a[0], a + 5, 0);
    	fill(&a[0], &a[5], 1); // 因为是"不到last"
    	fill(&a[0], a + sizeof(a) / sizeof(int), 1);
    	fill(&a[0], a + sizeof(a) / sizeof(a[0]), 1);
    	int a[5][5];
    // fill(a, a + 5 * 5, 0); // 报错,'const int' to 'int [5]'
    // fill(&a, &a + 5 * 5, 0); // 报错,'const int' to 'int [5][5]'
    // fill(&a[0], &a[0] + 5 * 5, 0); // 报错,'const int' to 'int [5]'
    	fill(a[0], a[0] + 5 * 5, 0);
    	fill(&a[0][0], &a[5][5], 0);
    	fill(&a[0][0], &a[0][0] + 5 * 5, 0);
    	fill(&a[0][0], &a[0][0] + sizeof(a) / sizeof(int), 0);
    	
    	return 0;
    }
    
    /*
    // 单个字符
    char c = getchar(); // 输入单个字符
    putchar(c);// 输出单个字符
    islower(c);// 判断c是否为小写字母
    isupper(c);// 判断c是否为大写字母
    isalpha(c);// 判断是否为字母
    isdigit(c);// 判断是否为数字
    、// 字符数组
    '\0' // 字符数组最后一个:ASCII值:0
    char str[];
    cin>>str; // 可以作为一个整体进行cin,cout
    cout<<str;
    str ="sdfa";// 可以直接用字符串赋值
    
    // 字符数组常用处理函数:
    char str[100]; // char *str
    puts(str); // 输出字符串
    gets(str);// 输入一整行字符串(包括空格,已弃用)
    fgets(str,100,stdin) // 将标准输入中长度最多为100的字符串输入到 str
    strcat(str1,str2) // 把str2连接到str1后面
    strcmp(str1,str2) // 比较两个字符串,正数:1大;0:一样大,负数:2大
    strlen(str) // 获取字符串长度(不包括'\0')
    
    // string
    #include<string> // 字符串头文件
    =  可以重新赋值
    += 尾部加入字符串
    
    + 连接字符串
      ==,!=,<,>,<=,>= 字符串的比较
      [] 存取单一字符
      getline(cin,str) // 输入(包括空格,enter键结束)
      str.substr(i,1) // 从i开始截取,截取长度为1的子字符串
      str.find(str2) // 在str字符串中去找到str字符串
      str.rfind(str2) //  str中查找str2,返回所在的下标,没找到返回string::npos
      str.erase(i,1)  // 第i个字符开始往后面去删除
      str.inser(i,str2) // 在个位置 cun
    
    << // 输出
    str.substr(i, l); // 从i开始,截取长度为l的子字符串
    str.find(str2); // 在str中查找str2,返回所在的下标,没找到返回string::npos
    str.rfind(str2); // 同find,但是从右向左找
    str.erase(i, l); // 从i开始,删除长度为l的子字符串
    str.insert(i, str2); // 在i的位置前,插入str2
    str.size(); // 获取str的长度
    str.c_str(); // 获取str对应的char[]
    str.begin(); // 获取str的首地址
    str.end(); // 获取str的尾地址(最后一个元素后面)
    
    */
    
    // 字符数组
    '\0' // 字符数组最后一个:ASCII值:0
    char str[];
    cin>>str; // 可以作为一个整体进行cin,cout
    cout<<str;
    str ="sdfa";// 可以直接用字符串赋值
    
    // 字符数组常用处理函数:
    char str[100]; // char *str
    puts(str); // 输出字符串
    gets(str);// 输入一整行字符串(包括空格,已弃用)
    fgets(str,100,stdin) // 将标准输入中长度最多为100的字符串输入到 str
    strcat(str1,str2) // 把str2连接到str1后面
    strcmp(str1,str2) // 比较两个字符串,正数:1大;0:一样大,负数:2大
    strlen(str) // 获取字符串长度(不包括'\0')
    
    // string
    #include<string> // 字符串头文件
    =  可以重新赋值
    += 尾部加入字符串
    
    + 连接字符串
      ==,!=,<,>,<=,>= 字符串的比较
      [] 存取单一字符
      getline(cin,str) // 输入(包括空格,enter键结束)
      str.substr(i,1) // 从i开始截取,截取长度为1的子字符串
      str.find(str2) // 在str字符串中去找到str字符串
      str.rfind(str2) //  str中查找str2,返回所在的下标,没找到返回string::npos
      str.erase(i,1)  // 第i个字符开始往后面去删除
      str.inser(i,str2) // 在个位置 cun
    
    << // 输出
    str.substr(i, l); // 从i开始,截取长度为l的子字符串
    str.find(str2); // 在str中查找str2,返回所在的下标,没找到返回string::npos
    str.rfind(str2); // 同find,但是从右向左找
    str.erase(i, l); // 从i开始,删除长度为l的子字符串
    str.insert(i, str2); // 在i的位置前,插入str2
    str.size(); // 获取str的长度
    str.c_str(); // 获取str对应的char[]
    str.begin(); // 获取str的首地址
    str.end(); // 获取str的尾地址(最后一个元素后面)
    
    
    内建涵数
    _builtin_ffs(x)返回X中最后一个为1位是从后向前第几位
    (后往前第一个出现1位置)00000010010100 3位置
    __builtin_popcount(x)统计二进制中1的个数
    __builtin_ctz(x)    x末尾0的个数    100100     2个 
    __builtin_clz(x)    x前导0的个数    00001001   4个
    __builtin_parity(x) x中1的奇偶性 1有偶数个返回0,否则返回1
    */
    
    #include
    #include<bitset> 
    using namespace std;
    
    /*
    bitset<N> varm(M) 用于处理进制
    N 代表占的位数 
    varm 代表bitset名
    M变量的初始值 
    bitset头文件:
    #include<bitset> 
    bitset例子:
    bitset<32> b; 
    相关STL函数:
    b.any() 当bitset对象的一位或多个位被设置为1 时any()返回true 
    用途:检测总开关是否全被关闭状态
    b.none() 如果bitset 对象的所有位都被设置为0 ,则none()操作返回true
    用途:检测总开关是否全被关闭状态(出现一个没关false)
    b.count() count()操作返回被设置为1的位的个数.
    b.set() 我们可以用set()操作或者下标操作符来设置某个单独的位
    b.test(位置) 测试某个单独的位是否为1 
    if(b.test(2)) 返回真测试第二位是否为1 
    b.reset(x) 把x位设置为0 
    b.flip()  操作翻转整个bitset 对象或一个独立的位
    b.flip( 0 ); // 翻转第一位  
    b[0].flip(); // 也是翻转第一位  
    b.flip(); // 翻转所有的位的值
    size():返回大小(位数)。
    to_ulong():返回它转换为unsigned long的结果,如果超出范围,则报错。
    to_string():返回它转换为string的结果。
    
    
    */
    bitset<32> b(12); // 000000000000000000000000000000000000001100
    int main(){
    //	string s;
    //	cin>>s;
    //	int len = s.size();
    //	for(int i = 0;i<len-1;i++){
    //		ans+=(s[i]-'0')*pow(2,len-i-1);
    //		cout<<ans<<endl;
    //	}
    	cout<<b<<endl;
    	bool c = b.any();
    	bool k = b.none();
    	cout<<c<<" "<<k<<endl;
    	//偶数位数设为1会变成什么
    	for(int i = 0;i<32;i++){
    		if(i%2==0){
    			b[i]=1;
    		}
    	}
    //	int m = b.count();
    	cout<<b<<endl; 
    	if(b.test(13)){
    		cout<<"第13位是1"; 
    	} else{
    		cout<<"第13位是0";
    	}
    	b.reset(4);
    	cout<<endl<<b<<endl;
    	b.flip(0);
    	b.flip(2);
    	b[6].flip();
    	cout<<"翻转第一位后的结果:";
    	cout<<endl<<b<<endl;
    	cout<<"把整个bitset翻转:"<<endl;
    	b.flip();
    	cout<<endl<<b<<endl;
    	int l = b.to_ulong();
    	cout<<"改变后的进制转成数字"<<l;
     
    	
    }
    
    将字符串转成数字:
    
    1.借用bitset将01字符串变成无符号整数
    
    string a = "1001";
    
    bitset<64> b(string("1001"))
    
    bitset<64> b(a)
    
    cout<<b.to\_ulong()
    
    2.用sscanf() 函数把字符数组里面的字符串打印到数值变量里面
    
    int buf;
    
    sscanf("123456","%d",&buf)
    
    printf("%d\\n",buf)
    
    3.用sprintf()把数据打印到字符数组里面
    
    char s[100]
    
    sprintf(s,"%d",123)
    
    4.用直接的方式
    
    string s = "1234";
    
    int n = 0;
    
    for(int i = 0;i<4;i++){
    
    n = n\*10+s[i]-'0';
    
    }
    
    5.一般用法
    
    char buf[512] = ;
    
    sscanf("123456 ", "%s", buf);
    
    printf("%s\\n", buf);
    
    结果为:123456
    
    1. 取指定长度的字符串。如在下例中,取最大长度为4字节的字符串。
    
    sscanf("123456 ", "%4s", buf);
    
    printf("%s\\n", buf);
    
    结果为:12342. 取到指定字符为止的字符串。如在下例中,取遇到空格为止字符串。
    
    sscanf("123456 abcdedf", "%[^ ]", buf);
    
    printf("%s\\n", buf);
    
    结果为:123456
    
    3. 取仅包含指定字符集的字符串。如在下例中,取仅包含1到9和小写字母的字符串。
    
    sscanf("123456abcdedfBCDEF", "%[1-9a-z]", buf);
    
    printf("%s\\n", buf);
    
    结果为:123456abcdedf
    
    4. 取到指定字符集为止的字符串。如在下例中,取遇到大写字母为止的字符串。
    
    sscanf("123456abcdedfBCDEF", "%[^A-Z]", buf);
    
    printf("%s\\n", buf);
    
    结果为:123456abcdedf
    
    5、给定一个字符串iios/12DDWDFF@122,获取 / 和 @ 之间的字符串,先将 "iios/"过滤掉,再将
    
    非'@'的一串内容送到buf中
    
    sscanf("iios/12DDWDFF@122", "%\*[^/]/%[^@]", buf);
    
    printf("%s\\n", buf);
    
    结果为:12DDWDFF
    
    6、给定一个字符串"hello, world",仅保留"world"。(注意:“,”之后有一空格)
    
    sscanf("hello, world", "%\*s%s", buf);
    
    printf("%s\\n", buf);
    
    结果为:world  P.S. %\*s表示第一个匹配到的%s被过滤掉,即hello,被过滤了,如果没有空格则结果为
    
    NUL
    
    #include<bits/stdc++.h>
    #define f_Getchar() getchar()
    #define f_Putchar(ch) putchar(ch)
    using namespace std;
    
    
    inline int read(){ // 单个字符读入
    	register int x = 0,t=1;
    	register char cj =getchar();
    	while(cj<'0'||cj>'9'){
    		if(cj == '-')t--;
    		cj = getchar();
    	}
    	while(cj>='0'&&cj<='9'){
    	//x =(x<<1)+(x<<3)+(cj^48);
    		x = x*10+cj-'0';
    		cj = getchar();
    	}
    	return x*t;
    }
    inline void write(int x){
    	if(x<0){// 写入
    		putchar('-');
    		x=-x;
    	}
    	if(x>9){
    		write(x/10);
    	}
    	putchar(x%10+'0');
    	putchar('\n');
    	return;
    }
    //string 整行快读读入
    inline void inputL(char* s){
        char ch = f_Getchar() ;
        while(ch == '\n')ch = f_Getchar() ;
        while(ch != '\n')*s = ch,++ s,ch = f_Getchar() ;
        *s = '\0' ;
        return ;
    }
    // 确定字符串长度情况下 
    inline void inputSs(char* s,unsigned long long len){
        char ch = f_Getchar() ;
        while(ch == ' ' || ch == '\n')ch = f_Getchar() ;
        while((len --) && (ch != ' ' && ch != '\n')){
        	*s = ch,++ s,ch = f_Getchar() ;
        	*s = '\0' ;
    	}
        return ;
    }
    // 正常字符串快写 
    inline void outputS(const char* s){
        while(*s)f_Putchar(*s ++) ;
        return ;
    }
    //输出一行字符串
    inline void outputSL(const char* s){
        while(*s && *s != '\n')f_Putchar(*s ++) ;
        return ;
    } 
    int main(){
    //	int m,n;
    //	m = read();
    //	n = read();
    //	write(m);
    //	write(n);
    	char s[100];
    	inputL(s);https://slowroads.io/
    	outputS(s);
    }
    

    什么你竟然刷到这,那我就给你个好玩的网站─=≡Σ(((つ•̀ω•́)つ

    飙车 风叶穿行 4399

    https://www.scratch-cn.cn/

  • 通过的题目

  • 最近活动

题目标签

一本通编程启蒙
267
循环结构
154
小学生C++趣味编程
150
来源
102
分支结构
93
顺序结构
89
基础语法
85
力扣
29
函数
27
数组
21
多重循环
15
字符串
12
数据结构
10
搜索
10
多分支结构
8
排序
7
DFS
7
难度
6
STL
6
结构体
5