二叉树实现 

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "string.h"
  4 #include <windows.h>
  5 
  6 #define SUCCESS           1 // 执行成功                                            
  7 #define ERROC          -1 // 执行失败                                            
  8 #define INDEX_IS_ERROR   -2 // 错误的索引号                                            
  9 #define BUFFER_IS_EMPTY  -3 // 缓冲区已空                                            
 10 
 11 
 12 
 13 class Monster
 14 {
 15 public:
 16     int ID;
 17     int Level;
 18     char Name[20];
 19 public:
 20     Monster() {}
 21     Monster(int ID, int Level,LPCSTR Name)
 22     {
 23         this->ID = ID;
 24         this->Level = Level;
 25         memcpy(&this->Name, Name, strlen(Name) + 1);
 26     }
 27 };
 28 
 29 template<class T>
 30 class TreeNode {
 31 public:
 32     T element;                    //当前节点存储的数据            
 33     TreeNode<T>* pLeft;                    //指向左子节点的指针            
 34     TreeNode<T>* pRight;                    //指向右子节点的指针            
 35 
 36     TreeNode(T& ele) {
 37         //初始化Node节点                            
 38         memset(&element, 0, sizeof(TreeNode));
 39         //为元素赋值                            
 40         memcpy(&element, &ele, sizeof(T));
 41         pLeft = pRight = NULL;
 42     }
 43 };
 44 
 45 template<class T>
 46 class BSortTree {
 47 public:
 48     BSortTree();                    //构造函数            
 49     ~BSortTree();                    //析构函数            
 50 public:
 51     void InOrderTraverse(TreeNode<T>* pNode);                    //中序遍历            
 52     void PreOrderTraverse(TreeNode<T>* pNode);                    //前序遍历            
 53     void PostOrderTraverse(TreeNode<T>* pNode);                    //后序遍历            
 54     TreeNode<T>* GetRoot();                    //返回根节点            
 55     int GetDepth(TreeNode<T>* pNode);                    //返回某个节点的高度/深度            
 56 private:
 57     void Init();
 58     void Clear(IN TreeNode<T>* pNode);
 59 private:
 60     TreeNode<T>* m_pRoot;                    //根结点指针            
 61     int size;                //树中元素总个数            
 62 };
 63 
 64 template<class T>
 65 BSortTree<T>::BSortTree()
 66 {
 67     Init();
 68 }
 69 template<class T>
 70 BSortTree<T>::~BSortTree()
 71 {
 72     printf("执行了析构函数");
 73     Clear(m_pRoot);
 74     //释放所有节点空间                                
 75 
 76 }
 77 
 78 template<class T>
 79 void BSortTree<T>::Init()
 80 {
 81 
 82     Monster m1(1, 1, "刺猬");
 83     Monster m2(2, 2, "野狼");
 84     Monster m3(3, 3, "野猪");
 85     Monster m4(4, 4, "士兵");
 86     Monster m5(5, 5, "火龙");
 87     Monster m6(6, 6, "独角兽");
 88     Monster m7(7, 7, "江湖大盗");
 89 
 90 
 91     TreeNode<Monster>* n1 = new TreeNode<Monster>(m1);
 92     TreeNode<Monster>* n2 = new TreeNode<Monster>(m2);
 93     TreeNode<Monster>* n3 = new TreeNode<Monster>(m3);
 94     TreeNode<Monster>* n4 = new TreeNode<Monster>(m4);
 95     TreeNode<Monster>* n5 = new TreeNode<Monster>(m5);
 96     TreeNode<Monster>* n6 = new TreeNode<Monster>(m6);
 97     TreeNode<Monster>* n7 = new TreeNode<Monster>(m7);
 98 
 99     m_pRoot = n5;
100     n5->pLeft = n4;
101     n5->pRight = n6;
102     n4->pLeft = n1;
103     n1->pRight = n2;
104     n6->pLeft = n3;
105     n3->pRight = n7;
106     size = 7;
107     /*
108                     5
109 
110                 4        6
111 
112             1            3
113 
114                  2                7
115              
116     */
117 }
118 
119 template<class T>
120 void BSortTree<T>::Clear(IN TreeNode<T>* pNode)
121 {
122     if (pNode !=NULL)
123     {
124         Clear(pNode->pLeft);
125         Clear(pNode->pRight);
126         delete pNode;
127         pNode = NULL;
128     }
129 }
130 
131 template<class T>
132 TreeNode<T>* BSortTree<T>::GetRoot()
133 {
134     return m_pRoot;
135 }
136 template<class T>
137 int BSortTree<T>::GetDepth(TreeNode<T>* pNode)
138 {
139     if (pNode == NULL)
140     {
141         return 0;
142     }
143     else
144     {
145         int m = GetDepth(pNode->pLeft);
146         int n = GetDepth(pNode->pRight);
147         return (m > n) ? (m + 1) : (n + 1);
148     }
149 }
150 template<class T>
151 void BSortTree<T>::InOrderTraverse(TreeNode<T>* pNode)
152 {
153     if (pNode != NULL)
154     {
155         LPCSTR pName = NULL;
156         InOrderTraverse(pNode->pLeft);
157         pName = (LPCSTR)pNode;
158         pName = pName + 8;
159         printf("%s\n",pName);
160         InOrderTraverse(pNode->pRight);
161     }
162     //中序遍历所有怪物,列出怪的名字                                
163 
164 
165 }
166 
167 template<class T>
168 void BSortTree<T>::PreOrderTraverse(TreeNode<T>* pNode)
169 {
170     if (pNode != NULL)
171     {
172         printf("%d", pNode->element);
173         PreOrderTraverse(pNode->pLeft);
174         PreOrderTraverse(pNode->pRight);
175     }
176     //前序遍历所有怪物,列出怪的名字                                
177 }
178 
179 template<class T>
180 void BSortTree<T>::PostOrderTraverse(TreeNode<T>* pNode)
181 {
182     //后序遍历所有怪物,列出怪的名字                                
183     if (pNode != NULL)
184     {
185         PostOrderTraverse(pNode->pLeft);
186         PostOrderTraverse(pNode->pRight);
187         printf("%d", pNode->element);
188     }
189 }
190 void TestTree()
191 {
192     BSortTree<Monster>* p = new BSortTree<Monster>;
193     p->InOrderTraverse(p->GetRoot());
194     delete p;
195 }
196 int main()
197 {
198     
199     TestTree();
200 
201     return 0;
202 }

 

posted @ 2021-04-02 16:09  Punished  阅读(87)  评论(0)    收藏  举报