leetcode 1670

leetcode 1670

在这里插入图片描述

解题思路

使用2个deque作为类的成员变量

code

class FrontMiddleBackQueue {
public:
    deque<int> left;
    deque<int> right;
    
    FrontMiddleBackQueue() {
    
    }
    
    void pushFront(int val) {
        
        left.push_front(val);
        if(left.size() == right.size()+2){
            right.push_front(left.back());
            left.pop_back();
        }

    }
    
    void pushMiddle(int val) {
        if(left.size() == right.size() + 1){
            right.push_front(left.back());
            left.pop_back();
        }

        left.push_back(val);

    }
    
    void pushBack(int val) {

        right.push_back(val);
        if(left.size() + 1 == right.size()){
            left.push_back(right.front());
            right.pop_front();
        }

    }
    
    int popFront() {
        if(left.empty()){
            return -1;
        }

        int val = left.front();
        left.pop_front();
        if(left.size() + 1 == right.size()){
            left.push_back(right.front());
            right.pop_front();
        }
        return val;

    }
    
    int popMiddle() {
        if(left.empty()){
            return -1;
        }

        int val = left.back();
        left.pop_back();
        if(left.size() + 1 == right.size()){
            left.push_back(right.front());
            right.pop_front();
        }
        return val;

    }
    
    int popBack() {
        if(left.empty()){
            return -1;
        }

        int val = 0;
        if(right.empty()){
            val = left.back();
            left.pop_back();

        }else{
            val = right.back();
            right.pop_back();
            // pop 之后，left 和 right 相差2个元素的情况

            if(left.size() == right.size() + 2){
                right.push_front(left.back());
                left.pop_back();
            }
        }
        return val;

    }
};

/**
 * Your FrontMiddleBackQueue object will be instantiated and called as such:
 * FrontMiddleBackQueue* obj = new FrontMiddleBackQueue();
 * obj->pushFront(val);
 * obj->pushMiddle(val);
 * obj->pushBack(val);
 * int param_4 = obj->popFront();
 * int param_5 = obj->popMiddle();
 * int param_6 = obj->popBack();
 */

c++ 相关

成员变量和局部变量

class FrontMiddleBackQueue {
public:
    deque<int> left;
    deque<int> right;
    
    FrontMiddleBackQueue() {
    
    }
}

和

class FrontMiddleBackQueue {
public:
   
    
    FrontMiddleBackQueue() {
 deque<int> left;
    deque<int> right;
    
    }
}

在第一个示例中，FrontMiddleBackQueue 类包含了两个 deque 类型的成员变量 left 和 right。这意味着每个 FrontMiddleBackQueue 对象都会包含两个 deque 对象作为其成员。

而在第二个示例中，FrontMiddleBackQueue 类的构造函数中定义了两个 deque 对象 left 和 right。这意味着每次创建 FrontMiddleBackQueue 对象时，都会在构造函数中新建两个 deque 对象。

因此，第一个示例中的 left 和 right 是 FrontMiddleBackQueue 类的成员变量，它们在对象的整个生命周期内都存在；而第二个示例中的 left 和 right 是构造函数内的局部变量，它们只在构造函数执行期间存在。

总的来说，第一个示例中的 left 和 right 是 FrontMiddleBackQueue 类的成员变量，而第二个示例中的 left 和 right 只是构造函数内的局部变量。

stl 组成

C++的STL（Standard Template Library）由以下几个组成部分构成：

  1. 容器（Containers）：包括vector、list、deque、set、map等，用于存储和管理数据。
  2. 算法（Algorithms）：包括对容器中的数据进行排序、查找、遍历等操作的算法，如sort、find、for_each等。
  3. 迭代器（Iterators）：用于在容器中进行数据访问和遍历的工具，包括输入迭代器、输出迭代器、正向迭代器、双向迭代器和随机访问迭代器等。
  4. 仿函数（Functors）：也称为函数对象，用于封装可调用对象，可以在算法中作为函数参数使用。
  5. 适配器（Adapters）：包括stack、queue、priority_queue等，用于提供特定接口的容器适配器。

STL的这些组成部分共同构成了一个强大的工具库，可以大大简化C++程序的开发和维护工作，提高程序的性能和可维护性。

