二叉树的建立与遍历

最新推荐文章于 2019-09-25 16:35:53 发布
转载 最新推荐文章于 2019-09-25 16:35:53 发布 · 945 阅读 · 1
文章标签：

#二叉树 #递归 #非递归 #前序中序后序 #遍历

本文详细介绍了二叉树的创建及多种遍历方法，包括递归与非递归实现的前序、中序和后序遍历，并提供了完整的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

该文章转自：http://www.verydemo.com/demo_c92_i175689.html

 

二叉树的节点结构为：

复制代码 
1 struct NODE
2 {
3     char ch;
4 
5     struct NODE *lChild;
6     struct NODE *rChild;
7 };
复制代码

    按照前序的顺序递归建立一颗二叉树：

复制代码 
 1 void PreOrderCreatBinary(struct NODE **root)
 2 {
 3     // 函数入口检验
 4     if (NULL == root)
 5     {
 6         printf ("Invalid Parameter(s)!\n");
 7         return;
 8     }
 9 
10     char ch;
11 
12     printf ("Input NODE value, '#' equal NULL:");
13     scanf ("%c", &ch);
14 
15     // 去掉输入结束按下的回车符
16     getchar();
17 
18     if ('#' == ch)
19     {
20         *root = NULL;
21         return;
22     }
23 
24     if (NULL == (*root = (struct NODE *)malloc(sizeof(struct NODE))))
25     {
26         printf ("Fail to malloc space for *root!\n");
27         return;
28     }
29 
30     (*root)->ch = ch;
31 
32     // 建立其左子树
33     printf ("Create %c's left child.\n", (*root)->ch);
34     PreOrderCreatBinary (&((*root)->lChild));
35 
36     // 建立其右子树
37     printf ("Create %c's right child.\n", (*root)->ch);
38     PreOrderCreatBinary (&((*root)->rChild));
39 }
复制代码

    前序递归遍历二叉树：

复制代码 
 1 void RecursionPreOrder(struct NODE *root)
 2 {
 3     if (NULL != root)
 4     {
 5         // 访问根节点
 6         printf ("%c ", root->ch);
 7 
 8         // 访问左子树
 9         RecursionPreOrder (root->lChild);
10 
11         // 访问右子树
12         RecursionPreOrder (root->rChild);
13     }
14 }
复制代码

    第一种非递归前序遍历二叉树的方式：

复制代码 
 1 void NonRecursivePreOrder(struct NODE *root)
 2 {
 3     if (NULL == root)
 4     {
 5         printf ("Empty Binary Tree!\n");
 6         return;
 7     }
 8 
 9     struct NODE *Stack[MAX];
10     int nTop = -1;
11     struct NODE *Temp = NULL;
12 
13     // 根节点首先入栈
14     Stack[++nTop] = root;
15     while (nTop >= 0)
16     {
17         // 取出栈顶节点并访问
18         Temp = Stack[nTop--];
19         printf ("%c ", Temp->ch);
20 
21         // 左子树要先于右子树被访问，则右子树先入栈
22         if (NULL != (Temp->rChild))
23         {
24             Stack[++nTop] = Temp->rChild;
25         }
26 
27         // 然后左子树入栈
28         if (NULL != (Temp->lChild))
29         {
30             Stack[++nTop] = Temp->lChild;
31         }
32     }
33 }
复制代码

    第二种非递归前序遍历二叉树的方式：

复制代码 
 1 void NonRecursivePreOrder2(struct NODE *root)
 2 {
 3     if (NULL == root)
 4     {
 5         printf ("Empty Binary Tree!\n");
 6         return;
 7     }
 8 
 9     struct NODE *Stack[MAX];
10     int nTop = -1;
11     struct NODE *Temp = root;
12 
13     // 访问当前节点及其全部左子树
14     while (NULL != Temp)
15     {
16         printf ("%c ", Temp->ch);
17 
18         Stack[++nTop] = Temp;
19         Temp = Temp->lChild;
20     }
21 
22     while (nTop >= 0)
23     {
24         // 取得栈顶元素的右子树
25         Temp = Stack[nTop]->rChild;
26         --nTop;
27 
28         // 同样访问当前节点及其全部左子树
29         while (NULL != Temp)
30         {
31             printf ("%c ", Temp->ch);
32             
33             Stack[++nTop] = Temp;
34             Temp = Temp->lChild;
35         }
36     }
37 }
复制代码

    中序递归遍历二叉树：

