DS进阶：AVL树和红黑树

news/2024/5/20 6:35:38

一、AVL树

1.1 AVL树的概念

        二叉搜索树（BST）虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
（1）它的左右子树都是AVL树
（2）左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
 

AVL树有多种实现版本，但是我们采用平衡因子的版本来模拟实现AVL树。

1.2 AVL树的节点定义

        AVL树每插入或者删除一个节点，都有可能会影响高度，所以大多数情况下都需要向上调整平衡因子，所以我们的实现采用三叉链的形式（left、right、parent），方便我们找父节点，并且引入平衡因子，为的就是通过对平衡因子的调整和判断该树是否需要进行旋转。

template<class K, class V>
struct AVLTreeNode
{AVLTreeNode<K, V>* _left;AVLTreeNode<K, V>* _right;AVLTreeNode<K, V>* _parent;pair<K, V> _kv;int _bf;//平衡因子 balance factorAVLTreeNode(const pair<K, V>& kv): _left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _bf(0){}
};

      平衡因子的大小=右子树的高度-左子树的高度。 

1.3 AVL树的插入

        首先AVL树本质上也是BST的逻辑，只不过增加了平衡因子来控制高度。所以在按照BST的逻辑插入节点之后，我们要去向上调整平衡因子。逻辑：如果我（cur）是你（parent）的左子树，那么你的bf就-- ，如果我是你的右子树，那么你的bf就++（因为平衡因子的大小=右子树的高度-左子树的高度。）

       而现在需要思考的问题就是，什么情况下需要去进行调整。因此我们需要分情况讨论

1、如果调整过后，平衡因子的绝对值为1，说明调整之前的平衡因子为0，即左右高度是相等的，此时变成1说明树的高度变了，因此需要继续向上调整。

2、如果调整过后，平衡因子的绝对值为2，说明调整之前的平衡因子绝对值为1，说明子树已经严重不平衡并且破坏了AVL树的规则，此时我们就要进行旋转。旋转过后就可以结束循环了