c++ 常见的stl容器

C++的STL（Standard Template Library）提供了多种容器，用于存储和管理数据。常见的STL容器包括：

  1. vector（动态数组）
  2. list（双向链表）
  3. deque（双端队列）
  4. set（集合，不重复的有序元素）
  5. map（映射，键值对）
  6. unordered_set（无序集合）
  7. unordered_map（无序映射）
  8. stack（栈）
  9. queue（队列）
  10. priority_queue（优先队列）

除了上述常见的容器外，STL还提供了其他一些容器和适配器，以满足不同的数据存储和访问需求。这些容器提供了不同的性能特点和适用场景，可以根据具体的需求选择合适的容器来存储和管理数据。

c++ 的stl的算法

C++ STL（Standard Template Library）提供了丰富的算法，用于对容器中的数据进行排序、查找、遍历等操作。以下是一些常见的STL算法：

  1. 排序算法：

    • sort：对容器中的元素进行排序
    • stable_sort：稳定排序，保持相等元素的相对顺序
    • partial_sort：部分排序，将容器中的一部分元素排序

  2. 查找和搜索算法：

    • find：在容器中查找指定元素
    • binary_search：二分查找
    • lower_bound：返回第一个大于等于指定值的元素位置
    • upper_bound：返回第一个大于指定值的元素位置
    • equal_range：返回指定值的范围

  3. 数值算法：

    • accumulate：对容器中的元素进行累加
    • inner_product：计算两个容器的内积
    • partial_sum：计算部分和
    • adjacent_difference：计算相邻元素的差值

  4. 遍历算法：

    • for_each：对容器中的每个元素执行指定操作
    • transform：对容器中的元素进行转换操作

  5. 删除和修改算法：

    • remove：删除容器中指定值的元素
    • replace：将容器中指定值的元素替换为新值
    • reverse：反转容器中的元素顺序
    • rotate：旋转容器中的元素顺序

以上只是一部分常见的STL算法，STL还提供了更多强大的算法，可以根据具体需求选择合适的算法来处理容器中的数据。

stl 的迭代器

C++ STL（Standard Template Library）中的迭代器是一种抽象的数据访问方式，用于遍历和访问容器中的元素。迭代器提供了一种统一的访问容器元素的方式，使得算法可以独立于具体容器类型而操作。

迭代器可以看作是指向容器元素的指针，它提供了类似指针的操作，如解引用、递增、递减等。通过迭代器，我们可以遍历容器中的元素，访问和修改元素的值。

STL中的迭代器分为五种类型：

  1. 输入迭代器（Input Iterator）：只能读取容器中的元素，只能单向移动，不支持修改操作。
  2. 输出迭代器（Output Iterator）：只能写入容器中的元素，只能单向移动，不支持读取操作。
  3. 前向迭代器（Forward Iterator）：既可以读取容器中的元素，也可以写入容器中的元素，支持单向移动。
  4. 双向迭代器（Bidirectional Iterator）：具有前向迭代器的所有功能，同时支持逆向移动。
  5. 随机访问迭代器（Random Access Iterator）：具有双向迭代器的所有功能，同时支持随机访问，可以像指针一样进行算术运算。

不同类型的迭代器具有不同的功能和操作特性，我们可以根据需要选择合适的迭代器类型来遍历和操作容器中的元素。

当我们谈到STL的迭代器时，我们通常指的是STL容器的迭代器，它们允许我们遍历容器中的元素。以下是一个简单的例子，展示了如何使用STL容器（例如vector）的迭代器：

#include <iostream>
#include <vector>

