二叉树 

  1 #include <iostream>    
  2  #include <stdlib.h>    
  3  #include <stack>    
  4  #include <queue>    
  5  
  6  using namespace std;    
  7  
  8  struct BiTree    
  9  {    
 10      int data;    
 11      BiTree* left;    
 12      BiTree* right;    
 13  };    
 14  
 15  void visit(BiTree* root)    
 16  {    
 17      std::cout << "BiTree's data: " << root->data << std::endl;    
 18  }    
 19  
 20  //前序遍历    
 21  void pre_search(BiTree* root)    
 22  {    
 23      if (root==NULL)    
 24      {    
 25          return;    
 26      }    
 27      visit(root);    
 28      pre_search(root->left);    
 29      pre_search(root->right);    
 30  }    
 31  
 32  //非递归前序遍历一    
 33  void pre_traverse1(BiTree* root)    
 34  {    
 35      stack<BiTree*> s;    
 36      BiTree* q = root;    
 37      s.push(q);    
 38      while (!s.empty())    
 39      {    
 40          while (q = s.top())    
 41          {    
 42              visit(q);    
 43              s.push(q->left);    
 44          }    
 45          s.pop();//空指针出栈    
 46          if (!s.empty())    
 47          {    
 48              q = s.top();    
 49              s.pop();    
 50              s.push(q->right);    
 51          }    
 52      }    
 53  }    
 54  
 55  //非递归前序遍历二    
 56  void pre_traverse2(BiTree* root)    
 57  {    
 58      stack<BiTree*> s;    
 59      BiTree* q = root;    
 60      while (q || !s.empty())    
 61      {    
 62          if (q)    
 63          {    
 64              visit(q);    
 65              s.push(q);    
 66              q = q->left;    
 67          }    
 68          else    
 69          {    
 70              q = s.top();    
 71              s.pop();    
 72              q = q->right;    
 73          }    
 74      }    
 75  }    
 76  
 77  //中序遍历    
 78  void in_search(BiTree* root)    
 79  {    
 80      if (root==NULL)    
 81      {    
 82          return;    
 83      }    
 84      in_search(root->left);    
 85      visit(root);    
 86      in_search(root->right);    
 87  }    
 88  
 89  //非递归中序遍历一    
 90  void in_traverse1(BiTree* root)    
 91  {    
 92      stack<BiTree*> s;    
 93      BiTree* q = root;    
 94      s.push(q);    
 95      while (!s.empty())    
 96      {    
 97          while (q = s.top())    
 98          {    
 99              s.push(q->left);    
100          }    
101          s.pop();//空指针退栈    
102          if (!s.empty())    
103          {    
104              q = s.top();    
105              s.pop();    
106              visit(q);    
107              s.push(q->right);    
108          }    
109      }    
110  }    
111  
112  //非递归中序遍历二    
113  void in_traverse2(BiTree* root)    
114  {    
115      stack<BiTree*> s;    
116      BiTree* q = root;    
117      while (q || !s.empty())    
118      {    
119          if (q)    
120          {    
121              s.push(q);    
122              q = q->left;    
123          }    
124          else    
125          {    
126              q = s.top();    
127              s.pop();    
128              visit(q);    
129              q = q->right;    
130          }    
131      }    
132  }    
133  
134  //后续遍历    
135  void post_search(BiTree* root)    
136  {    
137      if (root==NULL)    
138      {    
139          return;    
140      }    
141      post_search(root->left);    
142      post_search(root->right);    
143      visit(root);    
144  }    
145  
146  
147  //非递归后序遍历一    
148  void post_traverse1(BiTree* root)    
149  {    
150      stack<BiTree*> st;  
151      BiTree* p   = root;  
152      BiTree* pre = NULL;  
153  
154      while(p || !st.empty())  
155      {  
156          while (p)  
157          {  
158              st.push(p);  
159              p = p->left;  
160          }  
161  
162          p = st.top();  
163          if(p->right == NULL || p->right == pre)//如果p没有右孩子或者其右孩子刚刚被访问过  
164          {  
165              visit(p);  
166              st.pop();  
167              pre = p;  
168              p   = NULL;  
169          }  
170          else  
171          {  
172              p = p->right;  
173          }  
174      }  
175  }    
176  
177  //非递归后序遍历二    
178  void post_traverse2(BiTree* root)    
179  {    
180      bool tag  = false;    
181      BiTree* p = root;    
182      BiTree* q = NULL;    
183      stack<BiTree*> s;    
184  
185      do    
186      {    
187          if (p)    
188          {    
189              s.push(p);    
190              p = p->left;    
191          }    
192          else    
193          {    
194              tag = true;    
195              q   = NULL;    
196              while (tag && !s.empty())    
197              {    
198                  p = s.top();    
199                  if (p->right == q)    
200                  {    
201                      visit(p);    
202                      s.pop();    
203                      q = p;    
204                  }    
205                  else  //遍历右子树    
206                  {    
207                      p = p->right;    
208                      tag = false;    
209                  }    
210              }    
211          }    
212      } while (!s.empty());    
213  }    
214  
215  //层遍历 和广度优先差不多    
216  void layer_search(BiTree* root)    
217  {    
218      queue<BiTree*> s;    
219      s.push(root);    
220      while (!s.empty())    
221      {    
222          BiTree* q = s.front();    
223          s.pop();    
224          visit(q);    
225          if (q->left) s.push(q->left);    
226          if (q->right) s.push(q->right);    
227      }    
228  }    
229  
230  //按层次遍历递归算法  
231  void layer_search(queue<BiTree*>& s)    
232  {    
233      if (s.empty())  
234          return;  
235  
236      BiTree* q = s.front();    
237      s.pop();    
238      visit(q);    
239      if (q->left) s.push(q->left);    
240      if (q->right) s.push(q->right);    
241      layer_search(s);  
242  }  
243  
244  //构建二叉排序树 第一个构建的节点为二叉树根节点    
245  void createTree(BiTree*& root, int data)    
246  {    
247      if (root==NULL)    
248      {    
249          root = new BiTree;    
250          root->data = data;    
251          root->left = NULL;    
252          root->right = NULL;    
253          return;    
254      }    
255  
256      if (root->data==data)    
257      {    
258          std::cout << "data already exists: " << data << std::endl;    
259      }    
260      else if (root->data>data)    
261      {    
262          createTree(root->left,data);    
263      }    
264      else    
265      {    
266          createTree(root->right,data);    
267      }    
268  }    
269  
270  void freeTree(BiTree* root)    
271  {    
272      if (NULL == root)    
273      {    
274          return;    
275      }    
276  
277      if (root->left)    
278      {    
279          freeTree(root->left);    
280      }    
281  
282      if (root->right)    
283      {    
284          freeTree(root->right);    
285      }    
286  
287      delete root;    
288  }    
289  
290  int main()    
291  {    
292      int a[10] = {49,44,59,30,91,9,35,79,63,85};    
293  /*  
294              49  
295            /    \  
296          44      59  
297          /          \  
298         30           91  
299        /  \         /  
300       9    35      79  
301                   /  \  
302                 63   85  
303  */    
304  
305      BiTree* root = NULL;    
306      for (int i=0; i<10; i++)    
307      {    
308          createTree(root, a[i]);    
309      }    
310  
311      std::cout << "**********递归前序遍历**********" << std::endl;    
312      pre_search(root);    
313      std::cout << "**********非递归前序遍历一**********" << std::endl;    
314      pre_traverse1(root);    
315      std::cout << "**********非递归前序遍历二**********" << std::endl;    
316      pre_traverse2(root);    
317  
318      std::cout << "**********递归中序遍历**********" << std::endl;    
319      in_search(root);    
320      std::cout << "**********非递归中序遍历一**********" << std::endl;    
321      in_traverse1(root);    
322      std::cout << "**********非递归中序遍历二**********" << std::endl;    
323      in_traverse2(root);    
324  
325      std::cout << "**********递归后续遍历**********" << std::endl;    
326      post_search(root);    
327      std::cout << "**********非递归后序遍历一**********" << std::endl;    
328      post_traverse1(root);   
329      std::cout << "**********非递归后序遍历二**********" << std::endl;    
330      post_traverse2(root);    
331  
332      std::cout << "**********按层遍历**********" << std::endl;    
333      layer_search(root);    
334      std::cout << "**********按层遍历**********" << std::endl;    
335      queue<BiTree*> s;  
336      s.push(root);  
337      layer_search(s);   
338  
339      //释放资源    
340      freeTree(root);    
341  
342      system("pause");  
343      return 0;    

344  }

