数据结构-----二叉搜索树

最新推荐文章于 2024-05-22 19:40:54 发布
最新推荐文章于 2024-05-22 19:40:54 发布
阅读量228 收藏
点赞数
分类专栏： 数据结构 c++ 文章标签： 二叉搜索树 创建 删除 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaronlanni/article/details/79180890
版权

一、基本概念
1、二叉搜索树概念
二叉搜索树：又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树
（1）若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
（2）若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
（3）它的左右子树也分别为二叉搜索树
2、形式
这里写图片描述
二、操作
（一）插入
1、若二叉树为空——>直接插入
2、不为空
（1）找插入结点的位置
（2）插入结点
注：新插入的结点为叶子结点，若插入的结点在树中已经存在，则插入失败
程序算法如下所示：

bool Insert(const K& key, const V& value)
    {
        pNode pCur = _pRoot;
        pNode pParent = NULL;
        pNode pNewNode = new Node(key, value);
        //空树--直接插入
        if (pCur == NULL)
        {
            _pRoot = pNewNode;
            return true;
        }

        //找插入的位置
        while (pCur)
        {
            if (key == pCur->_key)
                return false;
            else if (key < pCur->_key)
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
            else
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
        }
        //插入元素
        if (key < pParent->_key)
            pParent->_pLeft = pNewNode;
        else
            pParent->_pRight = pNewNode;

        return true;
    }

递归实现

bool _Insert1(pNode& pRoot, const K&key, const V&value)
    {
        pNode pNewNode = new Node(key, value);
        if (pRoot == NULL)
        {
            pRoot = pNewNode;
            return true;
        }

        if (pRoot == NULL)
            return false;
        if (pNewNode->_key == pRoot->_key)
            return false;

        if (pRoot->_key > pNewNode->_key)
            _Insert1(pRoot->_pLeft, key, value);

        else
            _Insert1(pRoot->_pRight, key, value);
    }

（二）查找
1、空树—–则此结点不存在
2、非空树
（1）用当前结点与所需比较的结点比较，如果大于，则走右子树，反之，查找成功。
程序算法如下所示

bool Find(const K&key)
    {
        //空树
        if (_pRoot == NULL)
            return false;
        //非空树
        pNode pCur = _pRoot;
        while (pCur)
        {
            if (key == pCur->_key)
                return true;
            else if (key > pCur->_key)
                pCur = pCur->_pRight;
            else
                pCur = pCur->_pLeft;
        }
        return false;
    }

递归实现

bool _Find1(pNode pRoot, const K&key)
    {
        if (pRoot == NULL)
            return false;       
        if (key == pRoot->_key)
            return true;
        //左子树
        else if (key < pRoot->_pLeft->_key)
            _Find1(pRoot->_pLeft, key);
        //右子树
        else
            _Find1(pRoot->_pRight,key);
    }

（三）获取最小的元素
二叉搜索树是一个有序树，最小的结点位于树中的最左边，因此，直到最左边没有元素，则找到最小的一个结点。
程序算法如下所示：

K LastMost()const
    {
        assert(_pRoot);//判断是否为空树

        pNode pCur = _pRoot;
        while (pCur->_pLeft)
        {
            pCur = pCur->_pLeft;
        }
        return pCur->_key;
    }

（四）获取最大的元素
二叉搜索树是一个有序树，最大的结点位于树中的最右边，因此，直到最右边没有元素，则找到最大的一个结点。
程序算法如下所示：

    K RightMost()const
    {
        assert(_pRoot);//判断是否为空树

        pNode pCur = _pRoot;
        while (pCur->_pRight)
        {
            pCur = pCur->_pRight;
        }
        return pCur->_key;
    }

（五）删除树中的元素
树存在，主要分四种情况，其中，情况一与二或三可以合并在一起
1、删除叶子结点——>直接删
2、待删的结点只有左孩子
3、待删的结点只有右孩子
4、待删的结点左右孩子均有
这里写图片描述
这里写图片描述
这里写图片描述
删除情况具体如上面所示，根据上面的情况，便可完成所有的情况，具体代码如下所示：

