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