【C++篇】红黑树封装 实现map和set

ops/2025/1/22 9:38:52/

目录

前言：

一，库中map和set的大致结构

二，模拟实现

2.1，大致框架

2.2，复用红黑树实现insert接口

 2.3，迭代器iterator的实现

operator++()的实现：

operator--()的实现：

对insert返回值的更改：

2.4，map支持[ ]

2.5，整体代码 

2.6，代码测试

前言：

本篇基于上篇【红黑树的实现】，代码也是基于红黑树的代码实现map和set的封装。

一，库中map和set的大致结构

库中部分源代码如下：

//set

class set {
public:
  // typedefs:

  typedef Key key_type;
  typedef Key value_type;

   //...

private:
  typedef rb_tree<key_type, value_type, 
                  identity<value_type>, key_compare, Alloc> rep_type;
  rep_type t;  // red-black tree representing set

};

//map

class map {
public:

  //typedefs:

  typedef Key key_type;

  typedef pair<const Key, T> value_type;

  //...

private:
  typedef rb_tree<key_type, value_type, 
                  select1st<value_type>, key_compare, Alloc> rep_type;
  rep_type t;  // red-black tree representing map

};

//rb_tree红黑树 

template <class Value>
struct __rb_tree_node : public __rb_tree_node_base
{
  typedef __rb_tree_node<Value>* link_type;
  Value value_field;
};

template <class Key, class Value, class KeyOfValue, class Compare,
          class Alloc = alloc>
class rb_tree {

   typedef __rb_tree_node<Value> rb_tree_node;

   typedef rb_tree_node* link_type;

}；

        通过上面的源码可以分析出，map和set的实现采用了泛型思想实现。本来map和set各需要一颗红黑树rb_tree来实现的，这样的话两份代码相似部分极多。而采用泛型的思想，让rb_tree成为一个泛型模板，通过传参的差异决定是 map还是set,这样只需一份rb_tree即可。

        rb_tree是实现key的搜索场景，还是实现key/value的搜索场景，是通过第二个模板参数Value决定的，Value的类型确定了，__rb_tree的存储数据的类型就确定了。

        对于set，它的底层封装了rb_tree，第二个模板参数传的是key,实例化出的rb_tree，就是支持key的搜索场景。

        对于map，它的底层也封装了rb_tree，第二个参数传的是pair<const k,v>,实例化出的rb_tree,就是支持key/value的搜索场景。

        还有一点，对于map和set，我们可以知道关键在于底层rb_tree的第二个模板参数，那为什么还要再传第一个模板参数？        

        对于set类型，通过源码可以发现，底层rb_tree的第一个模板参数和第二个模板参数其实是一样的，都是key。但对于map来说，底层rb_tree的第一个模板参数是key，第二个模板参数是pair<k,v>。由于我们在使用rb_tree的查找（find）接口时，是根据key值来查找的，所以需要传第一个模板参数key。可以认为对于set来说时多余的，而对于map来说是必不可少的。为了实现代码的统一，所以set也要传。

 

二，模拟实现

2.1，大致框架

set.h

#include "RBTree.h"//xg
//key
namespace xg
{template<class k>class set{public://...private://底层调用红黑树//k键值是不能修改的，所以 加上constRBTree<k, const k> _t;};
}

 map.h

#include "RBTree.h"//map
//pair<k,v>
namespace xg
{template<class k,class v>class map{public://...private://底层调用红黑树//key值不能修改RBTree<k, pair<const k, v>> _t;};
}

同时，我们也采取库中的方法，对rb_tree进行修改，使其成为一个泛型结构。

rb_tree.h

#include <iostream>
using namespace std;enum color
{Red,Black
};
//由类型T决定红黑树为key还是pair类型
template<class T>
struct RBTreeNode
{RBTreeNode(const T& data):_left(nullptr),_right(nullptr),_parent(nullptr),_data(data){}RBTreeNode<T>* _left;RBTreeNode<T>* _right;RBTreeNode<T>* _parent;T _data;color _col;       
};//T决定是k还是pair
template<class k,class T>
class RBTree
{
public:typedef RBTreeNode<T> Node;//...
private:Node* _root=nullptr;
}；

2.2，复用红黑树实现insert接口

对于set和map，底层直接调用红黑树rb_tree的insert接口。

//set

bool insert(const k& key)
{
    return _t.Insert(key);
}

//map

bool insert(const pair<k, v>& kv)
{
    return _t.Insert(kv);
}

我们看看rb_tree中的insert接口（部分代码）：

这里需要将参数类型改为T类型，由map和set决定它的类型是key还是pair。

在插入逻辑中，我们需要比较插入元素的key值，从而找到插入位置。

对于set，比较的就是key值。但是对于map，比较的就是kv.fist。

为了满足两种不同的比较，我们可以通过仿函数的方式实现。map和set各实现一个仿函数，用来获取各自的key值。

通过分析源码可知，map和set的第三个模板参数就是为了解决这个问题。

