二叉搜索树(非递归）

二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

1. 任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2. 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3. 任意节点的左、右子树也分别为二叉查找树；
4. 没有键值相等的节点。
5. 具体做法参考维基百科
   

   

   #include <vector>
   #include <queue>
    
   class BinarySearchTree {
   public:
       struct Node {
           int val;
           Node* left;
           Node* right;
           Node(int v, Node* l = NULL, Node* r = NULL):
           val(v), left(l), right(r) {
           }
       };
    
       BinarySearchTree();
       BinarySearchTree(const std::vector<int>&);
       ~BinarySearchTree();
    
       bool insertNode(int);
       bool searchNode(int);
       bool deleteNode(int);
       void clear();
    
       Node* getRoot() const;
    
   private:
       Node* root;
   };

   BinarySearchTree::BinarySearchTree() {
       root= NULL;
   }
   
   BinarySearchTree::BinarySearchTree(const std::vector<int>& v) {
       root= NULL;
       for (int i= 0; i< v.size(); i++) {
           insertNode(v[i]);
       }
   }
   
   BinarySearchTree::~BinarySearchTree() {
       clear();
   }
   
   bool BinarySearchTree::insertNode(int t) {
       if (root== NULL) {
           root= new Node(t); return true;
       } else {
           Node* back, *c= root;
           while (c!= NULL) {
               back= c;
               if (c->val== t) return false;
               if (c->val> t) c= c->left;
               else c= c->right;
           }
           if (back->val> t) {
               back->left= new Node(t);
               return true;
           } else {
               back->right= new Node(t);
               return true;
           }
       }
   }
   
   bool BinarySearchTree::searchNode(int t) {
       Node* c= root;
       while (c!= NULL) {
           if (t== c->val) return true;
           else if (c->val> t) c= c->left;
           else if (c->val< t) c= c->right;
       }
       return false;
   }
   
   bool BinarySearchTree::deleteNode(int t) {
       if (!searchNode(t)) return false;
       Node* c= root, *temp= root;
       while (c!= NULL) {
           if (c->val== t) {
               break;
           }
           if (c->val> t) {
               temp= c;
               c= c->left;
           }
           if (c->val< t) {
               temp= c;
               c= c->right;
           }
       }
       if (c->left== NULL&&c->right== NULL) {
           if (c== root) {
               delete c;
               root= NULL;
           } else {
               delete c;
               if (temp->val> t) temp->left= NULL;
               else if (temp->val< t) temp->right= NULL;
           }
           return true;
       } else if (c->left!= NULL&&c->right== NULL) {
           if (c== root) {
               Node* t= root;
               root= c->left;
               delete t;
           } else {
               Node* t= c;
               if (temp->val> c->val) temp->left= c->left;
               if (temp->val< c->val) temp->right= c->left;
               delete t;
           }
           return true;
       } else if (c->left== NULL&&c->right!= NULL) {
           if (c== root) {
               Node* t= root;
               root= c->right;
               delete t;
           } else {
               Node* t= c;
               if (temp->val> c->val) temp->left= c->right;
               if (temp->val< c->val) temp->right= c->right;
               delete t;
           }
           return true;
       } else if (c->left!= NULL&&c->right!= NULL) {
           Node* cao= c->left, *back;
           while (cao->right!= NULL) {
               back= cao;
               cao= cao->right;
       }
           if (c== root) {
               root->val= cao->val;
               delete cao;
               back->right= NULL;
           } else {
               c->val= cao->val;
               delete cao;
               back->right= NULL;
           }
           return true;
       }
   }
   
   void BinarySearchTree::clear() {
       queue<Node*>q;
       if (root!= NULL)
       q.push(root);
       while (!q.empty()) {
           Node*root1= q.front();
           q.pop();
           if (root1->left!= NULL)
           q.push(root1->left);
           if (root1->right!= NULL)
           q.push(root1->right);
           delete root1;
       }
   }
   
   BinarySearchTree::Node* BinarySearchTree::getRoot() const {
       return root;
   }