【二叉搜索树】的详细实现(C++)

  1 //二叉搜索树结点类型
  2 template<typename T>
  3 struct BSTNode
  4 {
  5     T data;    //数据域
  6     BSTNode<T> *left, *right;    //左子女、右子女
  7     BSTNode() :left(NULL), right(NULL) {}    //构造函数
  8     //构造函数
  9     BSTNode(const T d, BSTNode<T>* L = NULL, BSTNode<T>* R = NULL) :data(d), left(L), right(R) {}
 10 };
 11 
 12 //二叉搜索树的定义
 13 template <class T>
 14 class BST
 15 {
 16 public:
 17     //普通构造函数
 18     BST() :root(NULL) {}
 19     //构造BST
 20     BST(T value) :root(NULL), RefValue(value)
 21     {
 22         T x;
 23         cin >> x;
 24         while (x != RefValue)
 25         {
 26             Insert(x, root);    //新建一个结点，调用Insert插入到树中
 27             cin >> x;
 28         }
 29     }
 30     //析构
 31     ~BST() { Destroy(root); }
 32 
 33     //插入
 34     bool Insert(T x) { return Insert(x, root); }
 35 
 36     //删除
 37     bool Remove(T x) { return Remove(x, root); }
 38 
 39     //搜索
 40     bool Search(T x) { return (Search(x, root) != NULL) ? true : false; }
 41 
 42     //中序遍历
 43     void InOrder() { InOrder(root); }
 44 
 45 protected:
 46 
 47     //以ptr为根的二叉搜索树中插入所含值为e1的结点
 48     bool Insert(const T& e1, BSTNode<T>* &ptr)    //第二个参数是指针的引用
 49     {
 50         if (ptr == NULL)
 51         {
 52             ptr = new BSTNode<T>(e1);    //构造新结点
 53             if (ptr == NULL)
 54             {
 55                 cout << "Memory allocation failed!" << endl;
 56                 exit(1);
 57             }
 58             return true;
 59         }
 60         else if (e1 < ptr->data)    //小于，插入左子树
 61         {
 62             Insert(e1, ptr->left);
 63         }
 64         else if (e1 > ptr->data)    //大于，插入右子树
 65         {
 66             Insert(e1, ptr->right);
 67         }
 68         else    //x已在树中，不插入
 69         {
 70             return false;
 71         }
 72     }
 73 
 74     //以ptr为根的二叉搜索树中删除含x的结点
 75     bool Remove(T x, BSTNode<T>* &ptr)
 76     {
 77         BSTNode<T>* temp;
 78         if (ptr != NULL) //ptr不为空进行操作
 79         {
 80             if (x < ptr->data)
 81             {
 82                 Remove(x, ptr->left);
 83             }
 84             else if (x > ptr->data)
 85             {
 86                 Remove(x, ptr->right);
 87             }
 88             //找到了要删除的结点
 89             //1.要删除的结点ptr同时有左右子树
 90             else if (ptr->left != NULL&&ptr->right != NULL)
 91             {
 92                 temp = ptr->right;    //在右子树中搜索中序下的第一个结点
 93                 while (temp->left != NULL)
 94                 {
 95                     temp = temp->left;
 96                 }
 97                 //用右子树中序下的第一个结点的值填充要删除的结点
 98                 ptr->data = temp->data;
 99                 //然后再新填充值ptr的右子树中删除temp的data值
100                 Remove(ptr->data, ptr->right);
101             }
102             else //不同时有左右子树
103             {
104                 temp = ptr;        //temp记住要删除的ptr结点
105                 if (ptr->left == NULL) //只有右子树
106                 {
107                     ptr = ptr->right;
108                 }
109                 else    //只有左子树
110                 {
111                     ptr = ptr->left;
112                 }
113                 delete temp;    //删除结点
114                 temp = NULL;
115                 return true;
116             }
117         }
118         else //ptr为空直接返回false
119         {
120             return false;
121         }
122     }
123 
124     //在ptr为根的二叉搜索树中搜索含x的结点。若找到，返回该结点地址，否则返回NULL
125     BSTNode<T>* Search(T x, BSTNode<T>* ptr)
126     {
127         if (ptr == NULL)
128         {
129             return NULL;
130         }
131         else if (x < ptr->data)
132         {
133             return Search(x, ptr->left);
134         }
135         else if (x > ptr->data)
136         {
137             return Search(x, ptr->right);
138         }
139         else
140         {
141             return ptr;
142         }
143     }
144 
145     //中序遍历
146     void InOrder(BSTNode<T>* root)
147     {
148         if (root != NULL)
149         {
150             InOrder(root->left);
151             cout << root->data << " ";
152             InOrder(root->right);
153         }
154     }
155 
156     //销毁以root为根的二叉树搜索树函数
157     void Destroy(BSTNode<T>* &root)
158     {
159         if (root == NULL)
160         {
161             return;
162         }
163         if (root->left != NULL)
164         {
165             Destroy(root->left);
166         }
167         if (root->right != NULL)
168         {
169             Destroy(root->right);
170         }
171         delete root;
172         root = NULL;
173     }
174 private:
175     BSTNode<T>* root;    //根指针
176     T RefValue;    //输入结束标识
177 };
178 
179 int main(int argc, char* argv[])
180 {
181     //g a e d f h j i l k #
182     BST<char> tree(‘#‘);
183     tree.InOrder();
184     cout << endl;
185     cout << tree.Search(‘e‘) << endl;
186     cout << tree.Insert(‘z‘) << endl;
187     tree.InOrder();
188     cout << endl;
189     cout << tree.Remove(‘z‘) << endl;
190     cout << tree.Remove(‘j‘) << endl;
191     tree.InOrder();
192     cout << endl;
193     return 0;
194 }