【STL】模拟实现map和set {带头结点的红黑树；红黑树的核心结构；红黑树的迭代器；红黑树的插入和查找；map和set的封装}

news2024/11/26 16:28:33

模拟实现map和set

  • map和set是红黑树的两种不同封装形式，底层使用同一颗泛型结构的红黑树。
  • set是红黑树的K模型；map是红黑树的KV模型。

下面的代码和讲解着重体现红黑树的底层实现和map\set上层封装的衔接。关于二叉搜索树性质，map和set的介绍，搜索树的旋转，红黑树的性质等内容请依次阅读下面几篇文章：

  1. 【高阶数据结构】二叉搜索树 {概念；实现：核心结构，增删查，默认成员函数；应用：K模型和KV模型；性能分析；相关练习}
  2. 【STL】map和set的介绍和使用 {关联式容器；键值对；map和set；multimap和multiset；OJ练习}
  3. 【高阶数据结构】AVL树 {概念及实现；节点的定义；插入并调整平衡因子；旋转操作：左单旋，右单旋，左右双旋，右左双旋；AVL树的验证及性能分析}
  4. 【高阶数据结构】红黑树 {概念及性质；红黑树节点的定义；红黑树插入操作详细解释；红黑树的验证}

一、红黑树的核心结构

  • 问题一：map和set底层使用同一颗泛型结构的红黑树，如何处理map(pair<key,value>)和set(key)存储值不同的问题？

    解决方案：泛型底层红黑树的存储类型，通过不同的实例化参数，实现出map和set。

1.1 节点的定义

// RBTree.hpp
#pragma once
#include <utility>
#include <assert.h>
using std::pair;
using std::make_pair;

enum Color{
  RED,
  BLACK
};

template <class T>
struct RBTreeNode{
  typedef RBTreeNode<T> Node;
  Node *_left;
  Node *_right;
  Node *_parent;
  T _data; //泛型底层红黑树的存储类型，通过不同的实例化参数，实现出map和set。
  Color _color;
  
  RBTreeNode(const T &data = T(), Color color = RED)
    :_left(nullptr),
    _right(nullptr),
    _parent(nullptr),
    _data(data),
    _color(color)
  {}
};

1.2 红黑树的结构定义

STL中的红黑树结构

  • 为了后续实现关联式容器map/set，STL红黑树的实现中增加一个头结点；
  • 因为根节点必须为黑色，为了与根节点进行区分，将头结点给成红色；
  • 并且让头结点的_parent域指向红黑树的根节点，_left域指向红黑树中最小的节点，_right域指向红黑树中最大的节点。

在这里插入图片描述

头结点的作用(begin, end)：

  • STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？
  • 能否给成nullptr呢？答案是行不通的，因为对end()位置的迭代器进行–操作，必须要能找最后一个元素，此处就不行，因此最好的方式是将end()放在头结点的位置：
// RBTree.hpp
// K: key的类型，
// T: 如果是map，则为pair<K, V>; 如果是set，则为K
// KofT: 通过T类型的data来获取key的一个仿函数类
template <class K, class T, class KofT>
class RBTree{
  typedef RBTreeNode<T> Node; //第二个模版参数T，决定红黑树的存储类型
  Node *_phead; //指向头结点的指针

public:
  typedef RBT_iterator<T, T&, T*> iterator; //普通迭代器
  typedef RBT_iterator<T, const T&, const T*> const_iterator; //const迭代器
  //构造，创建头结点
  RBTree(){
    _phead = new Node(T(), RED); //为了和根节点区分，头节点设为红色
    _phead->_left = _phead->_right = _phead;
  }
    
  //普通对象返回普通迭代器
  iterator begin(){
    return iterator(_phead->_left); //begin放在红黑树最左节点的位置
  }
  iterator end(){
    return iterator(_phead); //end放在头结点的位置
  } 
  //const对象返回const迭代器
  const_iterator begin() const{ 
    return const_iterator(_phead->_left); 
  }
  const_iterator end() const{
    return const_iterator(_phead);
  }
    