 set.h

#include "RBTree.h"//xg
//key
namespace xg
{template<class k>class set{public:struct SetOfk{const k& operator()(const k& key){return key;}};bool insert(const k& key){return _t.Insert(key);}private://底层调用红黑树RBTree<k, const k,SetOfk> _t;};
}

map.h

#include "RBTree.h"//map
//pair<k,v>
namespace xg
{template<class k,class v>class map{public:struct MapOfk{const k& operator()(const pair<k, v>& kv){return kv.first;}};bool insert(const pair<k, v>& kv){return _t.Insert(kv);}private://底层调用红黑树RBTree<k, pair<const k, v>,MapOfk> _t;};
}

rb_tree的insert部分：

template<class k,class T,class ValueOfk>
class RBTree{

//插入k或者pair类型
bool  Insert(const T& data)
{
    if (_root == nullptr)
    {
        _root = new Node(data);
        _root->_col = Black;
        //return pair<Iterator,bool>({_root,_root},true);
        return {Iterator(_root,_root),true};
    }
    ValueOfk kot;
    Node* cur = _root;
    Node* parent = nullptr;
    while (cur)
    {
        //用键值k比较
        if (kot(cur->_data)< kot(data))
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (kot(cur->_data) >kot(data))
        {
            parent = cur;
            cur =cur->_left;
        }
        else
        {
            return false;
        }
    }
        //......旋转+变色

        //......

        //......

}

};

 2.3，迭代器iterator的实现

迭代器本质上是对红黑树节点的封装。我们需要实现对*，->的重载，以及对++，--的实现。

template<class T,class Ref,class ptr>
class RBTreeIterator
{
public:typedef RBTreeNode<T> Node;typedef RBTreeIterator<T, Ref, ptr> Self;RBTreeIterator(Node* node):_node(node){}//......//......
private://当前节点Node* _node;
};

这里的迭代器实现与list的迭代器实现思路大致相同，通过传Ref和ptr两个参数，从而通过一份模板，实现出iterator和const_iterator.

一些操作符的重载：

Ref operator*()
{
    return _node->_data;
}
ptr operator->()
{
    return &_node->_data;
}
bool operator!=(const Self& s) const
{
    return s._node != _node;
}
bool operator==(const Self& s) const 
{
    return s._node == _node;
}

operator++()的实现：