void Pop(const K&key)
    {
        //空树
        if (_pRoot == NULL)
            return;
        //非空树
        pNode pDel = _pRoot;
        pNode pDParent = NULL;
        //找待删除的结点
        while (pDel)
        {
            if (key == pDel->_key)
                break;
            else if (key > pDel->_key)
            {
                pDParent = pDel;
                pDel = pDel->_pRight;
            }
            else
            {
                pDParent = pDel;
                pDel = pDel->_pLeft;
            }
        }
        //删除的结点不在树中
        if (pDel == NULL)
        {
            return;
        }

        //删除结点
        //只有左孩子，此种情况包含两个孩子都没有
        if (NULL == pDel->_pRight)
        {
            //判断待删结点是否为根节点
            if (pDel == _pRoot)//左单支
            {
                _pRoot = pDel->_pLeft;

            }
            else
            {
                //待删结点在双亲结点的左孩子上
                if (pDParent->_pLeft == pDel)
                {
                    pDParent->_pLeft = pDel->_pLeft;

                }
                //待删结点在双亲结点的右孩子上
                else
                {
                    pDParent->_pRight = pDel->_pLeft;

                }
            }
        }

        //只有右孩子，此种情况包含两个孩子都没有
        else if (NULL == pDel->_pLeft)
        {
            if (pDel == _pRoot)//右单支
            {
                _pRoot = pDel->_pRight;

            }
            else
            {
                if (pDParent->_pLeft == pDel)
                {
                    pDParent->_pLeft = pDel->_pRight;

                }
                else
                {
                    pDParent->_pRight = pDel->_pRight;

                }
            }
        }
        //两个孩子都有
        else
        {
            //找替代结点，在右子树中，找待删除结点的中序遍历下的第一个结点,右子树中序遍历下的第一个结点
            pNode pReplaceNode = pDel->_pRight;
            pDParent = pDel;
            //找出替代结点
            while (pReplaceNode->_pLeft)
            {
                pDParent = pReplaceNode;
                pReplaceNode = pReplaceNode->_pLeft;
            }
            //交换待删结点与替代结点,一般的替代结点为只有右子树或者叶子结点
            pDel->_key = pReplaceNode->_key;
            pDel->_value = pReplaceNode->_value;
            pDel = pReplaceNode;
            //删除结点

            if (pDParent->_pLeft == pDel)
            {
                pDParent->_pLeft = pDel->_pRight;
            }
            else
            {
                pDParent->_pRight = pDel->_pRight;
            }
        }
        delete pDel;
    }

二叉搜索树最大的特点就是，其中序遍历的结果是一个有序的结果。

对于二叉搜索树，有关的操作就是在上面了，希望大家一起进步！！
所有的代码如下所示：

