二叉查找树（Binary Search Tree）

 

  1 #ifndef BSTREE_H
  2 #define BSTREE_H
  3 #include<cassert>
  4 #include<stack>
  5 using namespace std;
  6 
  7 template<typename T>
  8 class BSTree
  9 {
 10 public:
 11     template<typename T>
 12     struct Node{
 13         T data;
 14         Node* lchild;
 15         Node* rchild;
 16         Node* parent;
 17 
 18         Node(T d):data(d),lchild(0),rchild(0),parent(0){}
 19         Node(T d,Node*l,Node* r,Node* p):data(d),lchild(l),rchild(r),parent(p){}
 20     };
 21 private:
 22     Node<T>* _root;
 23 
 24     void clear(Node<T>* p){
 25         if(!p)
 26             return;
 27         clear(p->lchild);
 28         clear(p->rchild);
 29         delete p;
 30     }
 31 
 32     Node<T>* search(Node<T>* p,T key){
 33         if(!p||key==p->data)
 34             return p;
 35         if(key<p->data)
 36             return search(p->lchild,key);
 37         else
 38             return search(p->rchild,key);
 39     }
 40 
 41     Node<T>* iterativeSearch(Node<T>* p,T key){
 42         while(p&&p->data!=key){
 43             if(key < p->data)
 44                 p=p->lchild;
 45             else
 46                 p=p->rchild;
 47         }
 48         return p;
 49     }
 50 public:
 51     Node<T>* getRoot(){
 52         return _root;
 53     }
 54 
 55     BSTree(void)
 56     {
 57         _root=0;
 58     }
 59 
 60     ~BSTree(void)
 61     {
 62         clear(_root);
 63     }
 64 
 65     static void preorderTraversal(Node<T>* p){
 66         if(!p)
 67             return;
 68         cout<<p->data<<' ';
 69         preorderTraversal(p->lchild);
 70         preorderTraversal(p->rchild);
 71     }
 72 
 73     static void recursivePreorderTraversal(Node<T>* p){
 74         assert(p!=0);
 75 
 76         stack<Node<T>*> s;
 77         s.push(p);
 78         while(!s.empty()){
 79             Node<T>* cur=s.top();
 80             s.pop();
 81             if(cur){
 82                 cout<<cur->data<<' ';
 83                 if(cur->rchild)
 84                     s.push(cur->rchild);
 85                 if(cur->lchild)
 86                     s.push(cur->lchild);    
 87             }
 88         }
 89     }
 90 
 91     static void inorderTraversal(Node<T>* p){
 92         if(!p)
 93             return;
 94 
 95         inorderTraversal(p->lchild);
 96         cout<<p->data<<' ';
 97         inorderTraversal(p->rchild);
 98     }
 99 
100     static void recursiveInorderTraversal(Node<T>* p){
101         assert(p!=0);
102 
103         stack<Node<T>*> s;
104         while(p||!s.empty()){
105             if(p){
106                 s.push(p);
107                 p=p->lchild;
108             }
109             else{
110                 p=s.top();
111                 s.pop();
112                 cout<<p->data<<' ';
113                 p=p->rchild;
114             }
115         }
116     }
117 
118     static void postorderTraversal(Node<T>* p){
119         if(!p)
120             return;
121         postorderTraversal(p->lchild);
122         postorderTraversal(p->rchild);
123         cout<<p->data<<' ';
124     }

 1 static void levelTraversal(Node<T>* root){
 2         if(!root)
 3             return;
 4 
 5         queue<Node<T>*> q;
 6         q.push(root);
 7         while(!q.empty()){
 8             Node<T>*cur=q.front();
 9             cout<<cur->data<<' ';
10             q.pop();
11             if(cur->lchild)
12                 q.push(cur->lchild);
13             if(cur->rchild)
14                 q.push(cur->rchild);
15         }
16         cout<<endl;
17     }
18 
19     static int printNodeAtLevel(Node<T>* root,int level){
20         if(!root||level<0)
21             return 0;
22         if(level==0){
23             cout<<root->data<<' ';
24             return 1;
25         }
26         else{//level>0
27             return printNodeAtLevel(root->lchild,level-1)+printNodeAtLevel(root->rchild,level-1);
28         }
29     }
30 
31     static void printNodeByLevel(Node<T>* root){
32         int level=0;
33         while(printNodeAtLevel(root,level++)){
34             cout<<endl;
35         }
36     }
37 
38     static void printNodeByLevel2(Node<T>* root){
39         if(!root)
40             return;
41         vector<Node<T>*> vec;
42         vec.push_back(root);
43         int cur=0,last=1;
44         while(cur<vec.size()){
45             while(cur<last){
46                 cout<<vec[cur]->data<<' ';
47                 if(vec[cur]->lchild)
48                     vec.push_back(vec[cur]->lchild);
49                 if(vec[cur]->rchild)
50                     vec.push_back(vec[cur]->rchild);
51                 cur++;
52             }
53             cout<<endl;
54             last=vec.size();
55         }
56     }


125 
126     void insert(Node<T>* newNode){
127         Node<T>* p=0;
128         Node<T>* cur=_root;
129         while(cur){
130             p=cur;
131             if(newNode->data < cur->data)
132                 cur=cur->lchild;
133             else
134                 cur=cur->rchild;
135         }
136         newNode->parent=p;
137         if(!p){
138             _root=newNode;
139         }
140         else{
141             if(newNode->data < p->data)
142                 p->lchild=newNode;
143             else
144                 p->rchild=newNode;
145         }
146     }
147 
148     void insert(T data){
149         Node<T>* newNode=new Node<T>(data);
150         insert(newNode);
151     }
152 
153     Node<T>* search(T key){
154         return search(_root,key);
155     }
156 
157     Node<T>* minimum(Node<T>* p){
158         /*recursive version
159         if(!p)
160         return 0;
161         if(p->lchild)
162         return minimum(p->lchild);
163         else
164         return p;*/
165 
166         if(p){
167             while(p->lchild){
168                 p=p->lchild;
169             }
170         }
171         return p;    
172     }
173     Node<T>* minimum(){
174         return minimum(_root);
175     }
176 
177     Node<T>* maximum(Node<T>*p){
178         /*recursive version
179         if(!p)
180         return 0;
181         if(!p->rchild)
182         return p;
183         else
184         return maximum(p->rchild);*/
185 
186         if(p){
187             while(p->rchild){
188                 p=p->rchild;
189             }
190         }
191         return p;
192     }
193 
194     Node<T>* maximum(){
195         return maximum(_root);
196     }
197 
198     Node<T>* successor(Node<T>* cur){
199         assert(cur!=0);
200         if(cur->rchild){
201             return minimum(cur->rchild);
202         }
203         else{
204             Node<T>* p=cur->parent;
205             while(p && p->rchild==cur){
206                 cur=p;
207                 p=p->parent;
208             }
209             return p;
210         }
211     }
212 
213     Node<T>* predecessor(Node<T>* cur){
214         assert(cur!=0);
215         if(cur->lchild){
216             return maximum(cur->lchild);
217         }
218         else{
219             Node<T>* p=cur->parent;
220             while(p&&p->lchild==cur){
221                 cur=p;
222                 p=p->parent;
223             }
224             return p;
225         }
226     }
227 
228     Node<T>* findLowestCommonAncestor(Node<T>* p,Node<T>* child1,Node<T>* child2){
229         if(!p||!child1||!child2)
230             return 0;
231 
232         while(p){
233             T pd=p->data;
234             T cd1=child1->data;
235             T cd2=child2->data;
236             if(pd>cd1&&pd>cd2)
237                 p=p->lchild;
238             else if(pd<cd1&&pd<cd2)
239                 p=p->rchild;
240             else
241                 return p;
242         }
243         return 0;
244     }
245 
246     Node<T>* remove(Node<T>* cur){
247         Node<T>* deleted=0;
248         if(!cur->lchild||!cur->rchild)
249             deleted=cur;
250         else
251             deleted=successor(cur);
252 
253         Node<T>* child=0;
254         if(deleted->lchild)
255             child=deleted->lchild;
256         else
257             child=deleted->rchild;
258         Node<T>* parent=deleted->parent;
259         if(child)
260             child->parent=parent;
261 
262         if(!parent)
263             _root=child;
264         else if(deleted==parent->lchild)
265             parent->lchild=child;
266         else
267             parent->rchild=child;
268 
269         if(cur!=deleted){
270             T tmp=cur->data;
271             cur->data=deleted->data;
272             deleted->data=tmp;
273         }
274 
275         return deleted;
276     }




//二叉树镜像转换
 1 static void mirror(Node<T>* root){
 2         if(!root||(!root->lchild&&!root->rchild))
 3             return;
 4 
 5         mirror(root->lchild);
 6         mirror(root->rchild);
 7         swap(root->lchild,root->rchild);
 8     }
 9 
10     static void mirror2(Node<T>* root){
11         if(!root||(!root->lchild&&!root->rchild))
12             return;
13 
14         swap(root->lchild,root->rchild);
15         mirror(root->lchild);
16         mirror(root->rchild);
17     }
18 
19     static void mirrorIterative(Node<T>* root){
20         if(!root)
21             return;
22         stack<Node<T>*> s;
23         s.push(root);
24         while(!s.empty()){
25             Node<T>*cur=s.top();
26             s.pop();
27             swap(cur->lchild,cur->rchild);
28             if(cur->lchild)
29                 s.push(cur->lchild);
30             if(cur->rchild)
31                 s.push(cur->rchild);
32         }
33     }






 


277 };
278 
279 #endif//BSTREE_H








            

            
posted @ 
2012-06-22 15:52 
freewater 
阅读(290) 
评论(0) 
 
收藏 
举报