int main() {
    // 创建一个整数向量
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用迭代器遍历向量
    std::vector<int>::iterator it;
    for (it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上面的例子中，我们创建了一个整数向量vec，然后使用std::vector<int>::iterator来创建一个迭代器it。我们使用begin()方法获取向量的起始迭代器，使用end()方法获取向量的终止迭代器，然后使用迭代器it遍历向量并输出每个元素的值。

这个例子展示了STL中迭代器的基本用法，它们是遍历容器中元素的重要工具。迭代器提供了一种通用的方式来访问容器中的元素，使得算法可以独立于容器类型进行操作，从而增加了STL的灵活性和通用性。

stl的仿函数

C++ STL中的仿函数（functor）是一种可调用对象，它类似于函数指针，可以被用作函数的参数，或者在算法中作为操作的方式。仿函数可以是普通函数指针、函数对象、成员函数指针等。

在STL中，仿函数通常被用于算法中，比如sort、transform等，以提供一种灵活的方式来指定操作。STL中已经定义了一些常用的仿函数，比如less（小于）、greater（大于）、plus（加法）、minus（减法）等，它们可以直接用于算法中。

此外，程序员也可以自定义仿函数，以满足自己的需求。自定义的仿函数需要满足一定的接口要求，比如重载函数调用运算符 operator()，以便能够像函数一样被调用。

使用仿函数可以使得算法更加灵活，可以自定义操作方式，使得算法可以适用于不同的场景。因此，仿函数是STL中非常重要的一部分，它为算法提供了一种通用的操作方式。

当使用仿函数时，我们可以通过定义一个函数对象来实现自定义的操作。以下是一个简单的例子，演示了如何使用仿函数来自定义排序规则：

#include <iostream>
#include <vector>
#include <algorithm>

// 定义一个自定义的仿函数，用于比较两个整数的绝对值大小
struct CompareAbsolute {
    bool operator()(int a, int b) const {
        return abs(a) < abs(b);
    }
};

int main() {
    std::vector<int> numbers = {3, -1, 4, -1, 5, -9, 2, -6};

    // 使用自定义的仿函数进行排序
    std::sort(numbers.begin(), numbers.end(), CompareAbsolute());

    // 输出排序后的结果
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上面的例子中，我们定义了一个名为CompareAbsolute的仿函数，它重载了函数调用运算符operator()，以实现比较两个整数的绝对值大小的操作。然后，我们在main函数中使用std::sort算法，并传入了自定义的仿函数CompareAbsolute，以实现按照绝对值大小进行排序。最后，我们输出了排序后的结果。

通过这个例子，我们可以看到如何使用自定义的仿函数来实现自定义的操作，从而使得算法更加灵活，适用于不同的需求。

stl的适配器

STL中的适配器（adapter）是一种特殊的容器或迭代器，它们通过改变容器或迭代器的接口，使其适应不同的需求。适配器可以在不改变原有代码的情况下，将容器或迭代器的接口进行转换或扩展，以满足特定的操作要求。

STL中常见的适配器有以下几种：

  1. 容器适配器（Container Adapters）：容器适配器是一种特殊的容器，它基于已有的容器实现，提供了不同的接口。常见的容器适配器有栈（stack）、队列（queue）和优先队列（priority_queue）。这些适配器通过限制或改变容器的操作方式，使其符合栈、队列或优先队列的特性。

以下是一个使用STL中的栈（stack）容器适配器的简单例子：

#include <iostream>
#include <stack>

int main() {
    std::stack<int> myStack;

    // 将元素压入栈
    myStack.push(1);
    myStack.push(2);
    myStack.push(3);

    // 弹出栈顶元素
    std::cout << "Top element: " << myStack.top() << std::endl;
    myStack.pop();

    // 再次查看栈顶元素
    std::cout << "Top element after pop: " << myStack.top() << std::endl;

    // 检查栈是否为空
    if (myStack.empty()) {
        std::cout << "Stack is empty" << std::endl;
    } else {
        std::cout << "Stack is not empty" << std::endl;
    }

    // 获取栈中元素的数量
    std::cout << "Stack size: " << myStack.size() << std::endl;

    return 0;
}

在上面的例子中，我们使用了std::stack容器适配器来创建一个栈。我们通过push方法将元素压入栈，通过top方法获取栈顶元素，通过pop方法弹出栈顶元素，通过empty方法检查栈是否为空，以及通过size方法获取栈中元素的数量。这些操作都是栈特有的操作，而std::stack容器适配器通过限制容器的操作方式，使其符合栈的特性。

  1. 迭代器适配器（Iterator Adapters）：迭代器适配器是一种特殊的迭代器，它通过改变迭代器的行为，提供了不同的迭代方式。常见的迭代器适配器有插入迭代器（insert_iterator）、反向迭代器（reverse_iterator）和流迭代器（stream_iterator）。这些适配器可以在不修改原有容器的情况下，改变迭代器的行为，使其适应不同的需求。

以下是一个使用STL中的反向迭代器（reverse_iterator）的简单例子：

#include <iostream>
#include <vector>
#include <iterator>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用反向迭代器遍历向量
    std::vector<int>::reverse_iterator rit;
    for (rit = vec.rbegin(); rit != vec.rend(); ++rit) {
        std::cout << *rit << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上面的例子中，我们使用了std::vector容器来存储一些整数。然后，我们使用std::vector<int>::reverse_iterator来创建一个反向迭代器，通过rbegin()和rend()方法分别获取向量的反向起始迭代器和反向终止迭代器。然后我们使用反向迭代器rit从向量末尾向向量开头遍历，输出了向量的元素。

反向迭代器允许我们以相反的顺序遍历容器，这在某些情况下非常有用，比如需要逆序遍历一个容器。通过使用反向迭代器，我们可以灵活地改变迭代器的行为，以满足不同的需求。

  1. 函数适配器（Function Adapters）：函数适配器是一种特殊的函数对象，它通过改变函数的行为，提供了不同的操作方式。常见的函数适配器有绑定器（binder）、取反器（negator）和成员函数适配器（mem_fun）。这些适配器可以在不修改原有函数的情况下，改变函数的行为，使其适应不同的需求。

以下是一个使用STL中的函数适配器（function adapter）的简单例子：

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用函数适配器对向量中的元素进行平方操作
    std::transform(vec.begin(), vec.end(), vec.begin(), std::bind2nd(std::multiplies<int>(), 2));

    // 输出平方后的结果
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上面的例子中，我们使用了std::transform算法和std::bind2nd函数适配器来对向量中的元素进行平方操作。std::bind2nd函数适配器将std::multiplies<int>()函数对象和第二个参数绑定在一起，这样就可以将每个元素与2相乘。然后，std::transform算法将结果存储回原始的向量中。

函数适配器允许我们以不同的方式使用函数对象，从而实现更加灵活的功能。在上面的例子中，我们使用了std::bind2nd函数适配器来绑定一个参数，实现了对向量中的元素进行平方操作。这种灵活性使得函数适配器成为STL中非常有用的工具之一。

适配器在STL中起到了非常重要的作用，它们可以使得现有的容器、迭代器或函数更加灵活，适应不同的场景和需求。通过使用适配器，我们可以在不改变原有代码的情况下，扩展或转换容器、迭代器或函数的接口，使其更加符合实际应用的要求。

迭代器和适配器的区别

迭代器（Iterator）和适配器（Adapter）是两个在STL中具有不同功能的概念。

迭代器是一种抽象的概念，它提供了一种通用的方式来遍历容器中的元素。迭代器允许我们以统一的方式访问容器中的元素，而不需要了解容器的具体实现细节。迭代器可以分为输入迭代器、输出迭代器、前向迭代器、双向迭代器和随机访问迭代器，每种类型的迭代器提供了不同的功能和操作。

适配器是一种用于修改或扩展现有功能的工具。适配器将一个接口转换为另一个接口，使得原本不兼容的组件可以一起工作。在STL中，函数适配器是一种常见的适配器，它允许我们修改或扩展函数对象的行为，以满足特定的需求。函数适配器包括绑定器（binder）、成员函数适配器（mem_fun_adapter）和函数指针适配器（ptr_fun_adapter）等。

迭代器和适配器在功能和概念上有一些区别：

  1. 迭代器是用于遍历容器的工具，它提供了一种统一的访问方式。适配器是用于修改或扩展现有功能的工具，它可以修改函数对象的行为或转换接口。
  2. 迭代器是STL的核心概念之一，它在STL中广泛使用。适配器是STL的一个组件，它是对现有功能的扩展和修改。
  3. 迭代器的主要目的是提供一种统一的访问方式，使得算法可以独立于容器类型进行操作。适配器的主要目的是修改或扩展现有功能，以满足特定的需求。

总的来说，迭代器和适配器是STL中两个不同的概念，它们分别用于遍历容器和修改或扩展功能。迭代器提供了一种统一的访问方式，而适配器则用于修改函数对象的行为或转换接口。

stl 函数适配器扩展

函数适配器是一种用于修改或扩展函数对象行为的工具。在STL中，有几种函数适配器，包括绑定器（binder）、成员函数适配器（mem_fun_adapter）和函数指针适配器（ptr_fun_adapter）。以下是这些函数适配器的一些例子：

  1. 绑定器（binder）：
#include <iostream>
#include <functional>

// 定义一个二元函数
int multiply(int a, int b) {
    return a * b;
}

int main() {
    // 使用绑定器将一个参数绑定到函数上
    auto multiplyByTwo = std::bind(multiply, std::placeholders::_1, 2);

    // 调用绑定器函数
    int result = multiplyByTwo(5);
    std::cout << result << std::endl;  // 输出：10

    return 0;
}

在上面的例子中，我们定义了一个二元函数multiply，然后使用std::bind函数创建了一个绑定器multiplyByTwo，将第二个参数绑定为2。最后，我们调用绑定器函数，传入一个参数5，得到结果10。

  1. 成员函数适配器（mem_fun_adapter）：
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

class Person {
public:
    Person(int age) : age(age) {}

    bool isAdult() const {
        return age >= 18;
    }

private:
    int age;
};

int main() {
    std::vector<Person> people = {Person(25), Person(15), Person(30), Person(12)};

    // 使用成员函数适配器判断是否成年
    auto it = std::find_if(people.begin(), people.end(), std::mem_fun_ref(&Person::isAdult));

    if (it != people.end()) {
        std::cout << "Found an adult person." << std::endl;
    } else {
        std::cout << "No adult person found." << std::endl;
    }

    return 0;
}

在上面的例子中，我们定义了一个Person类，其中有一个成员函数isAdult用于判断是否成年。然后，我们创建了一个std::vector<Person>容器，并使用std::find_if算法和std::mem_fun_ref函数适配器来查找第一个成年人。

  1. 函数指针适配器（ptr_fun_adapter）：
#include <iostream>
#include <algorithm>
#include <functional>

// 定义一个谓词函数
bool isEven(int num) {
    return num % 2 == 0;
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用函数指针适配器判断是否为偶数
    auto it = std::find_if(numbers.begin(), numbers.end(), std::ptr_fun(isEven));

    if (it != numbers.end()) {
        std::cout << "Found an even number." << std::endl;
    } else {
        std::cout << "No even number found." << std::endl;
    }

    return 0;
}

在上面的例子中，我们定义了一个谓词函数isEven，用于判断一个数是否为偶数。然后，我们创建了一个std::vector<int>容器，并使用std::find_if算法和std::ptr_fun函数适配器来查找第一个偶数。

以上是函数适配器的一些例子，它们可以修改或扩展函数对象的行为，使得我们可以根据特定的需求来使用它们。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/195405.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

2021年06月 Scratch图形化（四级）真题解析#中国电子学会#全国青少年软件编程等级考试

2021年06月 Scratch图形化（四级）真题解析#中国电子学会#全国青少年软件编程等级考试

Scratch等级考试（1~4级）全部真题・点这里 一、单选题（共10题，每题2分，共20分） 第1题 执行下列程序，输出的结果为？ A：12 B：24 C：8 D：30 答案：B 第2题 执行下列程序，角色说出的内容是？ A：2 B：3 C：4 D：5 答案：A 第3题 执行下列程序，输出结果为？
阅读更多...
C++基础 -6-二维数组，数组指针

C++基础 -6-二维数组，数组指针

二维数组在内存中的存放方式和一维数组完全相同 下表把二维数组抽象成了行列形式方便理解 a[0]指向第一行首元素地址 a指向第一行的首地址 所以a地址和a[0]地址相同,因为起点相同 但a[0]1往右偏移 但a1往下方向偏移 方便理解 an控制行 a[0]n控制列(相当于*an) 数组指针指向二…
阅读更多...
聊聊VMware vSphere

聊聊VMware vSphere

VMware vSphere是一种虚拟化平台和云计算基础设施解决方案&#xff0c;由VMware公司开发。它为企业提供了一种强大的虚拟化和云计算管理平台&#xff0c;能够在数据中心中运行、管理和保护应用程序和数据。vSphere平台与VMware ESXi虚拟化操作系统相结合&#xff0c;提供了完整…
阅读更多...
Linux fork笔试练习题

Linux fork笔试练习题

1.打印结果&#xff1f; #include <stdio.h> #include <unistd.h> #include <stdlib.h>int main() {int i0;for(;i<2;i){fork();printf("A\n");}exit(0); } 结果打印 A A A A A A 2.将上面的打印的\n去掉,结果如何? printf("…
阅读更多...
HarmonyOS 应用模型开发指南介绍

HarmonyOS 应用模型开发指南介绍

一、基本概念解析 新版文档中的知识点&#xff0c;介绍更全面&#xff0c;逻辑更清晰&#xff0c;提供了各类基本概念解析&#xff0c;帮助开发者更快学习、掌握系统能力。以下是新版文档部分概念展示。 1、HAP是什么&#xff1f; 开发者通过DevEco Studio把应用程序编译为一…
阅读更多...
入门级认证 | Salesforce管理员认证最新备考指南！

入门级认证 | Salesforce管理员认证最新备考指南！

Salesforce管理员认证是其他任何管理员认证的基础。通过此考试将展示你对Salesforce功能和最佳实践的了解&#xff0c;使用自定义功能来管理、维护和扩展Salesforce平台。 Admin认证对备考者的要求 Salesforce管理员认证验证了备考者在管理客户和简档、维护数据质量、配置自动…
阅读更多...
C/C++ Zlib实现文件压缩与解压

C/C++ Zlib实现文件压缩与解压

在软件开发和数据处理中&#xff0c;对数据进行高效的压缩和解压缩是一项重要的任务。这不仅有助于减小数据在网络传输和存储中的占用空间&#xff0c;还能提高系统的性能和响应速度。本文将介绍如何使用 zlib 库进行数据的压缩和解压缩&#xff0c;以及如何保存和读取压缩后的…
阅读更多...
2、XFP 与 SFP+：有什么区别？

2、XFP 与 SFP+：有什么区别？

在光纤网络领域&#xff0c;光模块是促进数据顺利传输的重要组件。市场继续接受10G XFP和10G SFP等10G光模块&#xff0c;促使人们对XFP与SFP进行更仔细的审视。他们有什么区别&#xff1f;XFP和SFP的定义是什么&#xff1f;他们的应用场景又如何呢&#xff1f;在下文中寻找所有…
阅读更多...
MySQL用得好好的，为何要转ES?

MySQL用得好好的，为何要转ES?

MySQL是一种关系型数据库&#xff0c;它可以高效地存储和查询结构化的数据。 ES是一种分布式搜索引擎&#xff0c;它可以快速地对海量的非结构化或半结构化的数据进行全文检索和分析。 MySQL 和 ES 的数据存储方式也不同。MySQL 中的数据通常是以关系型表的形式存储在磁盘上&…
阅读更多...
8.0 泛型

8.0 泛型

通过之前的学习&#xff0c;读者可以了解到&#xff0c;把一个对象存入集合后&#xff0c;再次取出该对象时&#xff0c;该对象的编译类型就变成了Object类型&#xff08;尽管其在运行时类型没有改变&#xff09;。集合设计成这样&#xff0c;提高了它的通用性&#xff0c;但是…
阅读更多...
MySQL（免密登录）

MySQL（免密登录）

简介: MySQL免密登录是一种允许用户在没有输入密码的情况下直接登录到MySQL服务器的配置。这通常是通过在登录时跳过密码验证来实现的。 1、修改MySQL的配置文件 使用vi /etc/my.cnf&#xff0c;添加到【mysqld】后面 skip-grant-tables #配置项告诉mysql跳过权限验证&#…
阅读更多...
OpenCV快速入门【完结】：总目录——初窥计算机视觉

OpenCV快速入门【完结】：总目录——初窥计算机视觉

文章目录 前言目录1. OpenCV快速入门&#xff1a;初探2. OpenCV快速入门&#xff1a;像素操作和图像变换3. OpenCV快速入门&#xff1a;绘制图形、图像金字塔和感兴趣区域4. OpenCV快速入门&#xff1a;图像滤波与边缘检测5. OpenCV快速入门&#xff1a;图像形态学操作6. OpenC…
阅读更多...
【计算机组成原理】存储系统

【计算机组成原理】存储系统

&#x1f384;欢迎来到边境矢梦的csdn博文&#x1f384; &#x1f384;本文主要梳理计算机组成原理中 存储系统的知识点和值得注意的地方 &#x1f384; &#x1f308;我是边境矢梦&#xff0c;一个正在为秋招和算法竞赛做准备的学生&#x1f308; &#x1f386;喜欢的朋友可以…
阅读更多...
Docker可视化工具Portainer（轻量）或者Docker容器监控之 CAdvisor+InfluxDB+Granfana（重量）

Docker可视化工具Portainer（轻量）或者Docker容器监控之 CAdvisor+InfluxDB+Granfana（重量）

Docker轻量级可视化工具Portainer 是什么 Portainer 是一款轻量级的应用&#xff0c;它提供了图形化界面&#xff0c;用于方便地管理Docker环境&#xff0c;包括单机环境和集群环境。 安装 官网 https://www.portainer.io/ https://docs.portainer.io/v/ce-2.9/start/instal…
阅读更多...
【密码学】【安全多方计算】浅析隐私求交PSI

【密码学】【安全多方计算】浅析隐私求交PSI

文章目录 隐私求交的定义隐私求交方案介绍1. 基于DH的PSI方案2. 基于OT的PSI方案3.基于OPRF的PSI方案 总结 隐私求交的定义 隐私集合求交使得持有数据参与方通过计算得到集合的交集数据&#xff0c;而不泄露任何交集以外的数据信息。 隐私求交方案介绍 1. 基于DH的PSI方案 …
阅读更多...
如何通过内网穿透实现公网远程ssh连接kali系统

如何通过内网穿透实现公网远程ssh连接kali系统

文章目录 1. 启动kali ssh 服务2. kali 安装cpolar 内网穿透3. 配置kali ssh公网地址4. 远程连接5. 固定连接SSH公网地址6. SSH固定地址连接测试 简单几步通过[cpolar 内网穿透](cpolar官网-安全的内网穿透工具 | 无需公网ip | 远程访问 | 搭建网站)软件实现ssh远程连接kali 1…
阅读更多...
docker安装Sentinel

docker安装Sentinel

文章目录 引言I Sentinel安装1.1 运行容器1.2 DOCKERFILE 参考1.3 pom 依赖1.4 .yml配置（整合springboot）II 资源保护2.1 Feign整合Sentinel2.2 CommonExceptionAdvice：限流异常处理类引言 I Sentinel安装 Sentinel 分为两个部分: 核心库（Java 客户端）不依赖任何框架/库,能…
阅读更多...
了解静态测试？

了解静态测试？

静态测试是一种软件测试方法&#xff0c;它主要通过分析软件或代码的静态属性来检查潜在的问题和缺陷&#xff0c;而无需实际执行程序。这种测试方法侧重于检查源代码和其他软件文档&#xff0c;以发现错误并提高软件质量。 为什么要做静态测试&#xff1f; 提前发现和修复错…
阅读更多...
ESP32-Web-Server编程-CSS 基础 2

ESP32-Web-Server编程-CSS 基础 2

ESP32-Web-Server编程-CSS 基础 2 概述 如上节所述&#xff0c;可以使用外部 CSS 文件来修饰指定的 HTML 文件。 外部引用 - 使用外部 CSS 文件。 当样式需要被应用到很多页面的时候&#xff0c;外部样式表将是理想的选择。使用外部样式表&#xff0c;就可以通过更改一个文件…
阅读更多...
Linux驱动开发笔记（五）：驱动连接用户层与内核层的文件操作集原理和Demo

Linux驱动开发笔记（五）：驱动连接用户层与内核层的文件操作集原理和Demo

若该文为原创文章&#xff0c;转载请注明原文出处 本文章博客地址&#xff1a;https://hpzwl.blog.csdn.net/article/details/134561660 红胖子网络科技博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、OpenCV、OpenGL、ffmpeg、OSG、单片机、软硬…
阅读更多...
最新文章

Copyright @ 2022~2023