  //插入和查找
  pair<iterator, bool> Insert(const T& data);
  iterator Find(const K &k);
    
private:
  //获取根节点，注意返回指针的引用便于修改
  Node*& GetRoot(){
    return _phead->_parent;
  }
  //获取最左节点
  Node* LeftMost(){
    Node *proot = GetRoot();
    if(proot == nullptr)
    {
      return _phead;
    }
    else{
      Node *left = proot;
      while(left->_left != nullptr)
      {
        left = left->_left;
      }
      return left;
    }
  }
  //获取最右节点
  Node* RightMost(){
    Node *proot = GetRoot();
    if(proot == nullptr)
    {
      return _phead;
    }
    else{
      Node *right = proot;
      while(right->_right != nullptr)
      {
        right = right->_right;
      }
      return right;
    }
  }
  //旋转
  void RotateL(Node *parent);
  void RotateR(Node *parent);

二、红黑树的迭代器

2.1 迭代器的基本操作

红黑树的迭代器底层封装一个指向节点的指针，基本操作的详细解释请参照list迭代器的实现。

// RBTree.hpp
template<class T, class Ref, class Ptr>
class RBT_iterator{
  typedef RBT_iterator<T, Ref, Ptr> iterator;
  typedef RBTreeNode<T> Node;
  Node *_pnode; //红黑树的迭代器底层封装一个指向节点的指针

public:
  //基本操作请参照list迭代器的实现，不做过多解释
  RBT_iterator(Node *pnode)
  :_pnode(pnode)
  {}

  Ref operator*() const{ 
    return _pnode->_data;
  }

  Ptr operator->() const{
    return &_pnode->_data;
  }
  
  bool operator==(const iterator &it) const{
    return _pnode == it._pnode;
  }

  bool operator!=(const iterator &it) const{
    return _pnode != it._pnode;
  }
  //......
};

2.2 operator++

红黑树迭代器的实现难点在于++和–操作：

在这里插入图片描述

operator++：（中序：左子树，根，右子树）

  1. 如果当前节点的右子树不为空，++就是找右子树中序的第一个节点（最左节点）。11->12。

  2. 如果当前节点的右子树为空，++就是找孩子不是右节点的那个祖先。7->8。

  3. 特殊情况：根节点没有右孩子，迭代器在根位置（如下图），此时进行++迭代器因该指向头结点end遍历结束。但如果按照上面的逻辑由于根节点恰好是头结点的右孩子（根节点没有右孩子），最终迭代器又会指向根节点永远无法到达头结点end，导致程序陷入死循环。因此需要特殊处理。

在这里插入图片描述

提示：右子树为空或孩子是右节点，说明这棵子树已经遍历访问完了。

  //前置和后置++，后置复用前置
  iterator& operator++(){
    if(_pnode->_right != nullptr) //如果右子树不为空，++就是找右子树的最左节点
    {
      Node *left = _pnode->_right; 
      while(left->_left != nullptr)
      {
        left = left->_left;
      }
      _pnode = left;
    }
    else //如果右子树为空，++就是找孩子不是右节点的那个祖先
    {
      Node *parent = _pnode->_parent;
      while(_pnode == parent->_right)
      {
        _pnode = parent;
        parent = parent->_parent;
      }
      //特殊情况：根节点没有右孩子，迭代器在根位置。
      //经过循环此时_pnode指向头节点，parent指向根节点，做特殊处理使_pnode指向头结点
      if(_pnode->_right != parent)
        _pnode = parent;
    }
    return *this;
  }
  
  iterator operator++(int){
    iterator it(_pnode);
    ++*this;
    return it;
  }

2.3 operator–

在这里插入图片描述

operator–：和++相反（右子树，根，左子树）

