二叉查找树的C++实现

 #include <iostream>
 #include <algorithm>
 #include <stack>
 using namespace std;
 ////////
 template <typename T>
 class BinarySearchTree{
 /////////
 private:
     struct BinaryNode{
         T element;
         BinaryNode* left;
         BinaryNode* right;
         BinaryNode(T ele, BinaryNode* lt, BinaryNode* rt): element(ele),
             left(lt), right(rt){}
     };
     BinaryNode* root;
     BinaryNode* clone(BinaryNode* t)const{
         if(t == NULL)
             return NULL;
         return new BinaryNode(t->element, clone(t->left), clone(t->right));
     }
     void makeEmpty(BinaryNode* &t){//mind here
         if(t != NULL){
             makeEmpty(t->left);
             makeEmpty(t->right);
             delete t;//mind here...
         }
         t = NULL;
     }
 ////////
 public:
     BinarySearchTree(){
         root = new BinaryNode(, NULL, NULL);
     }
     BinarySearchTree(const BinarySearchTree& rhs): root(clone(rhs.root)){}
     const BinarySearchTree& operator=(const BinarySearchTree& rhs){
         if(this != &rhs){
             makeEmpty(this->root);
             root = clone(rhs.root);
         }
         return *this;
     }
     ~BinarySearchTree(){
         if(root != NULL)
             makeEmpty(root);
     }
 /// concrete algorithms
     BinaryNode* findMax(const BinaryNode* t){
         if(t == NULL)
             return NULL;
         if(t->right == NULL)
             return t;
         return findMax(t->right);
     }
 ///
     BinaryNode* findMin(const BinaryNode* t){
         if(t == NULL)
             return NULL;
         if(t->left == NULL)
             return t;
         return findMin(t->left);
     }

     bool isBinarySearchTree(const BinaryNode* root){
         if(root != NULL){
             if(root->right == NULL && root->left == NULL)
                 return true;
             if(root->left != NULL && root->right == NULL
                 && root->left->element < root->element)
                 return isBinarySearchTree(root->left);
             if(root->left == NULL && root->right != NULL
                 && root->element < root->right->element)
                 return isBinarySearchTree(root->right);
             if(root->left && root->right
                 && root->element < root->right->element
                 && root->left->element < root->element)
                 return isBinarySearchTree(root->left) && isBinarySearchTree(root->right);
             return false;
         }
         return true;
     }
     void numofNode(const BinaryNode* root, int& num){
         if(root != NULL){
             if(root->left == NULL && root->right == NULL)
                 ++num;
             if(root->left != NULL && root->right == NULL){
                 ++num;
                 numofNode(root->left, num);
             }
             if(root->left == NULL && root->right != NULL){
                 ++num;
                 numofNode(root->right, num);
             }
             if(root->left != NULL && root->right !=NULL){
                 ++num;
                 numofNode(root->left, num);
                 numofNode(root->right, num);
             }
         }
     }

     void numofLeafNode(const BinaryNode* root, int& num){
         if(root != NULL){
             if(root->left == NULL && root->right == NULL){
                 ++num;
             }
             if(root->left != NULL && root->right == NULL){
                 numofLeafNode(root->left, num);
             }
             if(root->left == NULL && root->right != NULL){
                 numofLeafNode(root->right, num);
             }
             if(root->left != NULL && root->right !=NULL){
                 numofLeafNode(root->left, num);
                 numofLeafNode(root->right, num);
             }
         }
     }

     void numoffullNode(const BinaryNode* root, int& num){
         if(root != NULL){
             if(root->left == NULL && root->right == NULL){
                 ++num;
             }
             if(root->left != NULL && root->right == NULL){
                 numoffullNode(root->left, num);
             }
             if(root->left == NULL && root->right != NULL){
                 numoffullNode(root->right, num);
             }
             if(root->left != NULL && root->right !=NULL){
                 numofLeafNode(root->left, num);
                 numofLeafNode(root->right, num);
             }
         }
     }

 ////
     bool contains(const T& x, const BinaryNode* t){
         if(t == NULL)
             return false;
         if(x < t->element)
             return contains(x, t->left);
         else if(x > t->right)
             return contains(x, t->right);
         else
             return true;
     }
 ///
     void insert_s(const T& x, BinaryNode* & t){
         if(t == NULL)
             t = new BinaryNode(x, NULL, NULL);
         if(x < t->element)
             insert_s(x, t->left);
         else if(x > t->element)
             insert_s(x, t->right);
         else
             ;
     }
     void insert(const T& x){
         insert_s(x, root);
     }
 ///
     void remove_s(const T& x, BinaryNode* & t){
         if(t == NULL)
             return;
         if(x < t->element)
             remove_s(x, t->left);
         else if(x, t->element)
             remove_s(x, t->right);
         else if(t->right != NULL && t->left != NULL){
             t->element = findMin(t->right)->element;
             remove_s(t->element, t->right);
         }
         else{
             BinaryNode* old = t;
             t = (t->left != NULL)? t->left: t->right;
             delete old;
         }
     }
     void remove(const T& x){
         remove_s(x, root);
     }
 ///
     void printTree_s(const BinaryNode* t){
         if(t != NULL){
             printTree_s(t->left);
             printTree_s(t->right);
             cout << t->element << endl;
         }
     }
     void printTree(){
         printTree_s(root);
     }

     //前序遍历
     void PreOrderTraverseRec(const BinaryNode* root){
         if(root != NULL){
             cout << root->element << endl;
             PreOrderTraverseRec(root->left);
             PreOrderTraverseRec(root->right);
         }
     }
     void PreOrderTraverseNonRec_1(const BinaryNode* root){
         if(root == NULL){
             cout << "enmpty tree...\n";
         }
         else{
             stack<BinaryNode*> st;
             BinaryNode* curr = root;
             st.push(curr);
             while(!st.empty()){
                 curr = st.top();
                 cout << curr->element << endl;
                 st.pop();
                 if(curr->right != NULL)
                     st.push(curr->right);
                 if(curr->left != NULL)
                     st.push(curr->left);
             }
         }
     }

     void PreOrderTraverseNonRec_2(const BinaryNode* root){
         if(root == NULL)
             cout << "empty tree...\n";
         else{
             stack<BinaryNode*> st;
             BinaryNode* curr = root;
             while(!st.empty() || curr != NULL){
                 while(curr != NULL){
                     st.push(curr);
                     cout << curr->element << endl;
                     curr = curr->left;
                 }
                 if(!st.empty()){
                     curr = st.top();
                     st.pop();
                     curr = curr->right;
                 }
             }
         }
     }
     void PreOrderTraverseMorris(const BinaryNode* root){
         BinaryNode* curr = root;
         BinaryNode* pre = NULL;
         while(curr != NULL){
             if(curr->left == NULL){
                 cout << curr->element << endl;
                 curr = curr->right;
             }
             else{
                 pre = curr->left;
                 while(pre->right != NULL && pre->right != curr)
                     pre = pre->right;
                 if(pre->right == NULL){
                     cout << curr->element << endl;
                     pre->right = curr;
                     curr = curr->left;
                 }
                 else{
                     pre->right = NULL;
                     curr = curr->right;
                 }
             }
         }
     }

     //中序遍历
     void InOrderTraverselRec(const BinaryNode* root){
         if(root != NULL){
             InOrderTraverselRec(root->left);
             cout << root->element << endl;
             InOrderTraverselRec(root->right);
         }
     }

     void InOrderTraverselNonRec(const BinaryNode* root){
         if(root == NULL)
             cout << "empty tree...\n";
         else{
             stack<BinaryNode*> st;
             BinaryNode* curr = root;
             while(!st.empty() || curr != NULL){
                 while(curr != NULL){
                     st.push(curr);
                     curr = curr->left;
                 }
                 if(!st.empty()){
                     curr = st.top();
                     st.pop();
                     cout << curr->element << endl;
                     curr = curr->right;
                 }
             }
         }
     }
     void InOrderTraverselMorris(const BinaryNode* root){
         BinaryNode* curr = root;
         BinaryNode* pre = NULL;
         while(curr != NULL){
             if(curr->left == NULL){
                 cout << curr->element << endl;
                 curr = curr->right;
             }
             else{
                 pre = curr->left;
                 while(pre->right != NULL && pre->right != curr)
                     pre = pre->right;
                 if(pre->right == NULL){
                     pre->right = curr;
                     curr = curr->left;
                 }
                 else{
                     pre->right = NULL;
                     cout << curr->element << endl;
                     curr = curr->right;
                 }
             }
         }
     }
     //后续遍历
     void PostOrderTraverseRec(const BinaryNode* root){
         if(root != NULL){
             PostOrderTraverseRec(root->left);
             PostOrderTraverseRec(root->right);
             cout << root->element;
         }
     }

     void PostOrderTraverseNonRec_1(const BinaryNode* root){
         if(root == NULL)
             cout << "empty tree...\n";
         else{
             stack<BinaryNode*> st;
             BinaryNode* curr = root;
             BinaryNode* pre = NULL;
             while(!st.empty() || curr != NULL){
                 while(curr != NULL){
                     st.push(curr);
                     curr = curr->left;
                 }
                 if(!st.empty()){
                     curr = st.top();
                     if(curr->right == NULL || pre == curr->right){
                         cout << curr->element << endl;
                         st.pop();
                         pre = curr;
                         curr == NULL;
                     }
                     else
                         curr = curr->right;
                 }
             }
         }
     }

     void PostOrderTraverseNonRec_2(const BinaryNode* root){
         if(root == NULL)
             cout << "empty tree...\n";
         else{
             stack<BinaryNode*> st;
             BinaryNode* curr = root;
             BinaryNode* pre = NULL;
             st.push(curr);
             while(!st.empty() || curr != NULL){
                 curr = st.top();
                 if((curr->left == NULL && curr->right == NULL) ||
                   ((curr->right == NULL && pre == curr->left) ||
                     pre == curr->right)){
                     st.pop();
                     cout << curr->element;
                     pre = curr;
                 }
                 else{
                     if(curr->right != NULL)
                         st.push(curr->right);
                     if(curr->left != NULL)
                         st.push(curr->left);
                 }
             }
         }
     }

     void PostOrderTraverseNonRec_3(const BinaryNode* root){
         stack<BinaryNode*> st;
         BinaryNode* curr = root;
         st.push(curr);
         st.push(curr);
         while(!st.empty()){
             curr = st.top();
             st.pop();
             if(!st.empty() && curr == st.top()){
                 if(curr->right){
                     st.push(curr->right); st.push(curr->right);
                 }
                 if(curr->left){
                     st.push(curr->left); st.push(curr->left);
                 }
             }
             else
                 cout << curr->element << endl;
         }
     }
 };

 int main(){
     BinarySearchTree<int> lt;
     lt.insert();
     lt.insert();
     lt.insert(-);
     lt.printTree();
     return ;
 }