BinarySearchTree

最新推荐文章于 2024-07-11 22:03:57 发布
最新推荐文章于 2024-07-11 22:03:57 发布
阅读量867 收藏
点赞数
文章标签： c++ visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jxb_8888/article/details/123773412
版权

#include "Box.h"
#include <afxtempl.h>


typedef CTypedPtrList<CObList , CBox*> CBoxList;
typedef CTypedPtrMap <CMapStringToPtr, CString, int*> CRecords;

struct BinarySearchTreeNode{

    CBox * data ;    
    BinarySearchTreeNode *leftChild;    //左子节点, 左框
    BinarySearchTreeNode *rightChild;    //右子节点，右框
    BinarySearchTreeNode *InChild;        //三叉节点，也是中梃节点
    BinarySearchTreeNode *ParentChild;        //前驱节点
    BinarySearchTreeNode(CBox* tempdata)
    {    data            = tempdata;
        leftChild        = NULL;
        rightChild        = NULL;
        InChild            = NULL;        //三叉节点，也是中梃节点
        ParentChild        = NULL;        //前驱节点
    }
};


///
// BinarySearchTree command target

class BinarySearchTree : public CCmdTarget
{
    DECLARE_SERIAL(BinarySearchTree)

    BinarySearchTree();           
    virtual ~BinarySearchTree();

protected:    
    BinarySearchTreeNode * Root;

public:    
    CBoxList* ml;
    CRecords* pRecords;
public:
    BinarySearchTreeNode *GetRoot()    {return this->Root;}
    void SetRoot(BinarySearchTreeNode * p)    {this->Root = p;}
    