  1. 如果当前节点的左子树不为空，–就是找左子树的最右节点。8->7
  2. 如果当前节点的左子树为空，–就是找孩子不是左节点的那个祖先。12->11
  3. 特殊情况：如果迭代器指向end，即头结点。此时进行–操作因该使迭代器指向最右节点。
  4. –操作也存在++操作中的特殊情况——根节点没有左孩子。但不需要做特殊处理，–后仍指向根节点即可。

提示：左子树为空或孩子是左节点，说明这棵子树已经遍历访问完了。

  //前置和后置--，后置复用前置
  iterator operator--(){
    //特殊情况：如果迭代器指向end，进行--操作因该使迭代器指向最右节点。
    if(_pnode->_parent->_parent == _pnode && _pnode->_color == RED)
    {
      _pnode = _pnode->_right;
    }
    else if(_pnode->_left != nullptr) //如果左子树不为空，--就是找左子树的最右节点
    {
      Node *right = _pnode->_left;
      while(right->_right != nullptr)
      {
        right = right->_right;
      }
      _pnode = right;
    }
    else //如果左子树为空，--就是找孩子不是左节点的那个祖先
    {
      Node *parent = _pnode->_parent;
      while(_pnode == parent->_left)
      {
        _pnode = parent;
        parent = parent->_parent;
      }
      _pnode = parent; //不需要特殊处理
    }
    return *this;
  }

  iterator operator--(int){
    iterator it(_pnode);
    --*this;
    return it;
  }

三、红黑树的插入和查找

  • 问题二：在进行查找、插入、删除等操作时，要对key值进行比较。在同一模版中，如何区别比较map和set中的key值？

    解决方案：通过传入仿函数KofT(KeyofTree)解决。如果是set，传入SetKofT返回data的值；如果是map，传入MapKofT返回data.first的值；

    注意：pair中重载了关系运算符，但first和second都参与运算，不符合要求。要求只比较pair.first (key)。

3.1 插入

pair<iterator, bool> Insert(const T& data){
    Node* &rproot = GetRoot(); //这里注意要用引用接收返回值
    if(rproot == nullptr)
    {
      rproot = new Node(data, BLACK); //因为GetRoot返回指针的引用，所以改的实际是_phead->_parent
      rproot->_parent = _phead;
      _phead->_left = _phead->_right = rproot;
      //返回pair<iterator, bool>，方便实现operator[]。
      return make_pair(iterator(rproot), true); 
    }

    KofT kot; //创建KofT对象，用于取出data中的key
    Node *cur = rproot;
    Node *parent = nullptr;
    while(cur != nullptr)
    {
      parent = cur;
      if(kot(data) > kot(cur->_data)) //不管是map还是set都能正确的取出key进行比较。
        cur = cur->_right;
      else if(kot(data) < kot(cur->_data))
        cur = cur->_left;
      else
        return make_pair(iterator(cur), false);
    }

    cur = new Node(data, RED);
    if(kot(data) > kot(parent->_data))
    {
      parent->_right = cur;
    }
    else
    {
      parent->_left = cur;
    }
    cur->_parent = parent;

    Node* newnode = cur; //在调整红黑树的过程中cur的指向会改变，所以要提前记录新节点的指针。
    
    //上一次循环中grandparent 为根节点，此次循环parent == _phead
    //关于红黑树性质的检查和平衡调整请阅读文章：【高阶数据结构】红黑树
    while(parent != _phead && parent->_color == RED)
    {
      Node* grandparent = parent->_parent;
      assert(grandparent!=nullptr);
      assert(grandparent->_color == BLACK);

      Node* uncle = grandparent->_left;
      if(grandparent->_left == parent)
        uncle = grandparent->_right;

      if(uncle != nullptr && uncle->_color == RED)
      {
        parent->_color = uncle->_color = BLACK;
        grandparent->_color = RED;
        cur = grandparent;
        parent = grandparent->_parent;
      }
      else
      {
        if(parent == grandparent->_left)
        {
          if(cur == parent->_left)
          {
            RotateR(grandparent);
            parent->_color = BLACK;
            grandparent->_color = RED;
          }
          else
          {
            RotateL(parent);
            RotateR(grandparent);
            cur->_color = BLACK;
            grandparent->_color = RED;
          }
        }
        else
        {
          if(cur == parent->_right)
          {
            RotateL(grandparent);
            parent->_color = BLACK;
            grandparent->_color = RED;
          }
          else
          {
            RotateR(parent);
            RotateL(grandparent);
            cur->_color = BLACK;
            grandparent->_color = RED;
          }
        }
        break;
      }
    } //end of while
    
	//如果在调整过程中将根节点变为红色，记得重新变回黑色。
    if(parent == _phead)
      cur->_color = BLACK;
    //令头节点的左指针指向红黑树的最左节点
    _phead->_left = LeftMost();
    //令头节点的右指针指向红黑树的最右节点
    _phead->_right = RightMost();
    //返回pair<iterator, bool>，方便实现operator[]。
    return make_pair(iterator(newnode), true);
  }

3.2 旋转