二叉树遍历  建树 

 

下面为二叉树的删除

  1 #include <iostream>
  2  
  3  using namespace std;
  4  
  5  struct BiTree
  6  {
  7      int data;
  8      BiTree* left;
  9      BiTree* right;
 10  };
 11  
 12  void visit(BiTree* root)
 13  {
 14      std::cout << "BiTree's data: " << root->data << std::endl;
 15  }
 16  
 17  //中序遍历
 18  void in_search(BiTree* root)
 19  {
 20      if (root==NULL)
 21      {
 22          return;
 23      }
 24      
 25      in_search(root->left);
 26      visit(root);
 27      in_search(root->right);
 28  }
 29  
 30  //构建二叉排序树 第一个构建的节点为二叉树根节点
 31  void createTree(BiTree*& root, int data)
 32  {
 33      if (root==NULL)
 34      {
 35          root = new BiTree;
 36          root->data = data;
 37          root->left = NULL;
 38          root->right = NULL;
 39          return;
 40      }
 41  
 42      if (root->data==data)
 43      {
 44          std::cout << "data already exists: " << data << std::endl;
 45      }
 46      else if (root->data>data)
 47      {
 48          createTree(root->left,data);
 49      }
 50      else
 51      {
 52          createTree(root->right,data);
 53      }
 54  }
 55  
 56  void freeTree(BiTree* root)
 57  {
 58      if (NULL == root)
 59      {
 60          return;
 61      }
 62  
 63      if (root->left)
 64      {
 65          freeTree(root->left);
 66      }
 67  
 68      if (root->right)
 69      {
 70          freeTree(root->right);
 71      }
 72  
 73      delete root;
 74  }
 75  
 76  bool Delete(BiTree*& p)
 77  {
 78      if (!p->right) //右子树为空 
 79      {
 80          BiTree* q = p;
 81          p = p->left;
 82          q->left = NULL; //置NULL是为了防止freeTree的递归删除
 83          freeTree(q);
 84      }
 85      else if (!p->left) //左子树为空
 86      {
 87          BiTree* q = p;
 88          p = p->right;
 89          q->right = NULL;
 90          freeTree(q);
 91      }
 92      else
 93      {
 94          BiTree* q = p;
 95          BiTree* s = p->left;
 96          while (s->right)//初始s右子树为空的情况下q==p
 97          {
 98              q = s;
 99              s = s->right;
100          }
101          p->data = s->data;
102          if (q!=p)
103          {
104              q->right = s->left;
105              s->left  = NULL;
106          }
107          else
108          {
109              q->left = s->left;
110              s->left = NULL;
111          }
112          freeTree(s);
113      }
114  
115      return true;
116  }
117  
118  bool DeleteBST(BiTree*& root, int data)
119  {
120      if (!root) return false;
121      if (root->data==data) return Delete(root);
122      else if (root->data>data) return DeleteBST(root->left, data);
123      else return DeleteBST(root->right, data);
124  }
125  
126  int main()
127  {
128      int a[12] = {49,44,47,59,52,30,91,9,35,79,63,85};
129  /*
130               49
131             /    \
132           44      59
133          /  \    /  \
134         30  47  52   91
135        /  \         /
136       9    35      79
137                   /  \
138                  63   85
139  */
140  
141      BiTree* root = NULL;
142      for (int i=0; i<12; i++)
143      {
144          createTree(root, a[i]);
145      }
146  
147      std::cout << "**********未删除前遍历**********" << std::endl;
148      in_search(root);
149  
150      //删除节点
151      std::cout << "**********删除节点后遍历**********" << std::endl;
152      DeleteBST(root, 44);
153      in_search(root);
154  
155      system("pause");
156      return 0;
157  }

 

 

posted @ 2012-10-02 09:33  starrynight  阅读(141)  评论(0)    收藏  举报