#pragma once
#include<iostream>
using namespace std;
#include<assert.h>
template<class K,class V>
struct BSTreeNode
{
    BSTreeNode(const K& key, const V& value)
    :_pLeft(NULL)
    , _pRight(NULL)
    , _key(key)
    , _value(value)
    {}
    BSTreeNode<K, V>* _pLeft;
    BSTreeNode<K, V>* _pRight;
    K _key;
    V _value;
};
template<class K,class V>
class BSTree
{
    typedef BSTreeNode<K, V> Node;
    typedef BSTreeNode<K, V>* pNode;
public:
    BSTree()
        :_pRoot(NULL)
    {}
    bool Insert(const K& key, const V& value)
    {
        pNode pCur = _pRoot;
        pNode pParent = NULL;
        pNode pNewNode = new Node(key, value);
        //空树--直接插入
        if (pCur == NULL)
        {
            _pRoot = pNewNode;
            return true;
        }
        //找插入的位置
        while (pCur)
        {
            if (key == pCur->_key)
                return false;
            else if (key < pCur->_key)
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
            else
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
        }
        //插入元素
        if (key < pParent->_key)
            pParent->_pLeft = pNewNode;
        else
            pParent->_pRight = pNewNode;
        return true;
    }
    //递归
    void Insert1(const K& key, const V& value)
    {
        _Insert1(_pRoot, key, value);
    }
    //查找某一个元素
    bool Find(const K&key)
    {
        //空树
        if (_pRoot == NULL)
            return false;
        //非空树
        pNode pCur = _pRoot;
        while (pCur)
        {
            if (key == pCur->_key)
                return true;
            else if (key > pCur->_key)
                pCur = pCur->_pRight;
            else
                pCur = pCur->_pLeft;
        }
        return false;
    }
    //递归
    bool Find1(const K&key)
    {
        //空树
        if (_pRoot == NULL)
            return true;
        //非空树
        _Find1(_pRoot, key);
    }
    //获取最小的元素,一直往其左边走
    K LastMost()const
    {
        assert(_pRoot);//判断是否为空树
        pNode pCur = _pRoot;
        while (pCur->_pLeft)
        {
            pCur = pCur->_pLeft;
        }
        return pCur->_key;
    }

    //获取最大的元素
    K RightMost()const
    {
        assert(_pRoot);//判断是否为空树

        pNode pCur = _pRoot;
        while (pCur->_pRight)
        {
            pCur = pCur->_pRight;
        }
        return pCur->_key;
    }

    void Pop(const K&key)
    {
        //空树
        if (_pRoot == NULL)
            return;
        //非空树
        pNode pDel = _pRoot;
        pNode pDParent = NULL;
        //找待删除的结点
        while (pDel)
        {
            if (key == pDel->_key)
                break;
            else if (key > pDel->_key)
            {
                pDParent = pDel;
                pDel = pDel->_pRight;
            }
            else
            {
                pDParent = pDel;
                pDel = pDel->_pLeft;
            }
        }
        //删除的结点不在树中
        if (pDel == NULL)
            return;
        //删除结点
        //只有左孩子，此种情况包含两个孩子都没有
        if (NULL == pDel->_pRight)
        {
            //判断待删结点是否为根节点
            if (pDel == _pRoot)//左单支
            {
                _pRoot = pDel->_pLeft;              
            }
            else
            {
                //待删结点在双亲结点的左孩子上
                if (pDParent->_pLeft == pDel)
                {
                    pDParent->_pLeft = pDel->_pLeft;                    
                }
                //待删结点在双亲结点的右孩子上
                else
                {
                    pDParent->_pRight = pDel->_pLeft;           
                }
            }
        }
        //只有右孩子，此种情况包含两个孩子都没有
        else if (NULL == pDel->_pLeft)
        {
            if (pDel == _pRoot)//右单支
            {
                _pRoot = pDel->_pRight;

            }
            else
            {
                if (pDParent->_pLeft == pDel)
                {
                    pDParent->_pLeft = pDel->_pRight;               
                }
                else
                {
                    pDParent->_pRight = pDel->_pRight;                  
                }
            }
        }
        //两个孩子都有
        else
        {
            //找替代结点，在右子树中，找待删除结点的中序遍历下的第一个结点,右子树中序遍历下的第一个结点
            pNode pReplaceNode = pDel->_pRight;
            pDParent = pDel;
            //找出替代结点
            while (pReplaceNode->_pLeft)
            {
                pDParent = pReplaceNode;
                pReplaceNode = pReplaceNode->_pLeft;
            }
            //交换待删结点与替代结点,一般的替代结点为只有右子树或者叶子结点
            pDel->_key = pReplaceNode->_key;
            pDel->_value = pReplaceNode->_value;
            pDel = pReplaceNode;
            //删除结点

            if (pDParent->_pLeft == pDel)
            {
                pDParent->_pLeft = pDel->_pRight;
            }
            else
            {
                pDParent->_pRight = pDel->_pRight;
            }
        }
        delete pDel;
    }
    void InOrder()
    {
        cout << "InOrder:" << endl;
        _InOrder(_pRoot);
    }
    //递归
private:
    bool _Find1(pNode pRoot, const K&key)
    {
        if (pRoot == NULL)
            return false;       
        if (key == pRoot->_key)
            return true;
        //左子树
        else if (key < pRoot->_pLeft->_key)
            _Find1(pRoot->_pLeft, key);
        //右子树
        else
            _Find1(pRoot->_pRight,key);
    }

