树和二叉树相关算法（一) c/c++

  1 //双亲储存结构
  2 typedef struct{
  3     ElemType data;
  4     int parent;
  5 }PTree[MaxSize];
  6
  7 //孩子链储存结构
  8 const int MaxSons = 10;
  9 typedef struct node{
 10     ElemType data;
 11     struct node* sons[MaxSons];
 12 }TSonNode;
 13
 14 //孩子兄弟链储存结构
 15 typedef struct tnode{
 16     ElemType data;
 17     struct tnode* hp;
 18     struct tnode* vp;
 19 }TSBNode;
 20
 21 //二叉树顺序储存结构
 22 typedef ElemType SqBinTree[MaxSize];
 23
 24 //二叉树链式储存结构
 25 typedef struct bnode{
 26     ElemType data;
 27     struct bnode* lchild;
 28     struct bnode* rchild;
 29 }BTNode;
 30
 31 //二叉树三叉链表
 32 typedef struct btnode{
 33     ElemType data;
 34     struct btnode* lchild;
 35     struct btnode* parent;
 36     struct btnode* rchild;
 37 }BTTNode;
 38
 39 //孩子兄弟链求树的高度
 40 int TreeHeight2(TSBNode *t)
 41 {
 42     TSBNode *p;
 43     int maxh = 0;
 44     int h = 0;
 45     if(t == NULL)
 46         return 0;
 47     else
 48     {
 49         p = t;
 50         while(p != NULL)
 51         {
 52             h = TreeHeight2(p->vp);
 53             if(h > maxh) maxh = h;
 54             p = p->hp;
 55         }
 56         return maxh+1;
 57     }
 58 }
 59
 60 //用括号表达式创建二叉树
 61 void CreateBTree(BTNode *&b,char *str)
 62 {
 63     BTNode *St[MaxSize];int top = -1;
 64     BTNode *p;
 65     int k = 1;
 66
 67     b = NULL;
 68     while(*str != ‘\0‘)
 69     {
 70         switch(*str)
 71         {
 72             case ‘(‘:
 73                 k = 1;
 74                 St[++top] = p;
 75                 break;
 76             case ‘)‘:
 77                 top--;
 78                 break;
 79             case ‘,‘:
 80                 k = 2;
 81                 break;
 82             default:
 83                 p = (BTNode*)malloc(sizeof(BTNode));
 84                 p->data = *str;
 85                 p->lchild = NULL;
 86                 p->rchild = NULL;
 87                 if(b == NULL)
 88                 {
 89                     b = p;
 90                 }
 91                 else
 92                 {
 93                     if(k == 1)
 94                         St[top]->lchild = p;
 95                     else
 96                         St[top]->rchild = p;
 97                 }
 98         }
 99         str++;
100     }
101 }
102 //销毁二叉树
103 void DestroyBTree(BTNode *b)
104 {
105     if(b != NULL)
106     {
107         DestroyBTree(b->lchild);
108         DestroyBTree(b->rchild);
109         free(b);
110     }
111 }
112 //查找结点(基于先序遍历)
113 BTNode *FindNode(BTNode *b,ElemType e)
114 {
115     BTNode *p;
116     if(b == NULL)
117         return NULL;
118     else if(b->data == e)
119         return b;
120     else
121     {
122         p = FindNode(b->lchild,e);
123         if(p != NULL)
124             return p;
125         else
126             return FindNode(b->rchild,e);
127     }
128 }
129 //找孩子结点
130 BTNode *LchildNode(BTNode *b)
131 {
132     return b->lchild;
133 }
134 BTNode *RchildNode(BTNode *b)
135 {
136     return b->rchild;
137 }
138
139 //求二叉树的高度
140 int BTHeight(BTNode *b)
141 {
142     int lchildh,rchildh;
143     if(b == NULL)
144         return 0;
145     else
146     {
147         lchildh = BTHeight(b->lchild);
148         rchildh = BTHeight(b->rchild);
149         return lchildh>rchildh?:lchildh+1,rchildh+1;
150     }
151 }
152
153 //输出二叉树
154 void DispBTree(BTNode *b)
155 {
156     if(b != NULL)
157     {
158         cout<<b->data;
159         if(b->lchild != NULL||b->rchild != NULL)
160         {
161             cout<<"(";
162             DispBTree(b->lchild);
163             if(b->rchild != NULL)cout<<",";
164             DispBTree(b->rchild);
165             cout<<")";
166         }
167     }
168 }
169
170 //递归算法遍历二叉树
171 void PreOrder(BTNode *b)
172 {
173     if( b!= NULL)
174     {
175         cout<<b->data;
176         PreOrder(b->lchild);
177         PreOrder(b->rchild);
178     }
179 }
180
181 void InOrder(BTNode *b)
182 {
183     if(b != NULL)
184     {
185         InOrder(b->lchild);
186         cout<<b->data;
187         InOrder(b->rchild);
188     }
189 }
190
191 void PostOrder(BTNode *b)
192 {
193     if(b != NULL)
194     {
195         PostOrder(b->lchild);
196         PostOrder(b->rchild);
197         cout<<b->data;
198     }
199 }
200
201 //求给定二叉树结点个数
202
203 int Nodes(BTNode *b)
204 {
205     int num = 0;
206     if(b == NULL)
207         return 0;
208     else
209         return Nodes(b->lchild) + Nodes(b->rchild) + 1;
210 }
211
212 //输出所有叶子结点
213 void DispLeaf(BTNode *b)
214 {
215     if(b != NULL)
216     {
217         if(b->lchild == NULL && b->rchild == NULL)
218             cout<<b->data;
219         else
220         {
221             DispLeaf(b->lchild);
222             DispLeaf(b->rchild);
223         }
224     }
225 }
226
227 //返回结点值为x的结点的深度
228 int Level(BTNode *b,ElemType e,int h)
229 {
230     int l;
231     if(b == NULL)
232         return 0;
233     else if(b->data == e)
234         return h;
235     else
236     {
237         l = Level(b->lchild,e,h+1);
238         if( l == 0)
239             return Level(b->rchild,e,h+1);
240         else
241             return l;
242     }
243 }
244
245 //求第k层结点个数
246 int Lnodenum(BTNode *b,int k,int h)
247 {
248     int num = 0;
249     if(b == NULL)
250         return 0;
251     if(h == k)
252         num++;
253     else if(h < k)
254     {
255         num += Lnodenum(b->lchild,k,h+1);
256         num += Lnodenum(b->rchild,k,h+1);
257     }
258     return num;
259 }
260
261 //判断两棵树是否相似
262 bool Like(BTNode *b1,BTNode *b2)
263 {
264     bool like1,like2;
265     if(b1 == NULL && b2 == NULL)
266         return true;
267     else if(b1 == NULL || b2 == NULL)
268         return false;
269     else
270     {
271         like1 = Like(b1->lchild,b2->lchild);
272         like2 = Like(b1->rchild,b2->rchild);
273         return like1 && like2;
274     }
275 }
276
277 //输出值为x的结点的所有祖先
278 bool ancestor(BTNode *b,ElemType e)
279 {
280     if(b == NULL)
281         return false;
282     else if(b->lchild != NULL && b->lchild->data == e
283         || b->rchild != NULL && b->rchild->data == e)
284     {
285             cout<<b->data;
286             return true;
287     }
288     else if(ancestor(b->lchild,e) || ancestor(b->rchild,e))
289     {
290         cout<<b->data;
291         return true;
292     }
293     else
294         return false;
295 }
296
297 //非递归算法遍历二叉树  算法一
298 void PreOrder1(BTNode *b)
299 {
300     BTNode *St[MaxSize];int top=-1;            //创建栈并初始化
301     BTNode *p;                                //结点p为当前处理的结点
302     if(b != NULL)                            //b不为空时
303     {
304         p = b;                                //p指向b
305         St[++top] = p;                        //p入栈
306         while(top!=-1)                        //栈不空时，说明有正在处理的结点
307         {
308             p = St[top];                    //把当前处理的结点拿出来，避免丢失
309             cout<<St[top]->data;            //访问结点并且出栈
310             top--;
311             if(p->rchild != NULL)            //栈后进先出，所以先让右结点进栈
312                 St[++top] = p->rchild;
313             if(p->lchild != NULL)            //左结点进栈
314                 St[++top] = p->lchild;
315         }
316     }
317 }
318
319 //非递归算法遍历二叉树  算法二
320 void PreOrder2(BTNode *b)
321 {
322     BTNode *St[MaxSize];int top = -1;        //定义一个栈保存访问过的结点
323     BTNode *p;                                //p为当前处理的树的根节点指针
324
325     p = b;                                    //p指向b
326     while(top != -1 || p != NULL)            //栈不空或者p不为空
327     {
328         while(p != NULL)                    //p不为空，访问p结点和其所有左下结点并进栈
329         {
330             cout<<p->data;                    //访问结点p
331             St[++top] = p;                    //p结点入栈
332             p = p->lchild;                    //移动到左孩子
333         }
334         if(top != -1)                        //处理完左下结点之后转向右节点
335         {
336             p = St[top--]->rchild;            //转向栈顶结点的右孩子并且栈顶出栈（ 因为栈顶结点处理完毕，不出栈会死循环)
337         }
338     }
339 }
340
341 //非递归算法中序遍历二叉树
342 void InOrder1(BTNode *b)
343 {
344     BTNode *St[MaxSize],*p;int top = -1;
345
346     p = b;
347     while(top != -1 || p != NULL)
348     {
349         while(p != NULL)
350         {
351             St[++top] = p;
352             p = p->lchild;
353         }
354         if(top != -1)
355         {
356             cout<<St[top]->data;
357             p = St[top--]->rchild;
358         }
359     }
360
361 }
362
363 //非递归算法后序遍历二叉树
364 void PostOrder1(BTNode *b)
365 {
366     BTNode *St[MaxSize];BTNode *p;int top = -1;
367     BTNode *r;
368     bool flag;
369
370     p = b;
371     do
372     {
373         while(p != NULL)
374         {
375             St[++top] = p;
376             p = p->lchild;
377         }
378         r = NULL;
379         flag = true;
380         while(top != -1 && flag)
381         {
382             p = St[top];
383             if(p->rchild == r)
384             {
385                 cout<<p->data;
386                 r = p;
387                 top--;
388             }
389             else
390             {
391                 p = p->rchild;
392                 flag = false;
393             }
394         }
395     }while(top != -1);
396 }
397
398 //输出从根节点到每个叶子结点的路径逆序列(非递归算法)
399 void AllPath1(BTNode *b)
400 {
401     BTNode *Path[MaxSize];BTNode *p;int top = -1;
402     BTNode *pre;
403     bool flag;
404
405     p = b;
406     do
407     {
408         while(p != NULL)
409         {
410             Path[++top] = p;
411             p = p->lchild;
412         }
413         pre = NULL;
414         flag = true;
415         while(top != -1 && flag)
416         {
417             p = Path[top];
418             if(p -> rchild == pre)
419             {
420                 if(p -> lchild == NULL && p->rchild == NULL)
421                 {
422                     cout<< p->data <<" : ";
423                     for(int i = 0;i <= top;i++)
424                         cout<<Path[i]->data;
425                     cout<<endl;
426                 }
427                 pre = p;
428                 top--;
429             }
430             else
431             {
432                 p = p->rchild;
433                 flag = false;
434             }
435         }
436     }while(top != -1);
437 }
438