3、如果调整过后，平衡因子的绝对值是0，说明调整之前的平衡因子的绝对值是1，这说明之前的高度是不平衡的，插入之后反而变得更平衡了，此时就可以结束循环了。

       根据上面的这些规则，我们现将整个架子先搭建起来，然后再去研究当bf的绝对值为2的时候应该怎么去进行旋转。

	bool insert(const pair<K, V>& kv){//如果为空树，新节点就是根if (_root == nullptr){_root = new Node(kv);return true;}//如果不为空树Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_kv.first > kv.first) //如果我比你大，到左子树去{parent = cur;cur = cur->_left;}else if (cur->_kv.first < kv.first) //比你小，你去右子树{parent = cur;cur = cur->_right;}else return false;//相等 }//此时肯定是对应地接在parent的后面cur = new Node(kv);if (kv.first < parent->_kv.first)   parent->_left =cur;                //比父亲小连左边else  parent->_right = cur; //比父亲大连右边//别忘了父亲指针cur->_parent = parent;//调整平衡因子while (parent){//首先调整因子，如果我是你的左孩子，这时你的左边变高了，所以要--//如果我是你的右孩子，此时你的右边变高了，所以要++if (cur == parent->_left) --parent->_bf;else ++parent->_bf;//更新之后，我们要根据当前多的情况，决定是向上更新，还是旋转，还是退出if (abs(parent->_bf) == 1)  //更新之后变成1，说明之前是左右相等，现在高度变了{parent = parent->_parent;//继续向上更新cur = cur->_parent;}// 更新之后变成0，说明之前是1或者 - 1，插入后更加平衡了，此时就不需要进行下去了else if (abs(parent->_bf) == 0)  break;else if (abs(parent->_bf) == 2) //说明子树不平衡，需要对子树进行旋转处理{//……………………… （旋转）break;}

1.4 AVL树的旋转（重点）

每一个模块都分别画了抽象图和具象图

1.4.1 新节点插入较高左子树的左侧 （左左->右单旋）

1.4.2 新节点插入较高右子树的右侧 （右右->左单旋）

1.4.3 新节点插入较高左子树的右侧 （左右->左右双旋）

1.4.4 新节点插入较高右子树的左侧 （右左->右左双旋）

 1.4.5 旋转的代码完善

        分析完上面的四种情况，我们通过抽象图去判断具体应该怎么旋转，分别封装对应的旋转函数，然后再根据图去看看哪一些需要去调整平衡因子。统一放在我们的代码逻辑里面。 

       平时我们记忆该选择哪一种旋转方式，可以先画出折线图再一步一步去分析。

	void RotateR(Node *parent){//旋转前，先记录对应的节点Node* subL = parent->_left;Node* subLR = subL->_right;Node* ppnode = parent->_parent;//子树的前驱节点//先让b变成60的左边parent->_left = subLR;if (subLR) subLR->_parent = parent;//让60变成30的右边subL->_right = parent;parent->_parent = subL;//此时与前驱节点连接起来 如果前驱节点为空，直接改变根if (ppnode==nullptr){_root = subL;_root->_parent = nullptr;}//如果前驱节点不为空，此时要根据之前paernt的情况决定插在哪边else{if (ppnode->_left == parent) ppnode->_left = subL;else ppnode->_right = subL;//向上连接subL->_parent = ppnode;}//旋转完后，别忘记调节平衡因子，按图，都为0subL->_bf = parent->_bf = 0;}void RotateL(Node* parent){//旋转前，先记录对应的节点Node* subR = parent->_right;Node* subRL = subR->_left;Node* ppnode = parent->_parent;//子树的前驱节点//先让b变成30的边parent->_right = subRL;if (subRL) subRL->_parent = parent;//让30变成60的左边subR->_left = parent;parent->_parent = subR;//此时与前驱节点连接起来 如果前驱节点为空，直接改变根if (ppnode == nullptr){_root = subR;_root->_parent = nullptr;}//如果前驱节点不为空，此时要根据之前paernt的情况决定插在哪边else{if (ppnode->_left == parent) ppnode->_left = subR;else ppnode->_right = subR;//向上连接subR->_parent = ppnode;}//旋转完后，别忘记调节平衡因子，按图，都为0subR->_bf = parent->_bf = 0;}void RotateLR (Node* parent){//旋转前，先记录相应的节点Node* subL = parent->_left;Node* subLR = subL->_right;int bf = subLR->_bf;//先对30左旋，再对90右旋RotateL(subL);RotateR(parent);//此时要调整平衡因子，但是有三种情况if (bf == -1){parent->_bf = 1;subL->_bf = 0;subLR->_bf = 0;}else if (bf == 0){parent->_bf = 0;subL->_bf = 0;subLR->_bf = 0;}else if (bf == 1){parent->_bf = 0;subL->_bf = -1;subLR->_bf = 0;}else assert(false);}void RotateRL(Node* parent){//旋转前，先记录相应的节点Node* subR = parent->_right;Node* subRL = subR->_left;int bf = subRL->_bf;//先对90右旋，再对30左旋RotateR(subR);RotateL(parent);//此时要调整平衡因子，但是有三种情况if (bf == -1){parent->_bf = 0;subR->_bf = 1;subRL->_bf = 0;}else if (bf == 0){parent->_bf = 0;subR->_bf = 0;subRL->_bf = 0;}else if (bf == 1){parent->_bf = -1;subR->_bf = 0;subRL->_bf = 0;}else assert(false);}};

然后我们接着去根据4种旋转方式，判断insert需要调用哪一个类型的函数，完善我们的insert代码

bool insert(const pair<K, V>& kv)
{//如果为空树，新节点就是根if (_root == nullptr){_root = new Node(kv);return true;}//如果不为空树Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_kv.first > kv.first) //如果我比你大，到左子树去{parent = cur;cur = cur->_left;}else if (cur->_kv.first < kv.first) //比你小，你去右子树{parent = cur;cur = cur->_right;}else return false;//相等 }//此时肯定是对应地接在parent的后面cur = new Node(kv);if (kv.first < parent->_kv.first)   parent->_left =cur;                //比父亲小连左边else  parent->_right = cur; //比父亲大连右边//别忘了父亲指针cur->_parent = parent;//调整平衡因子while (parent){//首先调整因子，如果我是你的左孩子，这时你的左边变高了，所以要--//如果我是你的右孩子，此时你的右边变高了，所以要++if (cur == parent->_left) --parent->_bf;else ++parent->_bf;//更新之后，我们要根据当前多的情况，决定是向上更新，还是旋转，还是退出if (abs(parent->_bf) == 1)  //更新之后变成1，说明之前是左右相等，现在高度变了{parent = parent->_parent;//继续向上更新cur = cur->_parent;}// 更新之后变成0，说明之前是1或者 - 1，插入后更加平衡了，此时就不需要进行下去了else if (abs(parent->_bf) == 0)  break;else if (abs(parent->_bf) == 2) //说明子树不平衡，需要对子树进行旋转处理{//旋转处理 1、让子树平衡（降低高度） 2、旋转同时保证是搜索树的逻辑。//此时会出现四种情况，左单旋 右单旋 左右双旋转  右左双旋//情况1 右单旋   较高左子树的左侧if (parent->_bf == -2 && cur->_bf == -1)  RotateR(parent);//情况2 左单旋   较高右子树的右侧else if (parent->_bf == 2 && cur->_bf == 1)  RotateL(parent);//情况3 左右双旋  较高左子树的右侧else if (parent->_bf == -2 && cur->_bf == 1) RotateLR(parent);//情况4  右左双旋  较高右子树的左侧else if (parent->_bf == 2 && cur->_bf == -1) RotateRL(parent);else assert(false);//加个断言防止旋转出问题//旋转处理完之后，可以直接breakbreak;}else  assert(false);//加个断言，防止平衡因子出问题}return true;
}

1.5 AVL树的验证

1.5.1 验证其为二叉搜索树

        这个比较容易，我们可以直接通过一个中序遍历，如果打印出来之后得到的是一个有序序列，说明这就是一个二叉搜索树。但是接下来我们还得判断他是否是平衡树。

void Inorder()//中序遍历接口
{_Inorder(_root);cout << endl;
}void _Inorder(Node*root)
{if (root == nullptr) return;_Inorder(root->_left);cout << root->_kv.first << " ";_Inorder(root->_right);
}

1.5.2 验证节点的平衡因子是否等于右子树的高度-左子树的高度

     首先我们需要封装一个计算树高度的函数。需要用到后序遍历。

int Height()  //搜索树的高度
{return _Height(_root);
}
int _Height(Node* root)
{if (root == nullptr) return 0;int leftH = _Height(root->_left);int rightH = _Height(root->_right);return leftH > rightH ? leftH + 1 : rightH + 1;
}

       然后看看我们遍历到当前节点的时候，我们用该函数算出左子树的高度和右子树的高度，看看右子树-左子树是否等于平衡因子。 

1.5.3 以每个节点为根的树他的左右子树是否严格遵守高度差

      但是平衡因子是我们自己去调整的，所以我们最关键的还是去判断我们的左右子树的高度差绝对值是否<2 

     需要注意的是，我们必须确保每一个子树都满足AVL树的性质，所以调用完一次isbalance之后，还得去继续判断他的左子树和右子树！！！  这样才能说明他是一颗平衡树！！   

bool IsBalance()
{return _IsBalance(_root);
}bool _IsBalance(Node* root)
{if (root == nullptr) return true;int leftH = _Height(root->_left);int rightH = _Height(root->_right);if (rightH - leftH != root->_bf) //检查平衡因子是否符合要求{cout<< root->_kv.first << "节点平衡因子异常" << endl;return false;}return abs(leftH - rightH) < 2 && _IsBalance(root->_left) && _IsBalance(root->_right);
}

 1.6 AVL树的性能

      AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即log2N。但是如果要对AVL树做一些结构修改的操
作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，
有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数
据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

     为了解决这个问题，红黑树出现了！！

二、红黑树

2.1 红黑树的概念

        红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或
Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的（通过几条规则达到近似平衡）。

    总的来说，BST可能会退化成单支树，而AVL旋转过于严格，RB就是一种退而求其次的解决方法。 比如下面这颗树，AVL树一定旋转，但是RB不一定旋转。

 2.2 红黑树的性质

    接下来我们就来探究，大佬是如何通过几条规则来让红黑树确保没有一条路径会比其他路径长出俩倍的。

1. 每个结点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)
 

 思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点
个数的两倍？

 2.3 红黑树节点的定义

和将AVL树的平衡因此换成颜色

enum Colour
{RED,BLACK,
};template<class K, class V>
struct RBTreeNode
{RBTreeNode<K, V>* _left;RBTreeNode<K, V>* _right;RBTreeNode<K, V>* _parent;pair<K, V> _kv;Colour _col;RBTreeNode(const pair<K, V>& kv): _left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _col(RED){}};

思考：为什么我们默认要把颜色设置成红色？？

      要分析究竟设置成红色还是黑色好一点，取决于以上的两条规则（1）如果一个节点是红色的，则它的两个孩子结点是黑色的 。（2）对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点

      首先我们要知道，插入这个节点之前该树一定是保持红黑树的性质，即满足上面的两个规则，如果我们新插入的节点默认选择黑色的话，那么凭空多出来的黑色节点必然会导致规则2被破坏，也就是说我们每插入一次就要去调整。如果我们选择的是红色的话，我们红色的父亲节点是黑色，那么就不需要进行调整，如果父亲节点是红色，我们才要进行调整！！！总的来说就是黑色是必然会破坏规则的，但是红色不一定，所以我们默认选择设置成红色，这样需要考虑的情况会更少一些。

2.4 红黑树的插入和旋转（重点）

情况1： 首先因为我们把默认节点设置为红色，所以如果被插入位置的父亲节点是黑色的话，就不需要进行调整了。

情况2：如果待插入前是空树， 那么新插入元素自动成为根，并且将其设置为黑色

      前两个情况比较简单，而后三个情况就是红黑树的非常关键的逻辑！！首先我们要知道我们调整的前提是当前待插入节点的父节点也是红色。

      如上图我们可以知道，因为待插入节点的父节点必然是红色，所以其祖父节点g必然是黑色，而我们下面情况的分析就是取决于u节点 

情况3：u存在且为红

 情况4：u存在且为黑，由情况3变化而来，插入在较高子树的同一侧（单旋）

 情况5：u存在且为黑，由情况3变化而来，插入在较高子树的另一侧（双旋） 

 总结：

 2.5 红黑树旋转和插入代码实现

//旋转代码和AVL树是一样的，只不过不需要搞平衡因子void RotateL(Node* parent){//旋转前，先记录对应的节点Node* subR = parent->_right;Node* subRL = subR->_left;Node* ppnode = parent->_parent;//子树的前驱节点//先让b变成30的边parent->_right = subRL;if (subRL) subRL->_parent = parent;//让30变成60的左边subR->_left = parent;parent->_parent = subR;//此时与前驱节点连接起来 如果前驱节点为空，直接改变根if (ppnode == nullptr){_root = subR;_root->_parent = nullptr;}//如果前驱节点不为空，此时要根据之前paernt的情况决定插在哪边else{if (ppnode->_left == parent) 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;//子树的前驱节点//先让b变成60的左边parent->_left = subLR;if (subLR) subLR->_parent = parent;//让60变成30的右边subL->_right = parent;parent->_parent = subL;//此时与前驱节点连接起来 如果前驱节点为空，直接改变根if (ppnode == nullptr){_root = subL;_root->_parent = nullptr;}//如果前驱节点不为空，此时要根据之前paernt的情况决定插在哪边else{if (ppnode->_left == parent) ppnode->_left = subL;else ppnode->_right = subL;//向上连接subL->_parent = ppnode;}}//先用搜索树的逻辑插入节点，然后再去更新平衡因子。
bool Insert(const pair<K, V>& kv)
{//如果为空树，新节点就是根if (_root == nullptr){_root = new Node(kv);_root->_col=BLACK;return true;}//如果不为空树Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_kv.first > kv.first) //如果我比你大，到左子树去{parent = cur;cur = cur->_left;}else if (cur->_kv.first < kv.first) //比你小，你去右子树{parent = cur;cur = cur->_right;}else return false;//相等 }//此时肯定是对应地接在parent的后面cur = new Node(kv);if (kv.first < parent->_kv.first)   parent->_left = cur;                //比父亲小连左边else  parent->_right = cur; //比父亲大连右边//别忘了父亲指针cur->_parent = parent;while (parent && parent->_col == RED){Node* grandfather = parent->_parent;//情况1，如果u为存在且为红if (grandfather->_left == parent)//如果p是g的左边，u就在右边{Node* uncle = grandfather->_right;//情况1，如果u为存在且为红 p u变黑，g变红 向上调整if (uncle && uncle->_col == RED){parent->_col = BLACK;uncle->_col = BLACK;grandfather->_col = RED;//继续向上调整cur = grandfather;parent = cur->_parent;}else //情况2或者情况3， u为黑或者不存在   旋转+变色{ if (cur == parent->_left) //情况2 右单旋+p变黑 g变红{//      g//   p    u// cRotateR(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else  //情况3 右左双旋  c变黑 g变红{//          g//   p     u//     cRotateL(parent);RotateR(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;//情况2和情况3都要跳出循环}}else//if (grandfather->_right == parent)//如果p是g的右边，u就在左边    几乎一样，就是旋转的逻辑不同{Node* uncle = grandfather->_left;//情况1，如果u为存在且为红 p u变黑，g变红 向上调整if (uncle && uncle->_col == RED){parent->_col = BLACK;uncle->_col = BLACK;grandfather->_col = RED;//继续向上调整cur = grandfather;parent = cur->_parent;}else//情况2或者情况3， u为黑或者不存在   旋转+变色{if (cur == parent->_right) //情况2 左单旋+p变黑 g变红{//      g//   p    u//          cRotateL(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else  //情况3 左右双旋  c变黑 g变红{//          g//   p     u//       cRotateR(parent);RotateL(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;//情况2和情况3都要跳出循环}}}_root->_col = BLACK; //预防情况1出现 parent就是根的情况 此时无论如何_root变成黑，总没错return true;
}

 2.6 红黑树的验证规则

bool IsBalance()
{if (_root && _root->_col == RED){cout << "根节点颜色是红色" << endl;return false;}int benchmark = 0;//找到一条路径作为基准值 然后看看其他路径是否相等Node* cur = _root;while (cur){if (cur->_col == BLACK)++benchmark;cur = cur->_left;}// 连续红色节点return _Check(_root, 0, benchmark);
}
bool _Check(Node* root, int blackNum, int benchmark)
{if (root == nullptr){if (benchmark != blackNum){cout << "某条路径黑色节点的数量不相等" << endl;return false;}return true;}if (root->_col == BLACK){++blackNum;}if (root->_col == RED&& root->_parent&& root->_parent->_col == RED){cout << "存在连续的红色节点" << endl;return false;}return _Check(root->_left, blackNum, benchmark)&& _Check(root->_right, blackNum, benchmark);
}

2.7 RB和AVL的比较

1、红黑树不追求"完全平衡"，即不像AVL那样要求节点的高度差 <= 1，它只要求部分达到平衡，但是提出了为节点增加颜色，红黑树是用非严格的平衡来换取增删节点时候旋转次数的降低。

2、就插入节点导致树失衡的情况，AVL和RB-Tree都是最多两次树旋转来实现复衡rebalance，旋转的量级是O(1)，删除节点导致失衡，AVL需要维护从被删除节点到根节点root这条路径上所有节点的平衡，旋转的量级为O(logN)，而RB-Tree最多只需要旋转3次实现复衡，只需O(1)，所以说RB-Tree删除节点的rebalance的效率更高，开销更小！

 总结：

（ 1 ）AVL更平衡，结构上更加直观，时间效能针对读取而言更高（搜索效率高）；维护稍慢，空间开销较大。
（ 2 ） 红黑树，读取略逊于AVL，维护强于AVL（复衡效率高），空间开销与AVL类似，内容极多时略优于AVL，维护优于AVL。

（3）总体来说RB的整体性能高于AVL，因此在实际应用中基本上都是用的RB。

2.8 红黑树的实际应用

1. C++ STL库 -- map/set、mutil_map/mutil_set
2. Java 库
3. linux内核
4. 其他一些库

     在后面关于封装map和set的过程中，会再次用到红黑树的知识，因为STL底层的架子就是用的红黑树。


http://www.mrgr.cn/p/18875034

相关文章

WDS+MDT网络启动自动部署windows（十）硬盘分区格式化全自动

WDS+MDT网络启动自动部署windows（十）硬盘分区格式化全自动

简介： 虽然WDS+MDT在单硬盘很方便，但是各种大硬盘，小固态加大硬盘的地方，还是有若干不便之处。 如：第二块硬盘未分区格式化，需要手动选择安装磁盘，如果固态超过250G，是否需要分为两个区？ 自动选择较小的硬盘 目前我这里的终端都是小固态，大机械，那么我们要尝试一下自…
阅读更多...
AI图片

AI图片

阅读更多...
关于pdf.js中文本坐标尺寸的使用

关于pdf.js中文本坐标尺寸的使用

一个电子教材项目中有这样一个需求&#xff1a; 用户向网站上传一个PDF书籍后&#xff0c;网站可以对PDF书籍进行解析&#xff0c;并支持用户对PDF书籍的每一页做一些操作&#xff0c;比如&#xff1a;为英语课本的单词和句子添加音频热区。因为热区数量很多&#xff0c;所以&a…
阅读更多...
【数据库】MongoDB

【数据库】MongoDB

文章目录 [toc]数据库操作查询数据库切换数据库查询当前数据库删除数据库查询数据库版本 数据集合操作创建数据集合查询数据集合删除数据集合 数据插入插入id重复的数据 数据更新数据更新一条丢失其他字段保留其他字段 数据批量更新 数据删除数据删除一条数据批量删除 数据查询…
阅读更多...
Java面向对象03——三大特性之继承

Java面向对象03——三大特性之继承

一、继承（extends） 1.1、继承是什么 继承就是 Java 允许我们用 extends 关键字，让一个类与另一个类建立起一种父子关系； 被继承的类称为父类（基类、超类），继承父类的类都称为子类（派生类） ，当子类继承父类后，就可以直接使用父类公共的属性和方法了 当子类继承父类后…
阅读更多...
使用 Docker 部署 Nuxt.js 应用程序

使用 Docker 部署 Nuxt.js 应用程序

来源：https://medium.com/@jkpeyi/deploying-a-nuxt-js-application-with-docker-69bf822c066dWhen developing a Nuxt.js application, it’s essential to be able to deploy it easily and reproducibly. In this article, we will explore how to use Docker to deploy a …
阅读更多...
Rust中的函数指针

Rust中的函数指针

什么是函数指针 通过函数指针允许我们使用函数作为另一个函数的参数。函数的类型是 fn &#xff08;使用小写的 ”f” &#xff09;以免与 Fn 闭包 trait 相混淆。fn 被称为 函数指针&#xff08;function pointer&#xff09;。指定参数为函数指针的语法类似于闭包。 函数指…
阅读更多...
Rabbitmq系列02---Exchange

Rabbitmq系列02---Exchange

个人理解： 交换机的类型划分个人理解是能过routing key来划分的，一是否按routing key找队列；fanout就是不按routingkey找队列，Direct和Topicr按routingkey找队列，只是一个模糊找，一个精准找，而headers不按routingkey 是按消头中的内容找队列。 一、Fanout（订阅模式|广播…
阅读更多...
python之List列表

python之List列表

1. 高级数据类型 Python中的数据类型可以分为&#xff1a;数字型&#xff08;基本数据类型&#xff09;和非数字型&#xff08;高级数据类型&#xff09; 数字型包含&#xff1a;整型int、浮点型float、布尔型bool、复数型complex 非数字型包含&#xff1a;字符串str、列表l…
阅读更多...
陈畅亮搞的专利在Windows上利用加解密DLL模块对数据库连接字符串进行加解密

陈畅亮搞的专利在Windows上利用加解密DLL模块对数据库连接字符串进行加解密

陈畅亮搞的专利在Windows上利用加解密DLL模块对数据库连接字符串进行加解密这种专利权人是公司，个人是发明人，专利年费是申请人先垫付，然后公司报销了，这个专利本身就不属于员工的这个是公司是专利权人， 使用权是公司 ， 如果想要维持权利的话 ，需要缴纳年费 ，专利发明…
阅读更多...
[最新]CentOS7设置开机自启动Hadoop集群

[最新]CentOS7设置开机自启动Hadoop集群

安装好Hadoop后我们可以使用开机自启动的方式&#xff0c;节约敲命令的时间。注意是centOS7版本!!!和centOS6版本区别非常大!!! 1、切换到系统目录 [rootmaster ~]# cd /etc/systemd [rootmaster systemd]# ll total 32 -rw-r--r-- 1 root root 720 Jun 30 23:11 bootcha…
阅读更多...
19-项目干系人管理（10/10 十大管理）

19-项目干系人管理（10/10 十大管理）

17.1 管理基础 17.1.1 管理的重要性 每个项目干系人，他们会受到项目积极或消极的影响，或者能对项目施加积极或消极的影响。项目经理和团队管理干系人的能力决定着项目的成败。为提高项目成功的概率，尽早开始识别干系人并引导干系人参与。 干系人满意度应作为项目目标加以识别…
阅读更多...
基于Springboot的考研资讯平台

基于Springboot的考研资讯平台

基于SpringbootVue的考研资讯平台的设计与实现 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringbootMybatis工具&#xff1a;IDEA、Maven、Navicat 系统展示 用户登录 首页 考研资讯 报考指南 资料信息 论坛信息 后台登录 考研资讯管理 学生管理 资…
阅读更多...
滴水逆向 FileBuffer-ImageBuffer 课后作业

滴水逆向 FileBuffer-ImageBuffer 课后作业

1)- 实现如下功能 #include<stdio.h> #include<stdlib.h> #include<windows.h> BYTE* bufferApply nullptr;//将磁盘文件复制到内存中后, 使用bufferApply指向该空间 DWORD fileSize 0;//将磁盘文件复制到内存时使用需要申请空间, 使用fileSize设置申请空…
阅读更多...
17-项目风险管理（8/10 十大管理）

