• 二叉搜索树【理论+代码】

    二叉搜索树


    在这里插入图片描述

    • 前言：本文会详细介绍二叉搜索树的概念，对二叉搜索树的操作进行了画图讲解，对二叉搜索树的两种模型以及应用作了介绍，最终对二叉搜索树的性能进行了分析.

    🏝️1.二叉搜索树概念

    在学习二叉搜索树之前，我们先温习一下二叉树的概念：所谓二叉树，其意义是：“任何节点最多只允许有两个子节点”，这两个子节点称为左子节点和右子节点.如果以递归方式来定义二叉树，我们可以说：“一个二叉树如果不为空，便是由一个根节点和左右两子树构成，左右两子树都可能为空”.

    那么，由此我们引入二叉搜索树（又称二叉排序树），它要么是一棵空树，要么是一棵具有以下性质的二叉树：

    • 若它的左子树不为空，那么它左子树任意一个节点的值都小于根结点的值
    • 若它的右子树不为空，那么它右子树任意一个节点的值都大于根节点的值
    • 它的左右子树分别为一棵二叉搜索树

    比如，如图这样一棵树，就是一棵二叉搜索树：

    在这里插入图片描述
    它的左右子树分别也是二叉搜索树
    在这里插入图片描述

    仔细观察一下我们会发现，对于一棵二叉搜索树，它的中序遍历的结果恰好是有序的.所以对于二叉搜索树，它不仅具有搜索的功能，也是能够做到排序的.

    🏠2.二叉搜索树的操作

    ⛰️2.1 二叉搜索树的查找

    对于二叉搜索树，我们最先需要学习的操作就是二叉搜索树的查找，因为对于更复杂的插入和删除操作都是需要用到查找的思想的.
    在这里插入图片描述
    例如，对于这样一棵二叉搜索树，我们怎样去实现它的查找呢？

    由上述二叉搜索树的性质，查找操作其实是比较容易的，对于我们要查找的值，从根结点开始，进行比较，当前要查找的值大于当前节点的值，就往当前节点的右子树走，若查找的值小于当前节点的值，就往当前节点的左子树走.，如果相等，就是找到了.

    在这里插入图片描述
    那么，如果走到了nullptr还没有返回，那就是没有找到.

    下面我们用代码实现一下：

    //节点定义
    template<class K>
    struct BSTreeNode
    {
        BSTreeNode(const K& key = K())
            : _key(key)
            , _left(nullptr)
            , _right(nullptr)
        {}

        BSTreeNode<K>* _left;
        BSTreeNode<K>* _right;
        K _key;    
    };
//树的基本框架
template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
protected:
	Node* _root = nullptr;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    //查找操作
