[TOC] > 这次创建的树节点只有value,没有包含key值,将在下次实现 # 二叉搜索树节点结构 ``` template<typename T> struct node { T data; struct node *lChild; node<T> *rChild; node<T> *parent; struct node() :lChild(nullptr), rChild(nullptr), parent(nullptr) {} struct node(const struct node<T> &n) :data(n.data), lChild(n.lChild), rChild(n.rChild), parent(n.parent) {} struct node(T d,node<T> *l,node<T> *r,node<T> *p) :data(d),lChild(l),rChild(r),parent(p){} }; ``` # 二叉搜索树的各种函数声明 ``` template<typename T> class BSTree { typedef struct node<T> TNode; typedef TNode *PNode; public: BSTree() :_root(nullptr) {} BSTree(T d) :_root(nullptr) { insert(d); } //使用vector构建二叉树 BSTree(const std::vector<T> &v); //使用list构建二叉树 BSTree(const std::list<T> &l); ~BSTree(); //插入节点 void insert(const T &d); //是否为空 bool empty(); //前序遍历 void preOrder() const; //中序遍历 void inOrder() const; //后序遍历 void postOrder() const; //清除树 void clear(); //查找 node<T>* search(const T &d) const; //二叉搜索树大小 size_t size() const; //最小值 T min(); //最大值 node<T>* max(); //是否包含d元素 bool contain(const T &d); //广度优先遍历 void levelOrder() const; //删除最小值 void removeMin(); //删除最大值 void removeMax(); //删除随机值 void erase(const T &d); //私有函数 private: void insert(PNode &n, PNode &newNode); void preOrder(const PNode &root) const; void inOrder(const PNode &root) const; void postOrder(const PNode &root) const; void clear(PNode &root); node<T>* search(const PNode &root, const T &d) const; size_t size(const PNode &root) const; node<T>* min(const PNode &root) const; node<T>* max(const PNode &root) const; bool contain(const PNode &root, const T &d); void levelOrder(const PNode &root); node<T>* removeMin(node<T>* root); node<T>* removeMax(node<T>* root); node<T>* erase(node<T>* root, const T &d); private: //根节点 PNode _root; }; ``` # 函数实现 ``` template<typename T> inline BSTree<T>::BSTree(const std::vector<T>& v):_root(nullptr) { for(auto &d:v) insert(d); } template<typename T> inline BSTree<T>::BSTree(const std::list<T>& l):_root(nullptr) { for (auto &d : l) insert(d); } template<typename T> inline BSTree<T>::~BSTree() { clear(); } template<typename T> inline void BSTree<T>::insert(const T &d) { PNode newNode = new node<T>(d, nullptr, nullptr, nullptr); newNode->data = d; if (_root == NULL) _root = newNode; else insert(_root, newNode); } template<typename T> inline bool BSTree<T>::empty() { return _root == nullptr; } template<typename T> inline void BSTree<T>::preOrder() const { preOrder(_root); } template<typename T> inline void BSTree<T>::inOrder() const { inOrder(_root); } template<typename T> inline void BSTree<T>::postOrder() const { postOrder(_root); } template<typename T> inline void BSTree<T>::clear() { clear(_root); } template<typename T> inline node<T>* BSTree<T>::search(const T & d) const { return PNode(_root,d); } template<typename T> inline size_t BSTree<T>::size() const { return size(_root); } template<typename T> inline T BSTree<T>::min() { return min(_root)->data; } template<typename T> inline T BSTree<T>::max() { return max(_root)->data; } template<typename T> inline bool BSTree<T>::contain(const T & d) { return contain(_root, d); } template<typename T> inline void BSTree<T>::levelOrder() const { levelOrder(_root); } template<typename T> inline void BSTree<T>::removeMin() { if (_root) _root = removeMin(_root); } template<typename T> inline void BSTree<T>::removeMax() { if (_root) _root = removeMax(_root); } template<typename T> inline void BSTree<T>::erase(const T & d) { if (_root != nullptr) erase(_root, d); } template<typename T> inline void BSTree<T>::insert(PNode &n, PNode &newNode) { if (newNode == nullptr) return; if (n->data > newNode->data) { if (n->lChild == nullptr) { n->lChild = newNode; n->lChild->parent = n; } else insert(n->lChild, newNode); } else { if (n->rChild == nullptr) { n->rChild = newNode; n->rChild->parent = n; } else insert(n->rChild, newNode); } } template<typename T> inline void BSTree<T>::preOrder(const PNode & root) const { if (root != nullptr) { cout << root->data << " "; preOrder(root->lChild); preOrder(root->rChild); } } template<typename T> inline void BSTree<T>::inOrder(const PNode & root) const { if (root != nullptr) { inOrder(root->lChild); cout << root->data << " "; inOrder(root->rChild); } } template<typename T> inline void BSTree<T>::postOrder(const PNode & root) const { if (root != nullptr) { postOrder(root->lChild); postOrder(root->rChild); cout << root->data << " "; } } template<typename T> inline void BSTree<T>::clear(PNode & root) { if (root != nullptr) { clear(root->lChild); clear(root->rChild); delete root; root = nullptr; } } template<typename T> inline node<T>* BSTree<T>::search(const PNode &root, const T & d) const { if (root == nullptr) return nullptr; if (root->data == d) return root; if (root->data > d) return search(root->lChild, d); else return search(root->rChild, d); } template<typename T> inline size_t BSTree<T>::size(const PNode & root) const { if (root == nullptr) return 0; else return size(root->lChild) + 1 + size(root->rChild); } template<typename T> inline node<T>* BSTree<T>::min(const PNode & root) const { PNode p = root; while (p->lChild != nullptr) p = p->lChild; return p; } template<typename T> inline node<T>* BSTree<T>::max(const PNode & root) const { PNode p = root; while (p->rChild != nullptr) p = p->rChild; return p; } template<typename T> inline bool BSTree<T>::contain(const PNode & root, const T & d) { if (root->data == d) return true; if (root == nullptr) return false; if (root->data > d) return contain(root->lChild, d); else return contain(root->rChild, d); } template<typename T> inline void BSTree<T>::levelOrder(const PNode & root) { std::queue<PNode> q; q.push(root); while (!q.empty()) { PNode p = q.front(); q.pop(); cout << p->data << " "; if (p->lChild != nullptr) q.push(p->lChild); if (p->rChild != nullptr) q.push(p->rChild); } } template<typename T> inline node<T>* BSTree<T>::removeMin(node<T>* root) { if (root->lChild == nullptr) { PNode rP = root->rChild; if (rP != nullptr) rP->parent = root; delete root; root = nullptr; return rP; } root->lChild = removeMin(root->lChild); return root; } template<typename T> inline node<T>* BSTree<T>::removeMax(node<T>* root) { if (root->rChild == nullptr) { PNode lP = root->lChild; if (lP != nullptr) lP->parent = root; delete root; root = nullptr; return lP; } root->rChild = removeMax(root->rChild); return root; } template<typename T> inline node<T>* BSTree<T>::erase(node<T>* root, const T & d) { if (root == nullptr) return nullptr; if (root->data > d) { root->lChild = erase(root->lChild, d); return root; } else if (root->data < d) { root->rChild = erase(root->rChild, d); return root; } else { if (root->lChild == nullptr) { PNode rP = root->rChild; if (rP != nullptr) rP->parent = root; delete root; root = nullptr; return rP; } if (root->rChild == nullptr) { PNode lP = root->lChild; if (lP != nullptr) lP->parent = root; delete root; root = nullptr; return lP; } PNode successNode = new node<T>(*(const_cast<node<T>*>(min(root->rChild)))); successNode->rChild = removeMin(root->rChild); successNode->lChild = root->lChild; successNode->parent = root->parent; delete root; root = nullptr; return successNode; } } ```