17-项目风险管理（8/10 十大管理）

15.1 管理基础 15.1.1 项目风险概述 项目风险是一种不确定的事件或条件，一旦发生，会对项目目标产生某种正面或负面的影响。项目风险既包括对项目目标的威胁，也包括促进项目目标的机会。 风险源于所有项目之中的不确定因素。项目在不同阶段会有不同的风险。风险会随着项目的进…
阅读更多...
18-项目采购管理（9/10 十大管理）

18-项目采购管理（9/10 十大管理）

16.1 管理基础 16.1.1 协议/采购合同 项目采购管理包括从项目团队外部采购或获取所需产品、服务或成果的各个过程。例如合同、订购单、协议备忘录（MOA）和服务水平协议（SLA）。被授权采购项目所需货物、服务的人员可以是项目团队、管理层或组织采购部的成员。 因应用领域不同…
阅读更多...
URL路由基础与Django处理请求的过程分析

URL路由基础与Django处理请求的过程分析

1. URL路由基础 对于高质量的Web应用来讲&#xff0c;使用简洁、优雅的URL设计模式非常有必要。Django框架允许设计人员自由地设计URL模式&#xff0c;而不用受到框架本身的约束。对于URL路由来讲&#xff0c;其主要实现了Web服务的入口。用户通过浏览器发送过来的任何请求&am…
阅读更多...
15-项目沟通管理（7/10 十大管理）