    //绘图图形
    void OnDraw (BinarySearchTreeNode * tempRoot , CDC * pDC )
    {
        //这里是绘制一个节点内的框
        GetBoxToNode (tempRoot) ->OnDraw(pDC);
    }

/**********************************************************
    *参数1：当前子树根节点
    *参数2：函数指针
    *参数3：备用指针

    *返回值：空
    *功能：前序遍历二叉查找树
************************************************************/
 void PreOrderBSTPrint(BinarySearchTreeNode * tempRoot , CDC * pDC)
     {        
        if(NULL==tempRoot)    return ;
        
        OnDraw(tempRoot,pDC);
        //如果有中梃, 就绘制它
         if(tempRoot->InChild)
         {
             OnDraw(tempRoot->InChild,pDC);
         }

        PreOrderBSTPrint(tempRoot->leftChild , pDC);
        PreOrderBSTPrint(tempRoot->rightChild , pDC);    
     }


BOOL InsertBST(BinarySearchTreeNode * tempRoot , CPoint  tempPt , UINT iType)
    {
            BinarySearchTreeNode* p  =  NULL;
            SeletedToNode(tempRoot ,tempPt , &p);

            if (p)
            {
                CreateToNode(p , tempPt ,iType);
                return TRUE ;
            }
            else    return FALSE;
    }


void SetIsSeleted(BinarySearchTreeNode *tempRoot  , CPoint  pt)
{

//在这里要清除所有选中状态
    UnsetSeleted(tempRoot);

    BinarySearchTreeNode* p  = NULL;
    SeletedToNode(tempRoot , pt , &p);

    if(p)
    {    
        CBox* m = GetBoxToNode(p);                                
        m->SetSeleced();        
    }

}

void SeletedToNode(BinarySearchTreeNode *tempRoot, CPoint  pt , BinarySearchTreeNode **p)
{
    if(NULL==tempRoot)    return ;

    CBox * p0 = GetBoxToNode(tempRoot) ;                
    CRect rtmp0 = p0->GetBox() ;    

    if( rtmp0.PtInRect(pt) && !tempRoot->leftChild && !tempRoot->rightChild)
    {        
            *p = tempRoot;    
            return ;
    }

    
    if(tempRoot->InChild)
    {

        CBox * p2 = GetBoxToNode(tempRoot->InChild) ;                
        CRect rtmp2 = p2->GetBox() ;
        
        if( rtmp2.PtInRect(pt))
        {        
            *p = tempRoot->InChild;    
            return ;
        }
    }

    if(tempRoot->leftChild)
        SeletedToNode(tempRoot->leftChild, pt ,    p);

    if(tempRoot->rightChild)
        SeletedToNode(tempRoot->rightChild , pt, p);

}


void UpDataToSet(BinarySearchTreeNode *tempRoot, set<int>& x , set<int>& y)
{
    if(NULL==tempRoot)    return ;    


    //如果是根节点
    if( tempRoot == Root)
    {
        //先清除set
        x.clear();    

        y.clear();
        
    
        
        //把左和右插入set
        CBox * p0 = GetBoxToNode(tempRoot) ;
        CRect rtmp0 = p0->GetBox() ;        
        
        x.insert((int)rtmp0.left);
        x.insert((int)rtmp0.right);

        y.insert((int)rtmp0.top);
        y.insert((int)rtmp0.bottom);


    }
    else
    {
        if(tempRoot->InChild )
        {
                    
                CBox * p2 = GetBoxToNode(tempRoot->InChild) ;
                UINT i = p2->GetToType();

                if(i == 2)
                {                    
                    CRect rtmp2 = p2->GetBox() ;
                    CPoint pt2 = rtmp2.CenterPoint();
                    
                    x.insert((int)pt2.x);        
                    
                }

                if(i == 12)
                {                    
                    CRect rtmp12 = p2->GetBox() ;
                    CPoint pt12 = rtmp12.CenterPoint();
                    
                    y.insert((int)pt12.y);        
                    
                }

        }
    }
    

    
    if(tempRoot->leftChild)
        UpDataToSet(tempRoot->leftChild, x , y);
    
    if(tempRoot->rightChild)
        UpDataToSet(tempRoot->rightChild , x , y);
    
}


    
//创建一个节点
BOOL CreateToNode(BinarySearchTreeNode *temp  , CPoint  pt , UINT iType)
{
    if(NULL==temp)
        return FALSE;
    else
    {
    //1. 把父节点传进来
    //2. 创建三个节点 分别为父节点的三个子节点
    //3. 把指针都连接起来

        int v = 10;
            if(pRecords)
            {        
                int *mx= NULL ;    
                pRecords->Lookup("中梃小面", mx);
                v= *mx ;

            }


        

            CBox* m0 = GetBoxToNode(temp);
            CRect p0 = m0->GetBox();//为父框
        if(2 == iType)
        {        
        

        
            CRect* p1 = new CRect(p0.left,p0.top,pt.x-v/2,p0.bottom);
            CBox*  m1 = new CBox(p1);
            BinarySearchTreeNode* n1 = new BinarySearchTreeNode (m1);    
            temp->leftChild = n1;
            n1->ParentChild = temp ;
            
            CRect* p2 = new CRect(pt.x-v/2,p0.top,pt.x+v/2,p0.bottom);
            CBox*  m2 = new CBox(p2);
            m2->SetToType(iType);
            BinarySearchTreeNode* n2 = new BinarySearchTreeNode (m2);    
            temp->InChild = n2;
            n2->ParentChild = temp ;

            CRect* p3 = new CRect(pt.x+v/2,p0.top,p0.right,p0.bottom);
            CBox*  m3 = new CBox(p3);
            BinarySearchTreeNode* n3 = new BinarySearchTreeNode (m3);    
            temp->rightChild = n3;
            n3->ParentChild = temp ;
        }

        if(12 == iType)
        {            
            //CBox* m0 = GetBoxToNode(temp);
            //CRect p0 = m0->GetBox();//为父框
                    
            
            CRect* p1 = new CRect(p0.left,p0.top,p0.right , pt.y-v/2);
            CBox*  m1 = new CBox(p1);            
            BinarySearchTreeNode* n1 = new BinarySearchTreeNode (m1);    
            temp->leftChild = n1;
            n1->ParentChild = temp ;
            
            CRect* p2 = new CRect(p0.left,pt.y-v/2,p0.right,pt.y+v/2);
            CBox*  m2 = new CBox(p2);
            m2->SetToType(iType);
            BinarySearchTreeNode* n2 = new BinarySearchTreeNode (m2);    
            temp->InChild = n2;
            n2->ParentChild = temp ;
            
            CRect* p3 = new CRect(p0.left,pt.y+v/2,p0.right,p0.bottom);
            CBox*  m3 = new CBox(p3);
            BinarySearchTreeNode* n3 = new BinarySearchTreeNode (m3);    
            temp->rightChild = n3;
            n3->ParentChild = temp ;
        }
    m0->SetToType(0);

    }

    

    return TRUE ;

}

/**********************************************************
*功能：取得一个RECT
*参数：节点
*返回值：RECT
************************************************************/
CRect* GetRectToNode(BinarySearchTreeNode *p )
{
    if(p)
    {        
        CBox * pb = (CBox *)p->data ;        
        return & pb->GetBox() ;    
    }
    else return NULL;    
}