  void RotateL(Node *parent){
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    Node* ppNode = parent->_parent;

    subR->_left = parent;
    parent->_parent = subR;

    parent->_right = subRL;
    if(subRL != nullptr)
      subRL->_parent = parent;

    if(ppNode == _phead) //如果parent是根节点，要修改头结点的_parent指针。
    {
      _phead->_parent = subR;
    }
    else
    {
      if(parent == ppNode->_left)
        ppNode->_left = subR; 
      else
        ppNode->_right = subR;
    }
    subR->_parent = ppNode;
  }
   
  void RotateR(Node *parent){
    Node *subL = parent->_left;
    Node *subLR = subL->_right;
    Node *ppNode = parent->_parent;

    subL->_right = parent;
    parent->_parent = subL;

    parent->_left = subLR;
    if(subLR != nullptr)
      subLR->_parent = parent;

    if(ppNode == _phead) //如果parent是根节点，要修改头结点的_parent指针。
    {
      _phead->_parent = subL;
    }
    else
    {
      if(parent == ppNode->_left)
        ppNode->_left = subL;
      else
        ppNode->_right = subL;
    }
    subL->_parent = ppNode;
  }

3.3 查找

  iterator Find(const K &k)
  {
    KofT kot; //创建KofT对象，用于取出data中的key
    Node *cur = GetRoot();
    if(cur == nullptr) return end(); //如果是空树，返回end。
    while(cur != nullptr)
    {
      if(k > kot(cur->_data)) //不管是map还是set都能正确的取出key进行比较。
        cur = cur->_right;
      else if(k < kot(cur->_data))
        cur = cur->_left;
      else
        return iterator(cur); //找到返回指向节点的迭代器
    }
    return end(); //如果找不到，返回end。
  }

四、map和set的封装

4.1 map

//Map.hpp
#pragma once
#include "RBTree.hpp"

namespace zty{
  template <class K, class V>
  class map{
    //MapKofT返回kv.first
    struct MapKofT{
      const K& operator()(const pair<K,V> &kv){
        return kv.first;
      }
    };
    //map是KV模型的红黑树，存储pair<K,V>键值对
    typedef RBTree<K, pair<K,V>, MapKofT> RBT;
    RBT _rbt;

  public:
    //取类模版中的内嵌类型时，需要在类型前加typename；告诉编译器，后面这一串是类型不是静态成员。
    typedef typename RBT::iterator iterator; //map的迭代器类型
    typedef typename RBT::const_iterator const_iterator; //const迭代器
      
    //C++11的用法：使用了default关键字，表示使用编译器自动生成的默认构造函数
    map() = default;
  	//迭代器区间构造    
    template <class InputIterator>
      map(InputIterator first, InputIterator last){
        while(first!=last)
        {
          _rbt.Insert(*first);
          ++first;
        }
      }

