红黑树的删除

最新推荐文章于 2024-05-19 16:12:42 发布
最新推荐文章于 2024-05-19 16:12:42 发布
阅读量92 收藏
点赞数
分类专栏： stl源码剖析 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45157276/article/details/131278008
版权

二叉排序树的删除

参考文章

情况1

被删除的结点D是叶子结点：直接从二叉排序树当中移除即可，也不会影响树的结构

情况2

被删除的结点D仅有一个孩子：如果只有左孩子，没有右孩子，那么只需要把要删除结点的左孩子链接到要删除结点的父亲节点，然后删除D结点就好了；如果只有右孩子，没有左孩子，那么只要将要删除结点D的右孩子重接到要删除结点D的父亲结点。

情况3

被删除结点的左右孩子都存在：用被删除结点左子树的值最大的结点或右子树中值最小的结点替换要删除的结点的值，然后移除要删除的结点。

代码实现

struct node* deleteNode(struct node* root, int key)
{
 // 如为空，直接返回
 if (root == NULL) return root;

 // 如果删除的值小于 root 的值，则递归的遍历rootde左子树
 // 即删除结点位于左子树
 if (key < root->key)
  root->left = deleteNode(root->left, key);

 // 如果删除的值大于 root 的值，则递归的遍历root的右子树
 // 即删除结点位于右子树
 else if (key > root->key)
  root->right = deleteNode(root->right, key);

 // 如果值相等，则删除结点
 else
 {
  /*第一种情况可以包含在第二种当中，所以不做处理
   这里处理第二种情况*/

  //删除结点的左孩子为空
  if (root->left == NULL)
  {
   struct node *temp = root->right;
   if(root->key == 30){
                printf("%d\n",temp->key);
   }
   free(root);
   return temp;
  }
  else if (root->right == NULL)//删除结点的右孩子为空
  {
   struct node *temp = root->left;
   free(root);
   return temp;
  }

  // 左右孩子均不为空，获取删除结点中序遍历的直接后继结点 
  struct node* temp = minValueNode(root->right);

  // 将删除结点的值替换为直接后继结点的值
  root->key = temp->key;

  // 删除直接后继结点
  root->right = deleteNode(root->right, temp->key);

  /* 或者获取删除结点中序遍历的直接前驱结点。*/
  //struct node* temp = maxValueNode(root->left);
  // root->key = temp->key;
  //root->left = deleteNode(root->left, temp->key);

 }
 return root;
}

时间复杂度

二叉排序树的插入和查找、删除操作的最坏时间复杂度为 ，其中 h 是二叉排序树的高度。

红黑树的左旋和右旋操作

左旋

  • 先把旋转点x的右孩子x_r的左子树连接到旋转点的右子树
  • 再把旋转点x的的右孩子x_r及其右子树连接到x的父节点
  • 最后把旋转点x连接到x_r的左子树

在这里插入图片描述

代码如下：

//左旋操作
inline void __rb_tree_rotate_left(__rb_tree_node_base *x,__rb_tree_node_base *&root) {
    __rb_tree_node_base *x_r = x->right;
    x->right = x_r->left;
    if (x_r->left != 0) {               //情况1
        x_r->left->parent = x;
    }
    x_r->parent = x->parent;

    if (x == root) {
        root = x_r;
    } else if (x == x->parent->left) {
        x->parent->left = x_r;
    } else {
        x->parent->right = x_r;
    }
    x_r->left = x;
    x->parent = x_r;
}

右旋：

  • 先把旋转点x的左孩子x_l的左子树连接到旋转点的左子树
  • 再把旋转点x的的左孩子x_l及其左子树连接到x的父节点
  • 最后把旋转点x连接到x_l的右子树

在这里插入图片描述

源码为：

//右旋操作
inline void __rb_tree_rotate_right(__rb_tree_node_base *x, __rb_tree_node_base *&root) {
    __rb_tree_node_base *x_l = x->left;
    x->left = x_l->right;
    if (x_l->right != 0) {
        x_l->right->parent = x;
    }
    x_l->parent = x->parent;

    if (x == root) {
        root = x_l;
    } else if (x == x->parent->right) {
        x->parent->right = x_l;
    } else {
        x->parent->left = x_l;
    }
    x_l->right = x;
    x->parent = x_l;

}