复制代码 
 1 void RecursionInOrder(struct NODE *root)
 2 {
 3     if (NULL != root)
 4     {
 5         // 访问左子树
 6         RecursionInOrder (root->lChild);
 7 
 8         // 访问根节点
 9         printf ("%c ", root->ch);
10 
11         // 访问右子树
12         RecursionInOrder (root->rChild);
13     }
14 }
复制代码

    中序非递归遍历二叉树：

复制代码 
 1 void NonRecursionInOrder(struct NODE *root)
 2 {
 3     if (NULL == root)
 4     {
 5         printf ("Empty Binary Tree!\n");
 6         return;
 7     }
 8 
 9     struct NODE *Stack[MAX];
10     int nTop = -1;
11     struct NODE *curr = root->lChild;
12 
13     Stack[++nTop] = root;
14 
15     while ((NULL != curr) || (nTop >= 0))
16     {
17         // 根节点及其左子树全部入栈
18         while (NULL != curr)
19         {
20             Stack[++nTop] = curr;
21             curr = curr->lChild;
22         }
23 
24         // 访问栈顶节点
25         curr = Stack[nTop--];
26         printf ("%c ", curr->ch);
27 
28         curr = curr->rChild;
29     }
30 }
复制代码

    后序递归遍历二叉树：

复制代码 
 1 void RecursionPostOrder(struct NODE *root)
 2 {
 3     if (NULL != root)
 4     {
 5         // 访问左子树
 6         RecursionPostOrder (root->lChild);
 7 
 8         // 访问右子树
 9         RecursionPostOrder (root->rChild);
10 
11         // 访问根节点
12         printf ("%c ", root->ch);
13     }
14 }
复制代码

    第一种后序非递归遍历二叉树的方式：

复制代码 
 1 void NonRecursionPostOrder(struct NODE *root)
 2 {
 3     if (NULL == root)
 4     {
 5         printf ("Empty Binary Tree!\n");
 6         return;
 7     }
 8 
 9     struct NODE *Stack[MAX];
10     int nTop = -1;
11     struct NODE *curr = root;
12     struct NODE *Previewed = NULL;
13 
14     while ((NULL != curr) || (nTop >= 0))
15     {
16         while (NULL != curr)
17         {
18             Stack[++nTop] = curr;
19             curr = curr->lChild;
20         }
21         
22         // 获取当前栈顶节点
23         curr = Stack[nTop];
24 
25         // 判断当前节点的右子树状态然后做出相应的操作
26         if ((NULL == (curr->rChild)) || (Previewed == (curr->rChild)))
27         {
28             printf ("%c ", curr->ch);
29             Previewed = curr;
30             curr = NULL;
31             --nTop;
32         } 
33         else
34         {
35             curr = curr->rChild;
36         }
37     }
38 }
复制代码

    第二种后序非递归遍历二叉树的方式：

复制代码 
 1 void NonRecursionPostOrder2(struct NODE *root)
 2 {
 3     if (NULL == root)
 4     {
 5         printf ("Empty Binary Tree!\n");
 6         return;
 7     }
 8 
 9     struct NODE *Stack1[MAX];
10     int nTop1 = -1;
11     struct NODE *Stack2[MAX];
12     int nTop2 = -1;
13     struct NODE *Temp = NULL;
14 
15     // 根节点先入栈1
16     Stack1[++nTop1] = root;
17     while (nTop1 >= 0)
18     {
19         Temp = Stack1[nTop1--];
20         Stack2[++nTop2] = Temp;
21 
22         // 左子树要先在栈2中被访问，则左子树需先入栈1
23         if (NULL != (Temp->lChild))
24         {
25             Stack1[++nTop1] = Temp->lChild;
26         }
27 
28         if (NULL != (Temp->rChild))
29         {
30             Stack1[++nTop1] = Temp->rChild;
31         }
32     }
33 
34     // 按2栈出栈顺序打印即是后序顺序
35     while (nTop2 >= 0)
36     {
37         Temp = Stack2[nTop2--];
38         printf ("%c ", Temp->ch);
39     }
40 }
复制代码

    测试主函数：