 void MoveToNode(BinarySearchTreeNode *tempRoot , int value)
 {
     if(tempRoot)
     {            
             //开始操作中梃节点
             CBox* b0 = GetBoxToNode(tempRoot);
             CRect r0 = b0->GetBox();
             
                UINT s = b0->GetToType() ;

                if (2 == s)
                {
                    r0.left        += value;
                    r0.right    += value;
                    b0->SetBox(r0);//为父框                
                }
                
                
                if (12 == s)
                {
                    r0.top        += value;
                    r0.bottom    += value;
                    b0->SetBox(r0);//为父框
                        
                }
                        //4. 更新所有节点的左节点的数据和右节点的数据
                    PreOrderBST(Root, 4);    
         }    
 }

void DeletedToNode(BinarySearchTreeNode *tempRoot)
{
    if(tempRoot)
    {    
            CBox* i = NULL ;
            CBox* l = NULL ;
            CBox* r = NULL;
            

            //这是左右节点都无子节情况删除
            if(!tempRoot->ParentChild->leftChild->InChild && !tempRoot->ParentChild->rightChild->InChild)
            {
                i = GetBoxToNode(tempRoot->ParentChild->InChild);
                l = GetBoxToNode(tempRoot->ParentChild->leftChild);
                r = GetBoxToNode(tempRoot->ParentChild->rightChild);
                
                tempRoot->ParentChild->InChild = NULL;
                tempRoot->ParentChild->leftChild = NULL;
                tempRoot->ParentChild->rightChild = NULL;
                
                delete i ;
                delete l ;
                delete r ;                
                
            }

    }
    
    
    
}

void OperateToNode(BinarySearchTreeNode *tempRoot , CPoint tempPt , int ModifyNum , int operNum)
{
    if(tempRoot)
    {    
        //1. 先取得选中的节点        
        BinarySearchTreeNode* p  = NULL ;
        SeletedToNode(tempRoot ,tempPt , &p);            
        
        
        //是否是中梃节点
        if(p && p != Root && p != Root->leftChild  )
        {
            //如果选中的是左节点或右节点直接返回
            if (p == p->ParentChild->leftChild || p == p->ParentChild->rightChild )
            {
                //设置框状态
                if(5 == operNum)
                {
                    CBox* pA =GetBoxToNode (p);
                    pA->SetToType(5);
                }

                //设置框状态
                if(6 == operNum)
                {
                    CBox* pB =GetBoxToNode (p);
                    pB->SetToType(6);
                }

                //设置框状态
                if(7 == operNum)
                {
                    CBox* pC =GetBoxToNode (p);
                    pC->SetToType(7);
                }
                

                return;    
            }    
            
            //修改
            if(75 == operNum)
            MoveToNode (p->ParentChild->InChild , ModifyNum);

            //删除
            if(76 == operNum)
            DeletedToNode (p->ParentChild->InChild );

        
    
        }
        
    }
    
}


void UpdateLR(BinarySearchTreeNode* tempRoot)
{
    if (tempRoot != Root)
    {
        if(tempRoot && tempRoot->InChild && tempRoot->leftChild && tempRoot->rightChild)
        {
                //取得父节点框
                CBox* b0 = GetBoxToNode(tempRoot);
                CRect r0 = b0->GetBox();
                
                //取得中梃节点框
                CBox* b2 = GetBoxToNode(tempRoot->InChild);
                CRect r2 = b2->GetBox();
                UINT s = b2 ->GetToType();

                if(2 ==s)
                {                //取得左框
                    CBox* b1 = GetBoxToNode(tempRoot->leftChild);
                    CRect r1 = b1->GetBox();                        
                    r1.top = r0.top;
                    r1.bottom = r0.bottom;

                    r1.left = r0.left;
                    r1.right = r2.left;
                    //把修改好的RECT再写回去
                    b1->SetBox(r1);//为父框
                
                    
                    CBox* b2 = GetBoxToNode(tempRoot->InChild);
                    CRect r2 = b2->GetBox();
                    
                    r2.top =    r0.top;
                    r2.bottom = r0.bottom;
                    //把修改好的RECT再写回去
                    b2->SetBox(r2);//为父框

                    
                    //取得右框//
                    CBox* b3 = GetBoxToNode(tempRoot->rightChild);
                    CRect r3 = b3->GetBox();                
                    r3.top = r0.top;
                    r3.bottom = r0.bottom;

                    r3.left = r2.right;
                    r3.right =r0.right;
                    //把修改好的RECT再写回去
                    b3->SetBox(r3);//为父框    

                }

                if(12 ==s)
                {                //取得左框
                    CBox* b1 = GetBoxToNode(tempRoot->leftChild);
                    CRect r1 = b1->GetBox();
                    //r1.NormalizeRect();    
                    r1.left = r0.left;
                    r1.right = r0.right;

                    r1.top = r0.top;
                    r1.bottom = r2.top;
                    //把修改好的RECT再写回去
                    b1->SetBox(r1);//为父框


                    //取得右框//
                    CBox* b2 = GetBoxToNode(tempRoot->InChild);
                    CRect r2 = b2->GetBox();
                    
                    r2.left = r0.left;
                    r2.right = r0.right;
                    
                    //r2.top = r0.bottom;
                    //r2.bottom =r0.bottom;
                    //把修改好的RECT再写回去
                    b2->SetBox(r2);//为父框    
                
                    
                    //取得右框//
                    CBox* b3 = GetBoxToNode(tempRoot->rightChild);
                    CRect r3 = b3->GetBox();
                    
                    r3.left = r0.left;
                    r3.right = r0.right;

                    r3.top = r2.bottom;
                    r3.bottom =r0.bottom;
                    //把修改好的RECT再写回去
                    b3->SetBox(r3);//为父框    
                    
                }
            
            }
    }

}


CBox* GetBoxToNode(BinarySearchTreeNode *p )
{
    if(p)
    {        
        CBox * pb = (CBox *)p->data ;        
        return pb ;    
    }
    else return NULL;    
}

void UnsetSeleted(BinarySearchTreeNode *tempRoot)
{

    if(NULL==tempRoot)
        return ;

    //清除本体选中状态
    BinarySearchTreeNode* p  = tempRoot;    
    CBox* m = GetBoxToNode(p);
    m->UnSeleced();    
    
    //清除中梃选中状态
    if(p->InChild)
    {
        CBox* n = GetBoxToNode(p->InChild);            
        n->UnSeleced();
    }

    UnsetSeleted(tempRoot->leftChild );
     UnsetSeleted(tempRoot->rightChild);

}