原文地址：https://www.cnblogs.com/cway/p/12708266.html

时间： 2024-10-11 12:21:51

树和二叉树相关算法（一) c/c++的相关文章

树与二叉树基础算法的比较

一:树的创建在数据结构中,树是以二叉树的形式储存的. 树转换为二叉树形式分为三步: ⑴加线——树中所有相邻兄弟之间加一条连线. ⑵去线——对树中的每个结点,只保留它与第一个孩子结点之间的连线,删去它与其它孩子结点之间的连线. ⑶层次调整——以根结点为轴心,将树顺时针转动一定的角度,使之层次分明. 转换后结果如图: 所以树的创建算法有两个思路: 1.将树转化为二叉树后,以二叉树中结点的关系输入而创建树. 2.直接以树中结点的关系输入,用代码转换为相应的二叉树. 第一种方法实际就是二叉树创建,只不

python 实现二叉树相关算法

一.构建与遍历二叉树 class Node(object): def __init__(self,item): self.key=item self.left=None self.right=None class BinaryTree(object): def __init__(self): self.root=None def addNode(self,item): new_node = Node(item) if self.root is None: self.root=new_node e

二叉树相关算法设计题

一. 题目: 二叉树按层打印,同时输出格式满足:打印完一层要换行,每一行的行首标明:level i(i=1,2,3...层) 思路:1.先把二叉树的层次遍历搞懂: 用队列实现,原理是:根节点入队,然后在队列不空的时候循环,循环体操作为:抛出队首元素并向队尾添加该抛出节点的左右子节点(如果不为空的话) 2.题目有两个额外的要求.a.换行打印.b.打印行号.其实就是让我们在层次遍历时遇到每一层的最右节点出队打印时换行并打印行号, 其实a和b是一样的,只要知道怎么换行,在换行时加上level+