    iterator begin(){
      return _rbt.begin();
    }

    iterator end(){
      return _rbt.end();
    }

    const_iterator begin() const{
      return _rbt.begin();
    }

    const_iterator end() const{
      return _rbt.end();
    }
    
    std::pair<iterator, bool> insert(const pair<K,V> &kv){
      return _rbt.Insert(kv);
    }
      
    //Insert返回pair<iterator, bool>，方便实现operator[]。
    //具体内容阅读文章：【STL】map和set的介绍和使用 
    V& operator[](const K& k){
      pair<iterator, bool> ret = _rbt.Insert(make_pair(k, V()));
      return ret.first->second;
    }

    iterator find(const K& k){
      return _rbt.Find(k);
    }
  };
}

4.2 set

//Set.hpp
#pragma once
#include "RBTree.hpp"

namespace zty{
template <class K>
  class set{
    //SetKofT返回k
    struct SetKofT{
      const K& operator()(const K &k)
      {
        return k;
      }
    };
    //set是K模型的红黑树，只存储key值
    typedef RBTree<K, K, SetKofT> RBT;
    RBT _rbt;

  public:
    //取类模版中的内嵌类型时，需要在类型前加typename；告诉编译器，后面这一串是类型不是静态成员。
    typedef typename RBT::iterator iterator; //set的迭代器类型
    typedef typename RBT::const_iterator const_iterator; //const迭代器
      
	//C++11的用法：使用了default关键字，表示使用编译器自动生成的默认构造函数
    set() = default;
    //迭代器区间构造
    template <class InputIterator>
      set(InputIterator first, InputIterator last){
        while(first!=last)
        {
          _rbt.Insert(*first);
          ++first;
        }
      }

    iterator begin(){
      return _rbt.begin();
    } 

    iterator end(){
      return _rbt.end();
    }

    const_iterator begin() const{
      return _rbt.begin();
    }

    const_iterator end() const{
      return _rbt.end();
    }

    std::pair<iterator, bool> insert(const K& k){
      return _rbt.insert(k);
    }