  void BSTSerialize(BinarySearchTreeNode *tempRoot)
  {
      //Serialize(CArchive& ar) 
      
      if(NULL==tempRoot)
          return ;
  
    
    if(tempRoot)
    {
        CBox* p1 = GetBoxToNode(tempRoot);
        
        ml->AddTail(p1);
        
        
        if(tempRoot->InChild)
        {
            CBox* p1 = GetBoxToNode(tempRoot->InChild);            
            ml->AddTail(p1);
        }
    }
      
      BSTSerialize(tempRoot->leftChild  );
      BSTSerialize(tempRoot->rightChild );
      
  }


//**********************************************************
void PreOrderBST(BinarySearchTreeNode* tempRoot, int i)
{
    if(NULL==tempRoot)
        return ;
    //查询i值，再执行对应的分支函数
    switch (i)
    {
        case 0: Test(tempRoot);break;
        case 1:break;
        case 2:break;
        case 3:break;
        case 4: UpdateLR(tempRoot);break;


        //case 100: BSTSerialize(tempRoot);
        default: break;
    }
    PreOrderBST(tempRoot->leftChild,   i);
    PreOrderBST(tempRoot->rightChild,  i);
}

/
.cpp


IMPLEMENT_SERIAL(BinarySearchTree, CCmdTarget,1)

BinarySearchTree::BinarySearchTree()
{
    EnableAutomation();
    Root=NULL;
}

jxb_8888
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++BinarySearchTree
qq_57558831的博客
03-02 120
#include<iostream> #include<string.h> #include<string> using namespace std; class Data { public: Data() = default; Data(int key, string val):key(key),val(val){} void PrintData() { cout << this->key << " " << .
C++二叉搜索树BinarySearchTree
学习C++的小陈同学
11-03 128
本章介绍了搜索二叉树的特性，并且用C++模拟实现，详细分析了代码思路
数据结构之搜索二叉树（BinarySearchTree）
Tlzns的博客
10-30 182
数据结构之搜索二叉树（BinarySearchTree）
数据结构与算法(九)-二叉搜索树(BinarySearchTree)
热门推荐
老男孩的博客
01-13 1万+
二叉搜索树(BinarySearchTree) 一、对二叉搜索树的介绍 二叉搜索树（BST，Binary Search Tree），也称为二叉排序树和二叉查找树 1. 二叉搜索树的特性 非空左子树的所有键值小于其根节点的键值。比如：下图三，中节点 6 的所有非空左子树的键值都小于 6 非空右子树的所有键值大于其根节点的键值；比如：下图三，中节点 6 的所有非空右子树的键值都大于 6； 左、右子树本身也都是二叉搜索树 图二和图三符合二叉搜索树的特效，所以属于二叉树 图一中的节点5要比节点7大，不符合
初始C++
2302_81016149的博客
07-08 776
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
python-torch加载c++与内核函数
weixin_40777649的博客
07-11 286
python 在线加载.cu 文件python 加载.cu 文件方式2二、实现python 在线加载.cu 文件python 加载c++ 方法采用的是torch.utils.cpp_extension包的扩展方法。直接加载cu文件，则采用torch.utils.cpp_extension.load() 方法。"fused",sources=[],具体： fused_bias_act.cpp//scalar_t y;
C++ 多态
wxk2227814847的博客
07-10 619
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
C++|智能指针
最新发布
weixin_68201503的博客
07-11 576
1.每个shared_ptr对象，其都包含着一个指针，该指针所指向空间内容用来计数有多少个指针指向该空间，即有多少个对象管理同一份资源，当多个对象管理同一份资源，那么他们的指针就会指向同一份空间，空间内容记录着这些数量，每增加一个对象管理相同资源，则计数也会加1。那么weak_ptr是怎样解决问题的了，其实很简单，weak_ptr不在对引用计数进行管理了，所以shared_ptr对象初始化时的引用计数都是为1，在进行析构的时候，引用计数都会减到0，然后释放对应的_ptr,_pcount。
C语言-动态内存管理
m0_73605503的博客
07-07 1148
在C语言编程中，动态内存管理是一个至关重要的概念。它不仅涉及到程序如何高效地使用内存资源，还影响到程序的稳定性和性能。通过动态分配内存，程序可以根据运行时的需求灵活地调整内存使用，这对于处理不确定的数据量和实现高效的资源利用尤为重要。在这篇文章中，我们将深入探讨C语言中的动态内存管理机制，了解如何使用标准库函数如 malloc、calloc、realloc 和 free，并讨论一些常见的内存管理陷阱和最佳实践。
C++ 入门08：运算符重载
LF__plus的博客
07-11 574
在前面的文章学习中，我们学习了类和对象的基础知识以及构造函数、拷贝构造函数、静态成员和常量成员。今天，我们将深入学习运算符重载。运算符重载是 C++ 的一大特色，它使得我们可以对类对象使用类似于基本数据类型的运算符，从而使代码更加简洁和易读。
C++初探究（2）
Frenemy__的博客
07-09 1281
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
初识C++
2301_80662872的博客
07-11 375
现在有一个项目分配给两个人让他们实现。他们写的都没问题但是它们一合并就出现了命名冲突的问题。在C++里就可以避免此问题的发生。C++提出了命名空间这是对标识符的名称进行本地化，以避免命名冲突。定义命名空间需要用到namespace关键字，后面接命名空间的名字，然后接一对{}即可。int a = 1;int b = 2;命名空间里面不止可以定义变量也可以定义函数和类型，注意一个命名空间就定义了一个新的作用域，命名空间里的所有内容只限于该命名空间中。
解释 C 语言中的函数重载机制（注意：C 语言不支持函数重载）？
技术笔记
07-11 279
虽然 C 语言不支持函数重载这一直接的特性，但通过合理地设计函数名、利用预处理器或使用函数指针和结构体等方法，我们仍然可以在一定程度上实现类似的功能，以满足不同参数类型的操作需求。然而，这些方法相较于真正的函数重载，在代码的简洁性和可读性上可能存在一定的不足。在实际编程中，选择哪种方法取决于具体的应用场景和编程需求。如果对函数重载有强烈的需求，可能考虑使用支持该特性的编程语言，如 C++。但对于一些简单的 C 语言项目，通过上述的模拟方法也能够有效地处理不同类型参数的函数调用问题。🎉相关推荐。
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 997
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
【C语言】经典C语言笔试面试题目
Young_Pro的博客
07-08 1534
本文收集了笔试面试中最高频且最常考的45道经典C语言题目
[c++] 可变参数模版
l23456789mmmmm的博客
07-07 515
可变参数模板是C++11及之后才开始使用,学校的老古董编译器不一定能用相信大家在刚入门c/c++时都接触过printf函数printf用于将数据格式化输出到屏幕上,它的参数非常有意思,可以支持任意数量,任意类型的多参数.而如果我们想实现类似这种的传参,在C里似乎并不支持c++11提出了可变模板参数来解决这一问题。
java 实现一个BinarySearchTree delete 方法
04-03
以下是Java实现BinarySearchTree的delete方法的示例代码： ``` public class BinarySearchTree { private Node root; private class Node { private int key; private Node left, right; public Node(int key) { this.key = key; } } public void delete(int key) { root = delete(root, key); } private Node delete(Node x, int key) { if (x == null) return null; if (key < x.key) { x.left = delete(x.left, key); } else if (key > x.key) { x.right = delete(x.right, key); } else { if (x.left == null) return x.right; if (x.right == null) return x.left; Node t = x; x = min(t.right); x.right = deleteMin(t.right); x.left = t.left; } return x; } private Node min(Node x) { if (x.left == null) return x; return min(x.left); } private Node deleteMin(Node x) { if (x.left == null) return x.right; x.left = deleteMin(x.left); return x; } } ``` 在该实现中，delete方法首先调用delete(Node x, int key)方法，传入根节点和待删除的键。 delete(Node x, int key)方法递归遍历二叉搜索树，查找要删除的键所对应的节点。如果找到了该节点，就执行删除操作。如果节点有左右子树，就用它的右子树中的最小值节点来替代这个节点，然后删除右子树中的最小值节点。 delete(Node x, int key)方法还调用了min(Node x)和deleteMin(Node x)方法。min(Node x)方法返回以节点x为根的子树中的最小节点，deleteMin(Node x)方法删除以节点x为根的子树中的最小节点，并返回删除后的子树。 注意：以上代码仅供参考，未经完整测试，可能存在错误，请谨慎使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值