 （1）首先，我们要知道map和set的迭代器遍历走的是中序遍历，左子树->根节点->右子树，那么begin()应该返回 中序第一个节点，也就是红黑树的最左节点。而对于end(),我们可以让它是空节点。

（2）迭代器++时，如果it指向的节点的右子树不为空时，说明当前节点已经访问完，下一个节点访问是右子树的中序第一个，也就是右子树的最左节点。

（3）迭代器++时，如果it指向的节点的右子树为空，说明当前节点已经当前节点所在的子树已经访问完了，要访问的下一个节点在当前节点的祖先里面，要沿着当前节点到根的路径找。并且该节点一定满足孩子是父亲的左子树。

 

Self operator++()
{//左根右//当前节点的右子树不为空，继续找右子树的最左节点if (_node->_right){Node* cur = _node->_right;while ( cur->_left){cur = cur->_left;}_node = cur;}else{//当前节点的右子树为空，说明当前子树已经访问完//找孩子为祖先左的祖先Node* cur = _node;Node* parent = cur->_parent;while (parent && cur == parent->_right){cur = parent;parent = cur->_parent;}_node = parent;}return *this;
}
operator--()的实现：

实现思路与operator++()相反

（1）迭代器--时，如果it指向的节点的左子树不为空时，说明当前节点已经访问完，下一个节点访问是左子树的最右节点。

（2）迭代器--时，如果it指向的节点的左子树为空，说明当前节点已经当前节点所在的子树已经访问完了，要访问的下一个节点在当前节点的祖先里面，要沿着当前节点到根的路径找。并且该节点一定满足孩子是父亲的右子树。

（3）需要注意的是，可能会遇到end()--的情况，而end()是空节点，会报错。我们可以进行特殊处理，当it==end()时，让 它等于中序遍历的最后一个节点，也就是红黑树的最右节点。

而在最右节点的时候，需要根节点，所以需要在iterator中再加入根节点。

Self operator--()
{//右根左if (_node == nullptr) //end()--{Node* cur = _root;while (cur->_right){cur = cur->_right;}_node = cur;}//当前节点的左子树不为空，继续找左子树的最右节点else if (_node->_left){Node* cur = _node->_left;while (cur){cur = cur->_right;}_node = cur;}else{//左子树为空，当前子树已访问完//找孩子为祖先右的节点Node* cur = _node;Node* parent = cur->_parent;while (parent && cur == parent->_left){cur = parent;parent = cur->_parent;}_node = parent;}return *this;
}
对insert返回值的更改：

 

库中的insert方法实现了返回pair<iterator,bool>类型，iterator表示 插入节点的迭代器，bool值表示是否插入成功。 我们只需在返回值处修改，返回iterator迭代器和bool构成的pair类型。

//插入k或者pair类型
pair<Iterator,bool> Insert(const T& data)
{
    if (_root == nullptr)
    {
        _root = new Node(data);
        _root->_col = Black;
        //return pair<Iterator,bool>({_root,_root},true);
        return {Iterator(_root,_root),true};
    }
    ValueOfk kot;
    Node* cur = _root;
    Node* parent = nullptr;
    while (cur)
    {
        //用键值k比较
        if (kot(cur->_data)< kot(data))
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (kot(cur->_data) >kot(data))
        {
            parent = cur;
            cur =cur->_left;
        }
        else
        {
            //return pair<Iterator,bool>({cur,_root},false);
            return { Iterator(cur, _root), false };
        }
    }

    //插入
    cur = new Node(data);

     //cur在下述调整过程中会向上更新变化，需要提前保存下来
    Node* newnode = cur;
    cur->_col = Red;
    if (kot(parent->_data) <kot(data))
        parent->_right = cur;
    else
        parent->_left = cur;
    cur->_parent = parent;

    //颜色处理+旋转
    while (parent&& parent->_col == Red)
    {
        Node* grandfather = parent->_parent;
        if (parent == grandfather->_left)
        {
            //    g
            //  p   u
            Node* uncle = grandfather->_right;
            //叔叔存在且为红
            if (uncle && uncle->_col == Red)
            {
                //变色
                parent->_col = Black;
                uncle->_col = Black;
                grandfather->_col = Red;
                //继续向上处理
                cur = grandfather;
                parent = cur->_parent;
            }
            else
            {
                //叔叔不存在或者叔叔为黑
                //    g
                //  p   u
               // c
                //u为黑，则c是之前是黑的
                //u不存在，则c是新插入的
                if (cur == parent->_left)
                {
                    RotateR(grandfather);
                    parent->_col = Black;
                    grandfather->_col = Red;
                }
                else
                {
                    //    g
                    //  p   u
                   //     c
                    RotateL(parent);
                    RotateR(grandfather);
                    cur->_col = Black;
                    grandfather->_col = Red;
                }
                break;
            }
        }
        else
        {
            //   g
            // u   p
            Node* uncle = grandfather->_left;
            if (uncle && uncle->_col == Red)
            {
                //变色
                parent->_col = Black;
                uncle->_col = Black;
                grandfather->_col = Red;

                cur = grandfather;
                parent = cur->_parent;
            }
            else
            {
                //   g
                // u   p
                //       c
                if (cur == parent->_right)
                {
                    RotateL(grandfather);
                    parent->_col = Black;
                    grandfather->_col = Red;
                }
                else
                {
                    //   g
                    // u   p
                    //   c
                    RotateR(parent);
                    RotateL(grandfather);
                    cur->_col = Black;
                    grandfather->_col = Red;
                }
                break;
            }
        }
    }
    _root->_col = Black;
    return pair<Iterator,bool>({newnode,_root},true);
}

2.4，map支持[ ]

map需要支持operator[ ]来实现对value值的访问及修改。

我们在上述实现了insert接口返回pair<iterator,bool>类型，就可以直接复用。