    bool _Insert1(pNode& pRoot, const K&key, const V&value)
    {
        pNode pNewNode = new Node(key, value);
        if (pRoot == NULL)
        {
            pRoot = pNewNode;
            return true;
        }

        if (pRoot == NULL)
            return false;
        if (pNewNode->_key == pRoot->_key)
            return false;

        if (pRoot->_key > pNewNode->_key)
            _Insert1(pRoot->_pLeft, key, value);

        else
            _Insert1(pRoot->_pRight, key, value);
    }
private:
    void _InOrder(pNode pRoot)
    {
        if (pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout << "<" << pRoot->_key << "," << pRoot->_value << ">" << endl;;
            _InOrder(pRoot->_pRight);
        }

    }

主要测试代码如下所示：

#define _CRT_SECURE_NO_WARNINGS 1
#include"BinarySearchTree.hpp"

int main()
{
    int a[] = { 5, 7, 2, 1, 9, 4, 8, 3, 6, 0 };
    BSTree<int,int> bst1;
    for (int i = 0; i < sizeof(a) / sizeof(*a); ++i)
    {
        bst1.Insert(a[i], a[i]);

    }
    bst1.InOrder();

    for (int i = 0; i < sizeof(a) / sizeof(*a); ++i)
    {
        bst1.Insert1(a[i], a[i]);

    }
    bst1.InOrder();
    if (bst1.Find(10))
        cout << "存在" << endl;
    else
        cout << "不存在" << endl;

    if (bst1.Find(5))
        cout << "存在" << endl;
    else
        cout << "不存在" << endl;

    if (bst1.Find1(10))
        cout << "存在" << endl;
    else
        cout << "不存在" << endl;

    if (bst1.Find1(5))
        cout << "存在" << endl;
    else
        cout << "不存在" << endl;

    cout << bst1.LastMost() << " ";//最小
    cout << bst1.RightMost();//最大
    //删除根结点
    bst1.Pop(5);
    bst1.InOrder();
    //删除结点只有右子树
    bst1.Pop(7);
    bst1.InOrder();
    //删除叶子结点
    bst1.Pop(0);
    bst1.InOrder();
    //删除结点只有左子树
    bst1.Pop(4);
    bst1.InOrder();
    //待删结点的左右孩子均存在
    bst1.Pop(2);
    bst1.InOrder();
    //删除结点不存在
    bst1.Pop(2);
    bst1.InOrder();
    //bst1.Pop(9);
    //bst1.InOrder();
    //bst1.Pop(2);
    //bst1.InOrder();
    //bst1.Pop(3);
    //bst1.InOrder();
    //bst1.Pop(6);
    //bst1.InOrder();
    //bst1.Pop(1);
    //bst1.InOrder();
    空树
    //bst1.Pop(2);
    //bst1.InOrder();
    //判断空树的情况
    //BSTree<int, int> bst2;
    //cout << bst2.LastMost() << " ";//最小
    //cout << bst2.RightMost();//最大
    system("pause");
    return 0;
}

只有不停的奔跑，才能不停留在原地。

梦奕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 --二叉搜索树
sdjn_lyn的博客
02-26 966
二叉搜索树 二叉搜索树定义 二叉搜索树也称为二叉查找树、二叉排序树，是一种插入、删除、查找操作性能都不错的数据结构 二叉搜索树首先还是一棵二叉树，但是这个二叉树有一些特点：对于树中的每个结点， 如果左子树存在，那么左子树中所有结点的值都小于该结点的值 如果右子树存在，那么右子树中所有结点的值都大于该结点的值 树中没有值相等的结点 下图就是一棵二叉搜索树，可见满足上述二叉搜索树的特点 二叉搜索...
数据结构-二叉搜索树
m0_61433144的博客
08-07 1697
二叉搜索树也称二叉排序树或者二叉查找树，它是在普通二叉树上加入一些特性所形成的： 1，若左子树非空，则左子树上所有结点的值均小于根结点的值。 2，若右子树非空，则右子树上所有结点的值均大于根结点的值。 3，其左右子树也分别是一棵二叉搜索树。......
数据结构--二叉搜索树
最新发布
weixin_66905164的博客
05-22 2234
二叉搜索树的概念；二叉树的实现；结点类；函数接口总览；实现二叉树；二叉搜索树的应用；K模型；KV模型；二叉搜索树的性能分析
数据结构-----二叉排序树
热门推荐
m0_73633088的博客
10-01 1万+
今天我们继续学习新的知识点----排序二叉树，在此之前我们学习了相关的排序算法，给你一个数组，然后对这个数组进行排序。那么同样的我们也可以去构建一个二叉排序树，在创建树的过程中进行排序，也能实现排序的效果，下面就一起来看看吧！二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。给定一个二叉树，如果满足以下条件，那就是二叉排序树。
数据结构-二叉搜索树 详解
HeartFireY的博客
06-06 2337
一、二叉搜索树 简介 二叉搜索树(BST, Binary Search Tree)是一种基于二叉树的树形数据结构，定义(满足的性质)如下 空树是二叉搜索树 若二叉搜索树的左子树不为空，则其左子树上所有点的权值均小于其根节点的权值； 若二叉搜索树的右子树不为空，则其右子树上所有点的权值均大于其根节点的权值； 二叉搜索树的左右子树均为二叉搜索树 不难发现，二叉搜索树是采用递归进行定
数据结构题目-二叉排序树
weixin_61133168的博客
12-06 1510
题目描述给定一个序列，使用该序列生成二叉排序树（也叫二叉搜索树，BST），然后以本题规定方法输出该二叉排序树。 例： 给定一个序列：43 25 29 67 17 88 54 47 35 62 以第一个数字（43）为根节点，然后将后面的数字依输入次序逐个添加至该树中，得到一个二叉排序树，如下图所示。 然后先序遍历上面这个树，并按行输出数字。 其中每个子节点的输出前，需要相较于其父节点前多四个普通空格。 当某个节点为叶子节点（即无子节点），则该节点的左右叶子节点均不用输出。 而当某个节点仅有左叶子节点或右叶子节
数据结构--二叉搜索树的实现
qq_63440853的博客
12-29 1007
介绍了二叉搜索树的概念以及插入，删除，遍历和其应用的场景，与key/value的应用与代码
数据结构 Java数据结构 --- 二叉搜索树
wwzzzzzzzzzzzzz的博客
02-25 580
二叉搜索树 1. 二叉搜索树的概念 二叉搜索树又称二叉排序树，它或者是一棵空树**，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 2. 二叉树操作 - 查找 代码实现: public Node search(int val){ while (root != null){ if(val > root.val){// va
算法与数据结构--二叉搜索树与自平衡二叉搜索树
bjjx123456的博客
12-25 707
二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。根据插入元素的落点，调整策略分为四种情况，插入元素落入以下4个子树的情况分别对应着四种状态。注：字典的 "member运算" 指的是检查字典中是否存在某个特定的键的操作，即查询操作。A连接左子树的右子树，A称为B的右子树。注：上图的沿路径回溯检查指的是沿插入路径回溯检查。这时候对根结点使用左旋操作。
数据结构 --- c语言二叉搜索树(有序的树)
weixin_60569662的博客
02-27 2622
二叉搜索树基础 左边孩子节点的值 < 父节点的值，右边孩子节点的值 > 父节点的值 每个二叉搜索树的子树也是一棵二叉搜索树 10 充当根节点 18 > 根节点，放在根节点右边；3 < 根节点，放在根节点左边；8 首先与根节点相比较，8 < 根节点，所以应该放在根节点的左边；然后 8 与 3 比较，3 < 8，8 应该放在 3 的右边，持续构建即可 二叉搜索树的特性：中序遍历是一个有序序列，从小到大排序，2-3-4-7-.
基于C语言的数据结构-二叉搜索树bitTree
06-25
二叉搜索树（Binary Search Tree，BST），也称为二叉排序树，是计算机科学中用于组织数据的一种数据结构。在二叉搜索树中，每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用以及一个指向右子节点的...
计算机基础-数据结构与算法.pdf
10-07
AVL树是一种自平衡二叉搜索树，通过引入平衡因子（左右子树的高度差）来确保树的平衡，使得搜索效率保持在O(logn)。而红黑树则是一种保持“黑平衡”的二叉搜索树，它通过红黑颜色规则来简化平衡调整，同样保证了搜索...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
二分搜索树-二叉查找树 .docx
03-13
二分搜索树，又称二叉查找树或有序二叉树，是一种特殊类型的二叉树，其每个节点都遵循以下规则： 1. 节点的左子树仅包含键值小于该节点的节点。 2. 节点的右子树仅包含键值大于该节点的节点。 3. 左右子树同样也是...
二叉树面试题之二叉树的遍历方式
aaronlanni的博客
12-02 3510
一、基本概念 1、二叉树的概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵分别称为左子树和右子树的二叉树组成（即一个根节点最多只有两个孩子结点）。 2、二叉树的特点 （1）每个结点最多有两棵子树，即二叉树不存在度大于2的结点(分支数最大不超过2) （2）二叉树的子树有左右之分，其子树的次序不能颠倒 3、完全二叉树与满二叉树 （1）满二叉树：在一棵二叉树中
查找一个字符串中第一个只出现两次的字符
aaronlanni的博客
02-02 1679
问题描述 查找一个字符串中第一个只出现两次的字符。例如：“abcdefabcdefabc”中第一个只出现两次的为“d”，要求时间复杂度为O(1),空间复杂度为O(1) 解决思路 1、建立一个Hash表，用来存储每一个字符出现的次数，即一个字符的大小：256（无符号类型） 2、对Hash表中的每一个的字符进行初始化 3、存储数组中每个字符出现的次数，将其保存在Hash表中 4、从数组的起
哈希
aaronlanni的博客
03-26 1401
在前面我们已经学到很多在一个结构中查找一个元素，不同的结构的方法不同且实现时的时间复杂度与空间复杂度都有不同，但是但部分的查找都是经过比较，从而找出自己要查找的主要元素。由此我们就想，有没有一种方法不通过比较，从而快速的找到需要的数据，因此，在这里我们就提出了哈希查找，利用存储位置并按照此位置进行存放元素，从而极大的实现了我们的查找效率。下面我们将对哈希查找展开来讲。 目前我们了解到的查找主要有以
【数据结构】数据结构之AVL树
aaronlanni的博客
03-16 1292
一、AVL树的来源 AVL树是一种搜索树，但在搜索效率上，容易形成单支树的情形，因此在查找元素相当于在顺序表中搜索元素，效率低下。
数据结构-结点类型定义与二叉排序树解析
这种结构是二叉搜索树（BST）的标准定义，其中左子树的所有结点的键值小于父结点，右子树的所有结点的键值大于父结点。 数据结构的学习涵盖多个章节，包括但不限于线性结构、树形结构、图、文件结构等，这些章节会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值