数据结构与算法系列研究五——树、二叉树、三叉树、平衡排序二叉树AVL

树.二叉树.三叉树.平衡排序二叉树AVL 一.树的定义树是计算机算法最重要的非线性结构.树中每个数据元素至多有一个直接前驱,但可以有多个直接后继.树是一种以分支关系定义的层次结构. a.树是n(≥0)结点组成的有限集合.{N.沃恩} (树是n(n≥1)个结点组成的有限集合.{D.E.Knuth}) 在任意一棵非空树中: ⑴有且仅有一个没有前驱的结点----根(root). ⑵当n>1时,其余结点有且仅有一个直接前驱. ⑶所有结

数据结构和算法（二）数据结构基础之树、二叉树

Java面试宝典之二叉树的实现我们接着上一篇数据结构继续讲解.本章系数据结构之树与二叉树,从这章开始,我们就要介绍非线性结构了,这些内容理解起来比线性表稍难一些,我尽量写的通俗一些,如果读的过程中有任何问题,请按上述方式联系我! 一.树树形结构是一类重要的非线性结构.树形结构是结点之间有分支,并具有层次关系的结构.它非常类似于自然界中的树.树结构在客观世界中是大量存在的,例如家谱.行政组织机构都可用树形象地表示.树在计算机领域中也有着广泛的应用,例如在编译程序中,用树来表示源程序的语法结

