二叉查找树

学习《算法导论》，学着写了二叉查找树。收获不少。

很多东西需要系统的学习呀。

1. /********************************************************************
2.     created:    2008/12/09
3.     created:    9:12:2008   20:57
4.     file base:  Main
5.     file ext:   cpp
6.     author:     Ai
7.     
8.     purpose:    练习二叉查找树
9. *********************************************************************/
10. #include <iostream>
11. #include <algorithm>
13. using namespace std;
15. template<class T>
16. class BSTree
17. {
18.     struct Node 
19.     {
20.         Node* left;
21.         Node* right;
22.         Node* parent;
23.         T key;
24.         Node(T k,Node* l,Node* r,Node* p):
25.         key(k),left(l),right(r),parent(p){}
26.     };
27.     Node* root;
28.     
29. public:
30.     //构造函数
31.     BSTree(T date,Node* l = NULL,Node* r = NULL,Node* p = NULL):
32.     root(new Node(date,l,r,p)){}
34.     //析构函数
35.     ~BSTree()
36.     {
37.         DeleteTree(root);
38.     }
40.     Node* Insert(T date)
41.     {
42.         Node* Target = new Node(date,NULL,NULL,NULL);//需要插入的结点
43.         Node* NowParent = NULL;//存储父结点
44.         Node* NowNode = root;//用于遍历的结点
46.         while(NowNode != NULL)//查找可插入的位置
47.         {
48.             NowParent = NowNode;
49.             if(Target->key > NowNode->key)
50.                 NowNode = NowNode->right;
51.             else
52.                 NowNode = NowNode->left;
53.         }
55.         if(NowParent == NULL)//如果NowParent值为NULL，说明该树为空
56.         {
57.             root = Target;
58.             return root;
59.         }
60.         else//将目标结点插入到指定位置
61.         {
62.             Target->parent = NowParent;
63.             if(Target->key > NowParent->key)
64.                 NowParent->right = Target;
65.             else
66.                 NowParent->left = Target;
67.             return Target;
68.         }
69.     }
71.     Node* SearchNode(Node* NowNode,const T date)
72.     {
73.         if(NowNode == NULL || NowNode->key == date)//未找到返回NULL，找到返回该结点位置
74.             return NowNode;
75.         if(date > NowNode->key)
76.             SearchNode(NowNode->right,date);
77.         else
78.             SearchNode(NowNode->left,date);
79.     }
81.     Node* Max(Node* Target)
82.     {
83.         while(Target->right != NULL)
84.             Target = Target->right;
85.         return Target;
86.     }
88.     Node* Min(Node* Target)
89.     {
90.         while(Target->left != NULL)
91.             Target = Target->left;
92.         return Target;
93.     }
95.     void Print(const Node* TRoot) const//中序遍历输出
96.     {
97.         if(TRoot)
98.         {
99.             Print(TRoot->left);
100.             //copy(&TRoot->key,&TRoot->key+1,ostream_iterator<T>(cout));
101.             cout<<TRoot->key<<endl;
102.             Print(TRoot->right);
103.         }
104.     }
106.     const Node* GetRoot() const
107.     {
108.         return root;
109.     }
111.     void DeleteTree(Node* TRoot)
112.     {
113.         if(TRoot)
114.         {
115.             DeleteTree(TRoot->left);
116.             DeleteTree(TRoot->right);
117.             delete TRoot;
118.             TRoot = NULL;
119.         }
120.     }
122.     Node* Successor(Node* x)
123.     {
124.         if(x->right != NULL)//如果x结点存在有子女结点。那么返回其右子树最小结点
125.             return Min(x->right);
126.         Node* y = x->parent;
127.         while(y != NULL && x == y->right)//x没有右子女结点，那么向上查找直到找到某一结点是其父结点的左结点
128.         {
129.             x = y;
130.             y = y->parent;
131.         }
132.         return y;
133.     }
135.     void DeleteNode(T date)
136.     {
137.         Node* x = NULL;
138.         Node* y = NULL;
139.         Node* z = SearchNode(root,date);
140.         if(z->left == NULL || z->right == NULL)//确定要删除的结点y，该结点y或者是输入结点z，或者是z的后继
141.             y = z;
142.         else
143.             y = Successor(z);
144.         if(y->left != NULL)
145.             x = y->left;
146.         else
147.             x = y->right;
148.         if(x != NULL)//修改y->parenet和x中的指针将y删除
149.             x->parent = y->parent;
150.         if(y->parent == NULL)
151.             root = x;
152.         else if(y == y->parent->left)
153.             y->parent->left = x;
154.         else
155.             y->parent->right = x;
156.         if(y != z)//如果z的后继就是要被删除的结点，则将y中的内容复制到z中。
157.             z->key = y->key;
158.         delete y;
159.     }
160. };
162. int main()
163. {
164.     BSTree<int> bst(15);
165.     bst.Insert(3);
166.     bst.Insert(5);
167.     bst.Insert(12);
168.     bst.Insert(10);
169.     bst.Insert(13);
170.     bst.Insert(6);
171.     bst.Insert(7);
172.     bst.Insert(16);
173.     bst.Insert(20);
174.     bst.Insert(18);
175.     bst.Insert(23);
176.     bst.Print(bst.GetRoot());
177.     cout<<"==============================="<<endl;
178.     bst.DeleteNode(15);
179.     bst.Print(bst.GetRoot());
180.     return 0;
181. }