15-项目沟通管理（7/10 十大管理）

14.1 管理基础 14.1.1 沟通 沟通是指用各种可能的方式来发送或接收信息。具体形式包括：书面行驶、口头形式、正式或非正式、手势动作、媒体行驶、遣词造句。 14.1.2 沟通模型 关键要素包括：编码：把思想或想法转化为他人能理解的语言 信息和反馈信息 媒介 噪声 解码：把信息还…
阅读更多...
与 Apollo 共创生态：Apollo 七周年大会给带来的震撼

与 Apollo 共创生态：Apollo 七周年大会给带来的震撼

文章目录 一、七年蛰伏&#xff0c;Apollo 迎来“智变”时刻二、Apollo 企业生态计划与开放平台2.1 Apollo X 企业自动驾驶解决方案2.2 Apollo 开放平台携手伙伴共创生态 三、个人感悟 一、七年蛰伏&#xff0c;Apollo 迎来“智变”时刻 让我们把时间倒回到 2013 年&#xff0…
阅读更多...
13-项目质量管理（5/10 十大管理）

13-项目质量管理（5/10 十大管理）

12.1 管理基础 12.1.1 质量与项目质量 1.质量 国际标准定义：反映实体满足主体明确和隐含需求的能力的特性总和。 国家标准定义：一组固有特性满足要求的程度。 质量通常是指产品的质量，广义上的质量还包括工作质量。质量与等级是两个不同的概念。 质量作为实现的性能或成果；…
阅读更多...
推荐文章

Copyright @ 2022~2023