 v& operator[](const k& key)   
{

     //key不存在就插入该值和value的缺省值，并返回

     //key存在就得到key位置的iterator
    pair<iterator, bool> ret = insert({ key,v() });
    return ret.first->second;
}

2.5，整体代码 

rb_tree.h

#include <iostream>
using namespace std;enum color
{Red,Black
};
//由类型T决定红黑树为key还是pair类型
template<class T>
struct RBTreeNode
{RBTreeNode(const T& data):_left(nullptr),_right(nullptr),_parent(nullptr),_data(data){}RBTreeNode<T>* _left;RBTreeNode<T>* _right;RBTreeNode<T>* _parent;T _data;color _col;       
};template<class T,class Ref,class ptr>
class RBTreeIterator
{
public:typedef RBTreeNode<T> Node;typedef RBTreeIterator<T, Ref, ptr> Self;RBTreeIterator(Node* node,Node* root):_node(node),_root(root){}Self operator++(){//左根右//当前节点的右子树不为空，继续找右子树的最左节点if (_node->_right){Node* cur = _node->_right;while ( cur->_left){cur = cur->_left;}_node = cur;}else{//当前节点的右子树为空，说明当前子树已经访问完//找孩子为祖先左的祖先Node* cur = _node;Node* parent = cur->_parent;while (parent && cur == parent->_right){cur = parent;parent = cur->_parent;}_node = parent;}return *this;}Self operator--(){//右根左if (_node == nullptr) //end()--{Node* cur = _root;while (cur->_right){cur = cur->_right;}_node = cur;}//当前节点的左子树不为空，继续找左子树的最右节点else if (_node->_left){Node* cur = _node->_left;while (cur){cur = cur->_right;}_node = cur;}else{//左子树为空，当前子树已访问完//找孩子为祖先右的节点Node* cur = _node;Node* parent = cur->_parent;while (parent && cur == parent->_left){cur = parent;parent = cur->_parent;}_node = parent;}return *this;}Ref operator*(){return _node->_data;}ptr operator->(){return &_node->_data;}bool operator!=(const Self& s) const//请const吃一顿{return s._node != _node;}bool operator==(const Self& s) const //请coonst吃一顿{return s._node == _node;}
private://当前节点Node* _node;Node* _root;//根节点
};//T决定是k还是pair
template<class k,class T,class ValueOfk>
class RBTree
{
public:typedef RBTreeNode<T> Node;typedef RBTreeIterator<T, T&, T*>  Iterator;typedef RBTreeIterator<T, const T&, const T*> ConstIterator;//迭代器为中序遍历Iterator Begin(){//找最左节点Node* cur = _root;while (cur&&cur->_left){cur = cur->_left;}return Iterator(cur,_root);}Iterator End(){return Iterator(nullptr,_root);}ConstIterator Begin() const{Node* cur = _root;while (cur && cur->_left){cur = cur->_left;}return ConstIterator(cur,_root);}ConstIterator End() const{return ConstIterator(nullptr,_root);}//插入k或者pair类型pair<Iterator,bool> Insert(const T& data){if (_root == nullptr){_root = new Node(data);_root->_col = Black;//return pair<Iterator,bool>({_root,_root},true);return {Iterator(_root,_root),true};}ValueOfk kot;Node* cur = _root;Node* parent = nullptr;while (cur){//用键值k比较if (kot(cur->_data)< kot(data)){parent = cur;cur = cur->_right;}else if (kot(cur->_data) >kot(data)){parent = cur;cur =cur->_left;}else{//return pair<Iterator,bool>({cur,_root},false);return { Iterator(cur, _root), false };}}//插入cur = new Node(data);Node* newnode = cur;cur->_col = Red;if (kot(parent->_data) <kot(data))parent->_right = cur;elseparent->_left = cur;cur->_parent = parent;//颜色处理+旋转while (parent&& parent->_col == Red){Node* grandfather = parent->_parent;if (parent == grandfather->_left){//    g//  p   uNode* uncle = grandfather->_right;//叔叔存在且为红if (uncle && uncle->_col == Red){//变色parent->_col = Black;uncle->_col = Black;grandfather->_col = Red;//继续向上处理cur = grandfather;parent = cur->_parent;}else{//叔叔不存在或者叔叔为黑//    g//  p   u// c//u为黑，则c是之前是黑的//u不存在，则c是新插入的if (cur == parent->_left){RotateR(grandfather);parent->_col = Black;grandfather->_col = Red;}else{//    g//  p   u//     cRotateL(parent);RotateR(grandfather);cur->_col = Black;grandfather->_col = Red;}break;}}else{//   g// u   pNode* uncle = grandfather->_left;if (uncle && uncle->_col == Red){//变色parent->_col = Black;uncle->_col = Black;grandfather->_col = Red;cur = grandfather;parent = cur->_parent;}else{//   g// u   p//       cif (cur == parent->_right){RotateL(grandfather);parent->_col = Black;grandfather->_col = Red;}else{//   g// u   p//   cRotateR(parent);RotateL(grandfather);cur->_col = Black;grandfather->_col = Red;}break;}}}_root->_col = Black;return pair<Iterator,bool>({newnode,_root},true);}void RotateR(Node* parent){Node* subL = parent->_left;Node* subLR = subL->_right;Node* pparent = parent->_parent;if (subLR)subLR->_parent = parent;parent->_left = subLR;subL->_right = parent;parent->_parent = subL;if (parent == _root){_root = subL;_root->_parent = nullptr;}else{if (pparent->_left == parent)pparent->_left = subL;elsepparent->_right = subL;subL->_parent = pparent;}}void RotateL(Node* parent){Node* subR = parent->_right;Node* subRL = subR->_left;Node* pparent = parent->_parent;parent->_right = subRL;if (subRL)subRL->_parent = parent;parent->_parent = subR;subR->_left = parent;if (parent == _root){_root = subR;_root->_parent = nullptr;}else{if (pparent->_left == parent)pparent->_left = subR;elsepparent->_right = subR;subR->_parent = pparent;}}void Inorder(){_Inorder(_root);}int Height(){return _Height(_root);}int size(){return _size(_root);}int _size(Node* root){if (root == nullptr)return 0;return _size(root->_left) + _size(root->_right) + 1;}int _Height(Node* root){if (root == nullptr)return 0;int leftHeight = _Height(root->_left);int rightHeight = _Height(root->_right);return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;}void _Inorder(Node* root){if (root == nullptr)return;_Inorder(root->_left);cout << root->_kv.first << ":" << root->_kv.second << endl;_Inorder(root->_right);}
private:Node* _root=nullptr;
};

set.h

#include "RBTree.h"//xg
//key
namespace xg
{template<class k>class set{public:struct SetOfk{const k& operator()(const k& key){return key;}};typedef typename RBTree<k, const k, SetOfk>::Iterator iterator;typedef typename RBTree<k, const k, SetOfk>::ConstIterator const_iterator;iterator begin(){return _t.Begin();}iterator end(){return _t.End();}const_iterator begin()const{return _t.Begin();}const_iterator end() const{return _t.End();}pair<iterator,bool> insert(const k& key){return _t.Insert(key);}private://底层调用红黑树RBTree<k, const k,SetOfk> _t;};
}

map.h

include "RBTree.h"//map
//pair<k,v>
namespace xg
{template<class k,class v>class map{public:struct MapOfk{const k& operator()(const pair<k, v>& kv){return kv.first;}};typedef typename RBTree<k, pair<const k, v>, MapOfk>::Iterator iterator;typedef typename RBTree<k, pair<const k, v>, MapOfk>::ConstIterator const_iterator;iterator begin(){return _t.Begin();}iterator end(){return _t.End();}const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}pair<iterator,bool> insert(const pair<k, v>& kv){return _t.Insert(kv);}v& operator[](const k& key)  {pair<iterator, bool> ret = insert({ key,v() });return ret.first->second;}private://底层调用红黑树RBTree<k, pair<const k, v>,MapOfk> _t;};
}

2.6，代码测试

#include "map.h"
#include "set.h"
#include <string>

int main()
{
    xg::set<int> s;
    s.insert(5);
    s.insert(1);
    s.insert(3);
    s.insert(2);
    s.insert(6);

    xg::set<int>::iterator sit = s.begin();
    
    while (sit != s.end())
    {
        cout << *sit << " ";
        ++sit;
    }
    cout << endl;

    for (auto& e : s)
    {
        cout << e << " ";
    }
    cout << endl;

    xg::map<string, string> dict;
    dict.insert({ "sort", "排序" });
    dict.insert({ "left", "左边" });
    dict.insert({ "right", "右边" });

    dict["left"] = "左边，剩余";
    dict["insert"] = "插入";
    dict["string"];

    xg::map<string, string>::iterator it = dict.begin();
    while (it!=dict.end())
    {
        // 不能修改first，可以修改second
        //it->first += 'x';
        it->second += 'x';

        cout << it->first << ":" << it->second << endl;
        ++it;
    }
    cout << endl;

    for (auto& kv : dict)
    {
        cout << kv.first << ":" << kv.second << endl;
    }

    return 0;
}

 


http://www.ppmy.cn/ops/152165.html

相关文章

Python 脚本-显示给定文件的文件信息

Python 脚本-显示给定文件的文件信息

目录 Python 代码实现 Python 代码解释 1.导入必要的模块&#xff1a; 2.函数 get_file_info&#xff1a; 3.函数 print_file_info&#xff1a; 4.主函数 main&#xff1a; 5.程序入口&#xff1a; 使用方法 Python 代码实现 import os import stat import sys import…
阅读更多...
AI大模型开发—1、百度的千帆大模型调用（文心一言的底层模型，ENRIE等系列）、API文档目的地

AI大模型开发—1、百度的千帆大模型调用（文心一言的底层模型，ENRIE等系列）、API文档目的地

文章目录 前言一、千帆大模型平台简介二、百度平台官网初使用1、平台注册和使用2、应用注册 并 申请密钥3、开启千帆大模型 API调用a、API文档b、 前言 本章旨在为读者奉献一份实用的操作指南&#xff0c;深入探索如何高效利用百度千帆大模型平台的卓越功能。我们将从账号注册…
阅读更多...
Django多线程爬虫：突破数据抓取瓶颈

Django多线程爬虫：突破数据抓取瓶颈

Django框架以其高效、安全、可扩展性强等特点&#xff0c;在Web开发领域得到了广泛应用。同时&#xff0c;Python语言的多线程支持和丰富的库也为开发多线程爬虫提供了便利。将Django与多线程技术相结合&#xff0c;不仅可以利用Django的强大功能进行项目管理和数据存储&#x…
阅读更多...
强化学习入门--基本概念

强化学习入门--基本概念

强化学习基本概念 grid-world example 这个指的是一个小机器人&#xff08;agent&#xff09;在一个网格区域&#xff08;存在边界&#xff09;&#xff0c;网格中存在需要躲避的格子和目标格子&#xff0c;我们的目的就是找到到达目标格子的最短路径 state 表示智能体相对…
阅读更多...
Golang的图形编程应用案例分析与技术深入

Golang的图形编程应用案例分析与技术深入

Golang的图形编程应用案例分析与技术深入 一、Golang在图形编程中的应用介绍 作为一种高效、简洁的编程语言&#xff0c;近年来在图形编程领域也逐渐展露头角。其并发性能优势和丰富的标准库使得它成为了一个越来越受欢迎的选择。 与传统的图形编程语言相比&#xff0c;Golang具…
阅读更多...
网络编程-UDP套接字

网络编程-UDP套接字

文章目录 UDP/TCP协议简介两种协议的联系与区别Socket是什么 UDP的SocketAPIDatagramSocketDatagramPacket 使用UDP模拟通信服务器端客户端测试 完整测试代码 UDP/TCP协议简介 两种协议的联系与区别 TCP和UDP其实是传输层的两个协议的内容, 差别非常大, 对于我们的Java来说, …
阅读更多...
MDX语言的语法糖

MDX语言的语法糖

MDX语言的语法糖及其应用分析 引言 在当今数据驱动的时代&#xff0c;大数据分析和数据可视化已成为企业决策中不可或缺的一部分。MDX&#xff08;Multidimensional Expressions&#xff0c;多维表达式&#xff09;作为一门专为分析多维数据而设计的查询语言&#xff0c;广泛…
阅读更多...
MySQL下载安装配置（超级超级入门级）

MySQL下载安装配置（超级超级入门级）

一、下载MySQL MySQL是一个关系型数据库管理系统&#xff0c;由瑞典 MySQL AB 公司开发&#xff0c;属于 Oracle 旗下产品。 MySQL官网下载地址&#xff1a;https://dev.mysql.com/downloads/mysql/ 打开官网&#xff0c;现在最新是9.0版本&#xff0c;我们这里选择8.03版本…
阅读更多...
最新文章

Copyright @ 2022~2023