bool find(const K& val)
{
     Node* cur = _root;

     while (cur)
     {
         //查找的值 < 当前节点的值 -> 向当前节点的左子树走
         if (cur->_key > val)
         {
             cur = cur->_left;
         }
         else if (cur->_key < val) //查找的值 > 当前节点的值 -> 向当前节点的右子树走
         {
             cur = cur->_right;
         }
         else
         {
             //找到了
             return true;
         }
     }

     return false; 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    🏞️2.2 二叉搜索树的插入

    要对一棵二叉搜索树进行插入，有许多种情况：

    1. 当这棵树是空树
      当这棵树还是一棵空树时，也就是_root为nullptr，那我们只需要创建一个新的节点，与_root进行链接就可以
    1. 这棵树不为空树
      当这棵树不为空树时，我们就需要根据二叉搜索树的性质，从根结点开始，如果要插入的值大于当前节点的值，就往当前节点的右子树走，若要插入的值小于当前节点的值，就往当前节点的左子树走.直到指向当前节点的指针为nullptr，就停止搜索.

    注意：由于最终指向节点的指针会走到空，所以我们还需要定义一个parent指针来记录当前节点的父节点

    最终我们只需要将新节点链接在搜索完成后的parent指针的左边或者右边即可.

    在这里插入图片描述

    当最终插入节点时，我们可以将parent指向的节点的值与需要插入的值相比较，如果parent->_key > 要插入的值就链接在parent的左边，反之链接在右边.

    可以看到，我们在进行处理时，如果插入节点的值与搜索树中其中一个节点的值相同，我们会返回false，这是因为，二叉搜索树一般是用来查找的，所以我们一般不插入重复值.

    代码如下：

    bool insert(const K& key)
{
    if (_root == nullptr)
    {
        _root = new Node(key);
        return true;
    }

    Node* cur = _root;
    Node* parent = nullptr;

    Node* newnode = new Node(key);

    while (cur)
    {
        if (cur->_key > key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else if (cur->_key < key)
        {
            parent = cur;
            cur = cur->_right;
        }
        else
        {
            return false;
        }
    }

    if (parent->_key > key)
    {
        parent->_left = newnode;
    }
    else
    {
        parent->_right = newnode;
    }

    return true;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    为了观察我们插入后的结果是否正确，由于我们知道二叉搜索树的中序遍历是有序的.所以我们可以写一个中序遍历来观察结果是否为有序从而判断插入的正确性.

    Java 实现二叉搜索树的查找、插入、删除、遍历
    pdf 0星 超过10%的资源 108KB
    下载
    public:
//给用户的接口
void InOrder()
{
    _InOrder(_root);
}
protected:
//内部实现递归的接口
void _InOrder(Node* root)
{
    if (root)
    {
        _InOrder(root->_left);
        std::cout << root->_key << " ";
        _InOrder(root->_right);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    🏜️2.3 二叉搜索树的删除

    二叉搜索树的删除是这些操作中最为复杂的一个，因为它有多种情况.

    首先，我们要删除这个节点，那第一步我们得先找到这个节点，然后再谈及对它的删除，如果这个节点不存在，返回false，如果找到了这个节点，那我们删除时会有下面四种情况：

    1. 要删除的节点无孩子节点

    2. 要删除的节点只有左孩子节点

    3. 要删除的节点只有右孩子节点

    4. 要删除的节点的左孩子和右孩子节点都存在

    但实际上，对于第一种情况，我们可以合并到第二种或第三种情况中，因为第一种情况时左右孩子都为nullptr，所以可以当作第二种或者第三种来处理，所以最终总结起来就只有三种情况：

    1. 删除该节点且使被删除节点的父节点指向被删除节点的左孩子节点
    2. 删除该节点且使被删除节点的父节点指向被删除节点的右孩子节点
    3. 找到该节点的右子树中最小值的节点，将它的值与找到的需要删除的节点的值进行交换，然后转换为删除这个最小值节点.

    我们先来看第2,3种情况：

    在这里插入图片描述
    接下来我们进行删除：
    在这里插入图片描述
    第三种情况与这个类似.

    我们着重来讲解第四种情况：
    在这里插入图片描述

    在这里插入图片描述

    代码如下：

    bool erase(const K& val)
{
    Node* cur = _root;
    Node* parent = nullptr;

    while (cur)
    {
        if (cur->_key < val)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_key > val)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            if (cur->_left == nullptr)
            {
                if (cur == _root)
                {
                    _root = cur->_right;
                }

                if (cur == parent->_left)
                {
                    parent->_left = cur->_right;
                }
                else
                {
                    parent->_right = cur->_right;
                }

                delete cur;
            }
            else if (cur->_right == nullptr)
            {
                if (cur == _root)
                {
                    _root = cur->_left;
                }

                if (cur == parent->_left)
                {
                    parent->_left = cur->_left;
                }
                else
                {
                    parent->_right = cur->_left;
                }

                delete cur;
            }
            else
            {
                Node* minParent = cur;
                Node* minRight = cur->_right;

                while (minRight->_left)
                {
                    minParent = minRight;
                    minRight = minRight->_left;
                }

                cur->_key = minParent->_key;

                if (minRight == minParent->_left)
                {
                    minParent->_left = minParent->_right;
                }
                else
                {
                    minParent->_right = minParent->_right;
                }

                delete minRight;
                minRight = nullptr;

            }

            return true;
        }
    }

    return false;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    if (cur == _root)
{
    _root = cur->_right;
}

    • 1
    • 2
    • 3
    • 4

    上面有这样几句代码，我来解释一下它是为了防止这种情况的发生：

    在这里插入图片描述

    这就是二叉搜索树的删除操作.

    acm二叉搜索树参考代码
    zip 0星 超过10%的资源 17KB
    下载

    🏖️3. 二叉搜索树的应用

    1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
      比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：以单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
    2. KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方式在现实生活中非常常见：比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是就构成一种键值对。

    下面，我用KV模型来写代码来举个例子：

    //KV模型的节点定义
template<class K, class V>
struct BSTreeNode
{
    BSTreeNode(const K& key = K(), const V& val = V())
        : _key(key)
        , _val(val)
        , _left(nullptr)
        , _right(nullptr)
    {}

    BSTreeNode<K,V>* _left;
    BSTreeNode<K,V>* _right;
    K _key;
    V _val;
    
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    #include"BSTree.h"
using namespace std;

int main()
{
    //KV模型的二叉搜索树,存两个值
	stl::BSTree<string, string> dict;

	dict.insert("钥匙", "key");
	dict.insert("月亮", "moon");
	dict.insert("团队", "team");
	dict.insert("工人", "worker");

	string _str;
	
	while (cin >> _str)
	{
	    //KV，模型中,由于我们可能需要修改value,所以返回节点的指针
		auto ret = dict.find(_str);

		if (ret != nullptr)
		{
			cout << ret->_val << endl;
		}
		else
		{
			cout << "查询不到此单词" << endl;
		}
	}

	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    运行这段代码就可以实现我们英汉词典的功能.
    运行结果如下：
    在这里插入图片描述

    🗻4. 二叉搜索树的性能分析

    插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

    对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

    但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

    在这里插入图片描述
    最优情况下，二叉搜索树为像左边这样的完全二叉树，其平均比较次数为： log ⁡ 2 N \log_2^N log2N​

    最差情况下，二叉搜索树退化为像右边这样的单支树，其平均比较次数为： N 2 \frac{N}{2} 2N​

    所以二叉搜索树查找的时间复杂度也就是O(N)

    本文对二叉搜索树的操作均为非递归实现，递归实现我会在下一篇文章中讲解.随后会附上链接.

    KV模型完整代码：

    //这是文章中提到的KV模型的完整代码,文章中是以K模型
#include

namespace stl
{
  template<class K>
  struct BSTreeNode
  {
    BSTreeNode(const K& key)
      : _key(key)
      , _left(nullptr)
      , _right(nullptr)
    {}

    BSTreeNode<T>* _left;
    BSTreeNode<T>* _right;
    K _key;
  };


  template<class K>
  class BSTree
  {
    typedef BSTreeNode<K> Node;

    Node* CopyTree(Node* root)
    {
      if(root == nullptr)
      {
        return nullptr;
      }

      Node* CopyNode = new Node(root->_key);
      CopyNode->_left = CopyTree(root->_left);
      CopyNode->_right = CopyTree(root->_right);

      return CopyNode;
    }

    void Destroy(Node* root)
    {
      if(root != nullptr)
      {
         Destroy(root->_left);
         Destroy(root->_right);

         delete root;
      }
    }

    public:
    //因为提供了拷贝构造后,编译器不再生成默认构造
      BSTree() = default;

      BSTree(const BSTree<K>& bst)
      {
         _root = CopyTree(bst._root);
      }

      BSTree<K>& operator=(BSTree<K> bst)
      {
        std::swap(_root, bst._root);

        return *this;
      }

      ~BSTree()
      {
        Destroy(_root);

        _root = nullptr;
      }



      bool insert(const K& val)
      {

        if(_root == nullptr)
        {
          _root = new Node(val);
          return true;
        }

        Node* cur = _root;
        Node* parent = nullptr;

        Node* newnode = new Node(val);

        while(cur)
        {
          if(cur->_key > val)
          {
            parent = cur;
            cur = cur->_left;
          }
          else if(cur->_key < val)
          {
            parent = cur;
            cur = cur->_right;
          }
          else
          {
            return false;
          }
        }

        if(parent->_key > val)
        {
          parent->_left = newnode;
        }
        else
        {
          parent->_right = newnode;
        }

        return true;
      }

      void InOrder()
      {
        _InOrder(_root);
        std::cout<<std::endl;
      }

      bool find(const K& val)
      {
        Node* cur = _root;

        while(cur)
        {
          if(cur->_key > val)
          {
            cur = cur->_left;
          }
          else if(cur->_key < val)
          {
            cur = cur->_right;
          }
          else
          {
            return true;
          }

          return false;
        }
      }

      bool erase(const K& val)
      {
        Node* cur = _root;
        Node* parent = nullptr;

        while(cur)
        {
          if(cur->_key < val)
          {
            parent = cur;
            cur = cur->_right;
          }
          else if(cur->_key > val)
          {
            parent = cur;
            cur = cur->_left;
          }
          else 
          {
            if(cur->_left == nullptr)
            {
              if(cur == _root)
              {
                _root = cur->_right;
              }
              
              if(cur == parent->_left)
              {
                parent->_left = cur->_right;
              }
              else 
              {
                parent->_right = cur->_right;
              }

              delete cur; 
            }
            else if(cur->_right == nullptr)
            {
              if(cur == _root)
              {
                _root = cur->_left;
              }

              if(cur == parent->_left)
              {
                parent->_left = cur->_left;
              }
              else 
              {
                parent->_right = cur->_left;
              }

              delete cur;
            }
            else 
            {
              Node* minParent = cur;
              Node* minRight = cur->_right;

              while(minRight->_left)
              {
                minParent = minRight;
                minRight = minRight->_left;
              }

              cur->_key = minParent->_key;

              if(minRight == minParent->_left)
              {
                minParent->_left = minParent->_right;
              }
              else 
              {
                minParent->_right = minParent->_right;
              }

              delete minRight;
              minRight = nullptr;

            }

            return true;
          }
        }           

        return false;

      }

      //递归版本
      //本文中还没有讲解递归的代码实现,但先将代码附上,大家可以先看一看
      bool FindR(const K& val)
      {
        return _FindR(_root, val);
      }

      bool InsertR(const K& val)
      {
        return _InsertR(_root, val);
      }

      bool EraseR(const K& val)
      {
        return _EraseR(_root, val);
      }


        
    protected:

      bool _FindR(Node* root, const K& val)
      {
          if(root == nullptr)
          {
            return false;
          }

          if(root->_key == val)
          {
            return true;
          }

          if(root->_key < val)
          {
            return _FindR(root->_right, val);
          }
          else if(root->_key > val)
          {
            return _FindR(root->_left, val);
          }

      }

      bool _InsertR(Node*& root, const K& val)
      {
        if(root == nullptr)
        {
          root = new Node(val);

          return true;
        }

        if(root->_key > val)
        {
          return _InsertR(root->_left, val);
        }
        else if(root->_key < val)
        {
          return _InsertR(root->_right, val);
        }
        else 
        {
          return false;
        }
      }

      bool _EraseR(Node*& root, const K& val)
      {
        if(root == nullptr)
        {
          return false;
        }

        if(root->_key > val)
        {
          return _EraseR(root->_left, val);
        }
        else if(root->_key < val)
        {
          return _EraseR(root->_right, val);
        }
        else 
        {
          //记录要删除的节点
          Node* del = root;

          if(root->_left == nullptr)
          {
            root = root->_right;
          }
          else if(root->_right == nullptr)
          {
            root = root->_left;
          }
          else 
          {
            Node* minRight = root->_right;
            while(minRight->_left)
            {
              minRight = minRight->_left;
            }

            std::swap(root->_key, minRight->_key);

            return _EraseR(root->_right, val);
          }

          delete del;
          del = nullptr;

          return true;
        }

      }


      void _InOrder(Node* root)
      {
        if(root)
        {
           _InOrder(root->_left);
           std::cout<<root->_key<<" ";
           _InOrder(root->_right);
        }
      }

      Node* _root = nullptr;
  };
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
    • 367
    • 368
    • 369
    • 370
  • 相关阅读:
    分布式Session解决方案
    MySQL数据库备份与还原批处理脚本
    【夜读】让自己更幸福的8件小事
    SpringBoot+Mybatis+Thymeleaf实现垃圾分类系统
    【设计模式】第2节：七大设计原则
    防抖跟节流
    TEASEL: A transformer-based speech-prefixed language model
    在Linux上安装Zookeeper集群(zookeeper-3.5.9)
    Lesson5-2:OpenCV视频操作---视频追踪
    C++——stack和queue
  • 原文地址：https://blog.csdn.net/smf12138/article/details/126092714