红黑树的删除

首先我们假定要删除的结点为 y ，x 是用来替换 y 的孩子结点。当y是叶子结点时，x是NULL结点，NULL节点当作黑色结点处理。

删除操作总纲：

  1. 执行标准的 BST 的删除操作（上面的操作就是）
  2. 简单情况：x 或者 y 是红色（移除y后,把x标记为黑色）
  3. 复杂情况：x 和 y 都是黑色结点。

1.先执行标准的BST的删除操作

inline __rb_tree_node_base*
    _rb_tree_rebalance_for_erase(__rb_tree_node_base *z,
                                 __rb_tree_node_base *&root,
                                 __rb_tree_node_base *&leftmost,
                                 __rb_tree_node_base *&rightmost) {
    __rb_tree_node_base *y = z;             //要删除的节点
    __rb_tree_node_base *x = 0;             //要替换的节点
    __rb_tree_node_base *x_parent = 0;
    ///标准的二叉搜索树删除流程
    //要删除节点有一个子孩子的情况,直接用其子孩子替换
    if (y->left == 0) {
        x = y->right;
    } else {
        if (y->right == 0) {
            x = y->left;
        } else {           //要删除节点的左右孩子均有的情况
            y = y->right;
            while (y->left != 0) {              //找到右子树值最小的节点
                y = y->left;
            }       //循环结束时，y是右子树的最小节点，将用来替换z
            x = y->right;       //x可能是null
        }
    }

    //当y != z时，要删除的节点左右孩子均有
    if (y != z) {     //用y代替z，y是z的继任者，重新链接y。
        z->left->parent = y;        //因为上面替换的是右子树的最小值，有可能是z的右孩子,所以先把z的左子树连接到y
        y->left = z->left;
        if (y != z->right) {
            x_parent = y->parent;                   //后面移除y时用到
            if (x) {    //把y从原来的位置拿掉，用x替换，此时x_parent是y的父节点
                x->parent = y->parent;
            }
            y->parent->left = x;
            y->right = z->right;        //用y替换z
            z->right->parent = y;
        } else {       //y是z的右孩子，z的右子树只有这一个y节点
            x_parent = y;			
        }
        if (root = z) {		//用y来替换z
            root = y;
        } else if (z->parent->left = z) {
            z->parent->left = y;
        } else {
            z->parent->right = y;
        }
        y->parent = z->parent;
        mystl::swap(y->color, z->color);		//颜色也要替换
        y = z;          //y现在指向实际要删除的节点
    } else {       //y == z;   说明只有z结点只有一个子节点x,x要替换z,且有可能是最大值或最小值
        x_parent = y->parent;			
        if (x) {		//用x来替换y
            x->parent = y->parent;
        }
        if (root == y) {
            root = x;
        } else {
            if (y->parent->left == y) {
                y->parent->left = x;
            } else {
                y->parent->right = x;
            }								//x_parent是x的父节点
        }
        //更新header的指针
        if (leftmost == z) {            //如果z是最小值
            if (z->right == 0) {
                leftmost = z->parent;
            } else {
                leftmost = __rb_tree_node_base::minimum(x);
            }
        }
        if (rightmost == z) {
            if (z->left == 0) {
                rightmost = z->parent;
            } else {
                rightmost = __rb_tree_node_base::maximum(x);
            }
        }

    ...
}

上面的程序结束时

  • 要移除的节点y已经转移到红黑树的叶子节点
  • x节点已经完成了对y 节点的替换
  • x_parent指向x的父节点。

2.简单情况：x或者y是红色

移除y，把x标记为黑色

源码为：

if (__y->_M_color != _S_rb_tree_red) { 
    while (__x != __root && (__x == 0 || __x->_M_color == _S_rb_tree_black)){
    	...
    }
    if (x) x->color = __rb_tree_black;
}

3.复杂情况：x和y都是黑色结点。

在本文的示例中，y是要移除的节点，y没有左右子树，所以用空节点替换。y的位置实际上也是x。

a .y的兄弟结点 w 是红色结点

b.y 的兄弟结点 w 是黑色且 w 的两个孩子结点都是黑色

c.y 的兄弟结点 w 是黑色且 w 的孩子结点至少有一个是红色

d.兄弟节点w为黑，且w的左节点不存在或为黑，右节点为红

e.x是根节点的情况：直接返回y进行移除，从所有路径去除了一个黑色节点，而新根是黑色的，所以性质都保持着。

a. y 为黑，y的兄弟结点 w 是红色结点4

删除y之后，会破坏红黑树的条件4（任一节点至 NULL（树尾端）的任何路径，所含之黑节点数必须相同。）

  1. 对调兄弟节点w和x_parent的颜色
  2. 以x_parent为旋转节点进行右旋

完成以上两个操作后，尽管所有路径上黑色结点的树目并没有改变，但x有了一个黑色的兄弟和一个红色的父亲，接下来的情况按照b,c,d处理。

在这里插入图片描述

可以看出把y移除后，这个红黑树满足所有条件

对应源码：

while (x != root && (x == 0 || x->color == __rb_tree_black)) {          //x是要替换y的节点，满足该条件的x是双黑节点
    if (x == x_parent->left) {      //如果x是父节点的左孩子，
       ...
        //对于右节点的操作是对称的
    } else {
        __rb_tree_node_base *w = x_parent->left;       //w记录要删除节点的兄弟节点
        if (w->color == __rb_tree_red) {      //兄弟节点为父节点的右节点且为红，破坏了条件4，左旋
            w->color = __rb_tree_black;
            x_parent->color = __rb_tree_red;
            __rb_tree_rotate_right(x_parent, root);
            w = x_parent->left;
        }
        //兄弟节点为黑，且兄弟节点的左孩子和右孩子均为黑色，也对应上面的情况b
        if ((w->right == 0 || w->right->color == __rb_tree_black)
            && (w->left == 0 || w->left->color == __rb_tree_black)) {
            w->color = __rb_tree_red;
            x = x_parent;
            x_parent = x_parent->parent;        //之后递归的进行操作
        } 
} 
if (x) x->color = __rb_tree_black;
b. y 的兄弟结点 w 是黑色且 w 的两个孩子结点都是黑色

把w标记为红色，这样会满足条件4。但可能会出现父子节点都为红色的情况，需要递归的往上执行。

c.兄弟节点w为黑色，w的左子节点为红色或左右节点均为红色。

把w左孩子的颜色标记为为黑色，以x_parent为旋转点右旋即可。

在这里插入图片描述

源码为：

 while (x != root && (x == 0 || x->color == __rb_tree_black)) {          //x是要替换y的节点，满足该条件的x是双黑节点
    if (x == x_parent->left) {      //如果x是父节点的左孩子，
       ...
        //对于右节点的操作是对称的
    } else {
        __rb_tree_node_base *w = x_parent->left;       //w记录要删除节点的兄弟节点
        if (w->color == __rb_tree_red) {      //兄弟节点为父节点的右节点且为红，破坏了条件4，左旋
            w->color = __rb_tree_black;
            x_parent->color = __rb_tree_red;
            __rb_tree_rotate_right(x_parent, root);
            w = x_parent->left;
        }
        //兄弟节点为黑，且兄弟节点的左孩子和右孩子均为黑色，也对应上面的情况b
        if ((w->right == 0 || w->right->color == __rb_tree_black)
            ...
        }else {
          if (__w->_M_left == 0 || 
              __w->_M_left->_M_color == _S_rb_tree_black) {
              ...
          }
          __w->_M_color = __x_parent->_M_color;
          __x_parent->_M_color = _S_rb_tree_black;
          if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
          _Rb_tree_rotate_right(__x_parent, __root);
          break;
        } 
} 
if (x) x->color = __rb_tree_black;
d. 兄弟节点w为黑，且w的左节点不存在或为黑，右节点为红

对调w和其右孩子的颜色，然后以w为旋转点右旋。得到情况c。根据情况c操作即可。

在这里插入图片描述

源码为：

while (x != root && (x == 0 || x->color == __rb_tree_black)) {          //x是要替换y的节点，满足该条件的x是双黑节点
    if (x == x_parent->left) {      //如果x是父节点的左孩子，
       ...
        //对于右节点的操作是对称的
    } else {
        __rb_tree_node_base *w = x_parent->left;       //w记录要删除节点的兄弟节点
        if (w->color == __rb_tree_red) {      //兄弟节点为父节点的右节点且为红，破坏了条件4，左旋
            w->color = __rb_tree_black;
            x_parent->color = __rb_tree_red;
            __rb_tree_rotate_right(x_parent, root);
            w = x_parent->left;
        }
        //兄弟节点为黑，且兄弟节点的左孩子和右孩子均为黑色，也对应上面的情况b
        if ((w->right == 0 || w->right->color == __rb_tree_black)
            ...
        }else {
          if (__w->_M_left == 0 || 
              __w->_M_left->_M_color == _S_rb_tree_black) {
            if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
            __w->_M_color = _S_rb_tree_red;
            _Rb_tree_rotate_left(__w, __root);
            __w = __x_parent->_M_left;
          }
          __w->_M_color = __x_parent->_M_color;
          __x_parent->_M_color = _S_rb_tree_black;
          if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
          _Rb_tree_rotate_right(__x_parent, __root);
          break;
        } 
} 
if (x) x->color = __rb_tree_black;

完整的删除源码：

///erase
template<class Key, class Value, class KeyOfValue, class Compare, class Alloc>
    inline void _rb_tree<Key, Value, KeyOfValue, Compare, Alloc>
    ::erase(iterator position) {
        link_type y = (link_type) _rb_tree_rebalance_for_erase(position.node,
                                                               header->parent,
                                                               header->left,
                                                               header->right);
        destroy_node(y);        //y为能安全删除的节点
        --node_count;
    }
inline __rb_tree_node_base 
    *_rb_tree_rebalance_for_erase(__rb_tree_node_base *z,
                                  __rb_tree_node_base *&root,
                                  __rb_tree_node_base *&leftmost,
                                  __rb_tree_node_base *&rightmost) {
    __rb_tree_node_base *y = z;             //要删除的节点
    __rb_tree_node_base *x = 0;             //要替换的节点
    __rb_tree_node_base *x_parent = 0;
    ///标准的二叉搜索树删除流程
    //要删除节点有一个子孩子的情况
    if (y->left == 0) {
        x = y->right;
    } else {
        if (y->right == 0) {
            x = y->left;
        } else {           //要删除节点的左右孩子均有的情况
            y = y->right;
            while (y->left != 0) {              //找到右子树值最小的节点
                y = y->left;
            }       //循环结束时，y是右子树的最小节点，将用来替换z
            x = y->right;       //x可能是null
        }
    }

    //当y != z时，要删除的节点左右孩子均有
    if (y != z) {     //用y代替z，y是z的继任者，重新链接y。
        z->left->parent = y;        //因为上面替换的是右子树的最小值，有可能是z的右孩子,所以先把z的左子树连接到y
        y->left = z->left;
        if (y != z->right) {
            x_parent = y->parent;                   //后面移除y时用到
            if (x) {    //要把y的右子树连接到y的父节点
                x->parent = y->parent;
            }
            y->parent->left = x;
            y->right = z->right;        //用y替换z
            z->right->parent = y;
        } else {       //y是z的有孩子
            x_parent = z;
        }
        if (root = z) {
            root = y;
        } else if (z->parent->left = z) {
            z->parent->left = y;
        } else {
            z->parent->right = y;
        }
        y->parent = z->parent;
        mystl::swap(y->color, z->color);
        y = z;          //y现在指向实际要删除的节点
    } else {       //y == z;   说明只有z结点只有一个子节点x,x要替换z,且有可能是最大值或最小值
        x_parent = y->parent;
        if (x) {
            x->parent = y->parent;
        }
        if (root == z) {
            root = x;
        } else {
            if (z->parent->left == z) {
                z->parent->left = x;
            } else {
                z->parent->right = x;
            }
        }
        //更新header的指针
        if (leftmost == z) {            //如果z是最小值
            if (z->right == 0) {
                leftmost = z->parent;
            } else {
                leftmost = __rb_tree_node_base::maximum(x);
            }
        }
        if (rightmost == z) {
            if (z->left == 0) {
                rightmost = z->parent;
            } else {
                rightmost = __rb_tree_node_base::maximum(x);
            }
        }

    }//经过标准的二叉树删除处理后，y指向要删除的节点，且有x_parent指向y节点的父节点

    if (y->color != __rb_tree_red) {      //y为黑，移除会破坏了红黑树的条件4
        while (x != root && (x == 0 || x->color == __rb_tree_black)) {          //x是要替换y的节点，满足该条件的x是双黑节点
            if (x == x_parent->left) {      //如果x是父节点的左孩子，
                __rb_tree_node_base *w = x_parent->right;       //w记录要删除节点的兄弟节点
                if (w->color == __rb_tree_red) {      //兄弟节点为父节点的右节点且为红，破坏了条件4，左旋
                    w->color = __rb_tree_black;
                    x_parent->color = __rb_tree_red;
                    __rb_tree_rotate_left(x_parent, root);
                    w = x_parent->right;
                }
                //兄弟节点为黑，且兄弟节点的左孩子和右孩子均为黑色
                if ((w->left == 0 || w->left->color == __rb_tree_black)
                    && (w->right == 0 || w->right->color == __rb_tree_black)) {
                    w->color = __rb_tree_red;
                    x = x_parent;
                    x_parent = x_parent->parent;        //之后递归的进行操作
                } else {
                    //兄弟节点的子节点有一个是红色
                    if (w->right == 0 || w->right->color == __rb_tree_black) {      //如果左子节点是红，内侧，先右旋再左旋
                        if (w->left) w->left->color = __rb_tree_black;
                        w->color = __rb_tree_red;
                        __rb_tree_rotate_right(w, root);
                        w = x_parent->right;
                    }

                    // 右节点为红
                    w->color = x_parent->color;
                    x_parent->color = __rb_tree_black;
                    if (w->right) w->right->color = __rb_tree_black;
                    __rb_tree_rotate_left(x_parent, root);
                    break;
                }
                //对于右节点的操作是对称的
            } else {
                __rb_tree_node_base *w = x_parent->left;       //w记录要删除节点的兄弟节点
                if (w->color == __rb_tree_red) {      //兄弟节点为父节点的右节点且为红，破坏了条件4，左旋
                    w->color = __rb_tree_black;
                    x_parent->color = __rb_tree_red;
                    __rb_tree_rotate_right(x_parent, root);
                    w = x_parent->left;
                }
                //兄弟节点为黑，且兄弟节点的左孩子和右孩子均为黑色
                if ((w->right == 0 || w->right->color == __rb_tree_black)
                    && (w->left == 0 || w->left->color == __rb_tree_black)) {
                    w->color = __rb_tree_red;
                    x = x_parent;
                    x_parent = x_parent->parent;        //之后递归的进行操作
                } else {
                    //兄弟节点的子节点有一个是红色
                    if (w->left == 0 || w->left->color == __rb_tree_black) {      //如果兄弟节点的右子节点是红，内侧，先左旋再右旋
                        if (w->right) w->right->color = __rb_tree_black;
                        w->color = __rb_tree_red;
                        __rb_tree_rotate_left(w, root);
                        w = x_parent->left;
                    }

                    // 右节点为红
                    w->color = x_parent->color;
                    x_parent->color = __rb_tree_black;
                    if (w->left) w->left->color = __rb_tree_black;
                    __rb_tree_rotate_right(x_parent, root);
                    break;
                }
            }
        }
        if (x) x->color = __rb_tree_black;

    }
    return y;

}
路_安
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树生成删除
07-04
红黑树在线生成的一个工具，从网上找的，我这样应该得不到分。大哭https://www.cnblogs.com/bbvi/p/5576201.html 删除可能存在问题，替换节点的兄弟节点为黑色节点时有问题，其他部分是没有问题的，凑合着看看
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 16万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
红黑树删除操作的各种情况分析
马小超
12-07 1260
目录 删除情况具体分析 1. 删除的节点没有子节点的情况 2. 删除的节点只有一个子节点时 3. 如果删除节点有两个子节点时 红黑树删除平衡情况分析 红黑书的删除本质上是一个穷举的过程。 删除情况具体分析 1. 删除的节点没有子节点的情况  a、如果为红色，直接删除即可，不会影响黑色节点的数量   删除红色节点（13）示例（不影响黑色节点数量，不需要平衡操作）  b、如果为黑色，删除的时候需要进行平衡操作   删除示例，删除节点11（平衡操作后面会介绍到） 2. 删除的节点只有一个子..
C++红黑树
~
03-26 6401
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树删除
weixin_43868793的博客
03-01 297
文章目录简介删除1 叶子2 独子 简介 https://blog.csdn.net/weixin_43868793/article/details/123114745 删除 1 叶子 如果欲删除的结点是一个叶子结点，即结点没有孩子，直接删除即可 2 独子 如果欲删除的结点只有一个子结点，那么子结点的值直接覆盖上来，再 ...
红黑树插入删除的平衡操作
03-17
红黑树插入，删除时各种状态的平衡操作。
红黑树demo python代码
07-12
该资源是一个红黑树的demo程序，包含了红黑树的插入和红黑树的删除过程，实现方式相对比较简单明了，适合于刚刚接触红黑树的入门者阅读。
数据结构之红黑树详解
12-31
在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。它是复杂的，但它的操作有着良好的最坏情况运行...
红黑树的插入与删除_详细整理资料
02-25
红黑树的插入与删除_详细整理资料
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 625
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
C语言.动态内存管理
Joseit的博客
05-16 592
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
【C++风云录】打破边界：心理学与情绪识别
记录我的学习历程
05-16 707
本文主要探讨了六种开发软件工具包，包括但不限于面部表情分析、心理学实验设计、图像处理、数据挖掘、情绪识别以及生物识别技术等各类关键功能，同时也涵盖了其在各自领域的应用。
文件操作（C语言）
最新发布
2303_76654613的博客
05-19 632
文件 = 文件内容 + 文件属性在程序设计中，文件分为程序文件和数据文件。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 409
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 662
对于类类型，如果定义了接受。
【C++】＜知识点＞ 类的大小计算
致力于Linux的博客
05-18 122
C++中使用sizeof计算类大小的内在说明。
4 软件定义安全综合：使用c/s模式进行控制器数据安全交互管理
qq_28938301的博客
05-15 340
本文将展示控制器与应用层如何通信编写的控制器为例子（packet_statics.py）结合mininet模块创建的网络拓扑（3_2_topo.py），然后在另外一个应用程序中开启数据收集（另外一个应用进程app_server.py），获取在SDN环境中每次通信的dpid和port，并传输给应用层（app_server.p）实际上就是解决：ryu控制器如何实现与应用层(如web、app等)的通信，利用SDN的北向接口的功能就是和其他软件实体之间的通信。
C++并发：构建线程安全的队列
[email protected]的博客
05-15 394
在 threadsafe_queue 的拷贝构造函数中，尽管传入的 other 对象是一个 const 引用，我们仍然需要从这个 const 对象中复制数据。拷贝构造函数需要访问 other 对象的 data_queue，而为了线程安全，必须先锁定 other 的互斥量。由于 mut 是 mutable 的，即使在 const 上下文中，也能执行锁定操作。
红黑树删除 java
09-08
下面是一个简单的红黑树删除的 Java 实现示例： ```java public class RedBlackTree { private Node root; // 其他代码... public void delete(int value) { Node node = search(root, value); if (node != ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值