    iterator find(const K& k){
      return _rbt.Find(k);
    }
  };
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

PowerDesigner 逆向工程

PowerDesigner 逆向工程

1、MySQL数据库连接&#xff08;JDBC方式&#xff09; 1.1 新建一个pdm&#xff0c;dbms选择mysql 1.2 Database - Connect 选择数据库连接 1.3 配置连接信息 数据库连接这里是通过一个配置文件来获取连接信息的&#xff0c;首次的话因为没有&#xff0c;所以我们需要选择…
阅读更多...
采用BeautifulSouppqQueryxpath三种方法爬取电影详情页

采用BeautifulSouppqQueryxpath三种方法爬取电影详情页

采用三个框架BeautifulSoup&&pqQuery&&xpath&#xff0c;爬取知名的电影网页 主要是想体验这三种框架爬同一个网页的不同。 当然具体的不同我也说不清道不明 只能是体验了一把 以下代码都是本人亲自撸 如图所示&#xff0c;四个位置。分别爬取 电影名字 -&g…
阅读更多...
docker 安装 Node-RED

docker 安装 Node-RED

Node-RED 是构建物联网应用程序的一个强大工具&#xff0c;使用可视化编程方法&#xff0c;连接起来执行任务。而homeassistant是家居智慧中枢&#xff0c;本文介绍如何安装Node-RED及HASS的插件 1、拉取镜像 docker pull nodered/node-red # 2、部署镜像 创建目录 mkidr -…
阅读更多...
微调文本到图像扩散模型新方法DreamBooth，实现主题驱动生成（CVPR 2023）

微调文本到图像扩散模型新方法DreamBooth，实现主题驱动生成（CVPR 2023）

来源&#xff1a;投稿 作者&#xff1a;橡皮 编辑&#xff1a;学姐 论文链接&#xff1a; https://arxiv.org/pdf/2208.12242 项目主页&#xff1a;https://dreambooth.github.io/ 图1. 只需要拍摄某个主题&#xff08;左&#xff09;的几张图像&#xff08;通常为 3-5 张&…
阅读更多...
Java守护线程的理解及应用

Java守护线程的理解及应用

在Java中有两类线程&#xff0c;分别是User Thread&#xff08;用户线程&#xff09;和Daemon Thread&#xff08;守护线程&#xff09; 。 用户线程很好理解&#xff0c;我们日常开发中编写的业务逻辑代码&#xff0c;运行起来都是一个个用户线程。而守护线程相对来说则要特别…
阅读更多...
Java发送（QQ）邮箱、验证码发送

Java发送（QQ）邮箱、验证码发送

前言 使用Java应用程序发送 E-mail 十分简单&#xff0c;但是首先需要在项目中导入 JavaMail API 和Java Activation Framework (JAF) 的jar包。 菜鸟教程提供的下载链接&#xff1a; JavaMail mail.jar 1.4.5JAF&#xff08;版本 1.1.1&#xff09; activation.jar 1、准备…
阅读更多...
C语言“牵手”拼多多商品详情数据方法，拼多多商品详情API接口，拼多多API申请指南

C语言“牵手”拼多多商品详情数据方法，拼多多商品详情API接口，拼多多API申请指南

拼多多是中国最大的自营式电商企业&#xff0c;在线销售计算机、手机及其它数码产品、家电、汽车配件、服装与鞋类、奢侈品、家居与家庭用品、化妆品与其它个人护理用品、食品与营养品、书籍与其它媒体产品、母婴用品与玩具、体育与健身器材以及虚拟商品等。 拼多多平台的商品…
阅读更多...
容器编排学习（十）控制器介绍与使用

容器编排学习（十）控制器介绍与使用

一 控制器 控制器是 k8s内置的管理工具。可以帮助用户实现 Pod的自动部署、自维护、扩容、滚动更新等功能的自动化程序。 为什么要使用控制器? 有大量的 Pod需要维护管理需要维护 Pod的健康状态控制器可以像机器人一样可以替用户完成维护管理的工作 二 Deployment 1 概…
阅读更多...
ROS学习笔记(四)---使用 VScode 启动launch文件运行多个节点

ROS学习笔记(四)---使用 VScode 启动launch文件运行多个节点

ROS学习笔记文章目录 01. ROS学习笔记(一)—Linux安装VScode 02. ROS学习笔记(二)—使用 VScode 开发 ROS 的Python程序&#xff08;简例&#xff09; 03. ROS学习笔记(三)—好用的终端Terminator 一、什么是launch文件 虽然说Terminator终端是能够比较方便直观的看运行的节点…
阅读更多...
Spring-MVC的文件上传，下载的技术攻克

Spring-MVC的文件上传，下载的技术攻克

目录 一.前言 二.文件上传 文件上传的步骤&#xff1a; 三.文件下载 四.多文件上传 一.前言 SpringMVC的文件上传下载的主要作用是让用户能够将文件上传到服务器或从服…
阅读更多...
消息队列基本原理和选型对比

消息队列基本原理和选型对比

消息队列使用场景 消息队列中间件是分布式系统中重要的组件&#xff0c;主要解决应用耦合&#xff0c;异步消息&#xff0c;削峰填谷等问题。实现高性能、高可用、可伸缩和最终一致性架构。 解耦&#xff1a;多个服务监听、处理同一条消息&#xff0c;避免多次 rpc 调用。 异步…
阅读更多...
计算机网络基础知识（非常详细）

计算机网络基础知识（非常详细）

1. 网络模型 1.1 OSI 七层参考模型 七层模型&#xff0c;亦称 OSI&#xff08;Open System Interconnection&#xff09;参考模型&#xff0c;即开放式系统互联&#xff0c;是网络通信的标准模型。一般称为 OSI 参考模型或七层模型。 它是一个七层的、抽象的模型体&#xff…
阅读更多...
Web学习笔记-React（组合Components）

Web学习笔记-React（组合Components）

笔记内容转载自 AcWing 的 Web 应用课讲义&#xff0c;课程链接&#xff1a;AcWing Web 应用课。 CONTENTS 1. 创建父组件2. 从上往下传递数据3. 传递子节点4. 从下往上调用函数 本节内容是组件与组件之间的组合&#xff0c;例如用不同组件构成 DOM 树&#xff0c;以及给不同的…
阅读更多...
看完这篇 教你玩转渗透测试靶机Vulnhub——Momentum:2

看完这篇 教你玩转渗透测试靶机Vulnhub——Momentum:2

Vulnhub靶机Momentum:2渗透测试详解 Vulnhub靶机介绍&#xff1a;Vulnhub靶机下载&#xff1a;Vulnhub靶机安装&#xff1a;Vulnhub靶机漏洞详解&#xff1a;①&#xff1a;信息收集&#xff1a;②&#xff1a;漏洞发现&#xff1a;③&#xff1a;文件上传漏洞利用&#xff1a;…
阅读更多...
【C++基础】8. 函数

【C++基础】8. 函数

文章目录 【 1. 函数的定义 】【 2. 函数声明 】【 3. 调用函数 】【 4. 函数参数 】4.1 传值调用4.2 指针调用4.3 引用调用 【 5. 形参默认值 】【 6. lambda函数 】 函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数&#xff0c;即主函数 main() 。可以把代码…
阅读更多...
Fiddler工具使用汇总

Fiddler工具使用汇总

Fiddler工作原理 fiddler作为一个代理服务器&#xff0c;跟浏览器建立连接之后&#xff0c;浏览器像目标服务器发送的请求都会经过fiddler代理&#xff0c;所以fiddler可以捕获到http&#xff08;s&#xff09;请求&#xff0c;从而可以解释、分析、甚至重写发出去的http&…
阅读更多...
[De1CTF 2019]SSRF Me | BUUCTF

[De1CTF 2019]SSRF Me | BUUCTF

根据题目名我们知道这是一道SSRF的题目 它允许攻击者在受害服务器上发起未经授权的网络请求 分析 在buuctf上有一个提示 也就是说flag在 网站的flag.txt 访问主页 很明显是段flask代码 格式化后 from flask import Flask, request # 导入Flask和request模块 import sock…
阅读更多...
设备管理系统的优势是什么？设备管理系统对企业运营管理有什么帮助？

设备管理系统的优势是什么？设备管理系统对企业运营管理有什么帮助？

传统的设备报修维护方式存在一些问题&#xff0c;例如指派传递速度慢和故障信息不准确等。然而&#xff0c;使用设备管理系统就可以轻松地解决这些问题&#xff0c;并且报修全流程只需短短的30秒。设备管理系统具有许多优势&#xff0c;首先它支持多种渠道的报修&#xff0c;包…
阅读更多...
《TCP/IP网络编程》阅读笔记--进程间通信

《TCP/IP网络编程》阅读笔记--进程间通信

目录 1--进程间通信 2--pipe()函数 3--代码实例 3-1--pipe1.c 3-2--pipe2.c 3-3--pipe3.c 3-4--保存信息的回声服务器端 1--进程间通信 为了实现进程间通信&#xff0c;使得两个不同的进程间可以交换数据&#xff0c;操作系统必须提供两个进程可以同时访问的内存空间&am…
阅读更多...
初出茅庐的小李博客之数制与编码知识

初出茅庐的小李博客之数制与编码知识

模拟量与数字量&#xff1a; 数字量和模拟量是两种用于表示和处理不同类型数据的概念&#xff0c;常见于电子和计算机系统中。它们在信号处理、传感器技术、通信和控制系统中有不同的应用。 1. 数字量&#xff08;Digital&#xff09;&#xff1a; 数字量是离散的&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023