复制代码 
 1 #include <stdio.h>
 2 #include <malloc.h>
 3 #define MAX 100
 4 
 5 int main(void)
 6 {
 7     struct NODE *root = NULL;
 8 
 9     // 前序建立二叉树
10     PreOrderCreatBinary (&root);
11 
12     printf ("\n建立的二叉树的前序递归遍历序列为:\n");
13     RecursionPreOrder (root);
14     printf ("\n");
15 
16     printf ("\n建立的二叉树的前序第一种非递归方式遍历序列为:\n");
17     NonRecursivePreOrder (root);
18     printf ("\n");
19 
20     printf ("\n建立的二叉树的前序第二种非递归方式遍历序列为:\n");
21     NonRecursivePreOrder2 (root);
22     printf ("\n");
23 
24     printf ("\n建立的二叉树的中序递归遍历序列为:\n");
25     RecursionInOrder (root);
26     printf ("\n");
27 
28     printf ("\n建立的二叉树的中序非递归遍历序列为:\n");
29     NonRecursionInOrder (root);
30     printf ("\n");
31 
32     printf ("\n建立的二叉树的后序递归遍历序列为:\n");
33     RecursionPostOrder (root);
34     printf ("\n");
35 
36     printf ("\n建立的二叉树的后序第一种非递归方式遍历序列为:\n");
37     NonRecursionPostOrder (root);
38     printf ("\n");
39 
40     printf ("\n建立的二叉树的后序第二种非递归方式遍历序列为:\n");
41     NonRecursionPostOrder2 (root);
42     printf ("\n");
43 
44     return(0);
45 }
复制代码

    结果：

 

【数据结构】二叉树的建立与遍历
weixin_45720246的博客
11-22 625
算法设计思路 二叉树的建立采用struct指针建立结点，每个结点内建两个struct指针来指向它的左右孩子，其中建立方法可采用先序，中序、后序。这里仅介绍先序建树，中序建树和后序建树实际上殊途同归。 建树代码如下 void build(Btree &t) /** * @description: 建树 * 采用先序建树，先根后左右 * @param {*Btree &t} */ { char s; sc("%c", &s); if (isdigit(
二叉树建立和遍历
github_35041937的博客
08-04 320
二叉树的建立— 前中后遍历// // main.c // aa // // Created by yyb on 16/8/4. // Copyright © 2016年 yyb. All rights reserved. //#include <stdio.h> typedef struct BiTNode //结点结构 { char data ;//结点数据 struct
10个经典数据结构课程设计实例：二叉树建立与遍历、冒泡排序、快速排序等详解.zip
最新发布
08-11
10个经典数据结构课程设计实例：二叉树建立与遍历、冒泡排序、快速排序等详解.zip
二叉树建立与遍历
11-04
二叉树的建立与遍历，包括二叉树的定义，有参和无参，前序，中序，后序的遍历。
二叉树建立及遍历算法实现
06-03
建立二叉树，实现二叉树的先序、中序、后序的递归遍历算法，输出遍历结果。 实现二叉树的先序、中序、后序和层次遍历的非递归算法，输出遍历结果。
二叉树建立与遍历的实践教程
在数据结构领域中，二叉树是一种十分重要的非...通过实现和应用二叉树的建立、遍历以及高度计算等操作，学习者可以对数据结构的基础知识有一个更深刻的认识。在实际的数据处理和算法设计中，这些基础知识是非常重要的。
数据结构（六）------树
weixin_43956414的博客
09-25 295
树： 1.树的概述 2.二叉树概述 3.二分搜索树 4.堆和优先队列 5.线段树 6.Trie前缀树 7.并查集 8.AVL树 9.红黑树 树的定义： 树(Tree) 是n (n≥0) 个结点的有限集。当n=0时称为空树。在任意一颗非空树中: (1) 有且仅有一个特定的称为根(root) 的结点; (2) 当n>1时，其余结点可分为m (m>0) 个互不相交的有限集T1、T2、… Tm...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值