我的软考之路（四）——数据结构和算法（2）树和二叉树

上鲍恩描述了数据结构的线性结构,我们引入非线性结构本博客-树和二叉树.我想向大家介绍一些基本概念树,树遍历,然后介绍了二叉树的概念和特征.和二叉树遍历.叉树的对照,总结. 树为了描写叙述现实世界的层次结构,树结构中一个数据元素能够有两个或两个以上的直接后继元素. 树的基本概念: 树的概念是学习树的关键所在.掌握了树的基本概念,学会树与二叉树,so easy. 我通过一棵树来了解树的基本概念.例如以下图 1.结点的度结点的度是子结点的个数.比如:结点1有三个字结点2,3,4,所以结点1的度为3.

树和二叉树总结及算法实现

[注:相关概念来自经典教材.百度百科及维基百科] 树树状图是一种数据结构,它是由n(n>=1)个有限节点组成一个具有层次关系的集合.它具有以下的特点: 每个节点(node)有零个或多个子节点: 没有父节点的节点称为根节点: 每一个非根节点有且只有一个父节点: 除了根节点外,每个子节点可以分为多个不相交的子树: 如图所示: 相关概念: 节点的度:一个节点含有的子树的个数称为该节点的度: 树的度:一棵树中,最大的节点的度称为树的度: 叶节点或终端节点:度为零的节点: 非终端节点或分支节点:度不为零

6-5-树的双亲表示法-树和二叉树-第6章-《数据结构》课本源码-严蔚敏吴伟民版

课本源码部分第6章树和二叉树 - 树的双亲表示法 ——<数据结构>-严蔚敏.吴伟民版源码使用说明链接??? <数据结构-C语言版>(严蔚敏,吴伟民版)课本源码+习题集解析使用说明课本源码合辑链接??? <数据结构>课本源码合辑习题集全解析链接??? <数据结构题集>习题解析合辑本源码引入的文件链接? Status.h.Scanf.c.SequenceStack.c

树和二叉树-第6章-《数据结构题集》习题解析-严蔚敏吴伟民版

习题集解析部分第6章树和二叉树 ——<数据结构题集>-严蔚敏.吴伟民版源码使用说明链接??? <数据结构-C语言版>(严蔚敏,吴伟民版)课本源码+习题集解析使用说明课本源码合辑链接??? <数据结构>课本源码合辑习题集全解析链接??? <数据结构题集>习题解析合辑相关测试数据下载链接? 数据包本习题文档的存放目录:数据结构\▼配套习题解析\▼06 树和二叉树