二叉树的中序、先序、后序、层序遍历 & 二叉树的深度 & 节点查找

最新推荐文章于 2024-12-28 20:59:39 发布
最新推荐文章于 2024-12-28 20:59:39 发布
阅读量496 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树 遍历 中序 后序 先序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/asd7486/article/details/51821608
版权
#pragma once
#include <assert.h>
#include <queue>
#include <stack>

template < class T >
struct BinaryTreeNode
{
                 BinaryTreeNode < T >* _left;
                 BinaryTreeNode < T >* _right;
                 T _data;

                BinaryTreeNode( const T & x )
                                :_left( NULL )
                                ,_right( NULL )
                                ,_data( x )
                {}
};

template < class T >
class BinaryTree
{
                 typedef BinaryTreeNode < T > Node ;
public :
                BinaryTree()
                                :_root( NULL )
                {}

                BinaryTree( const T * a , size_t size , const T & invalid )
                {
                                 size_t index = 0;
                                _root = _CreateTree( a , size , invalid , index);
                }

                BinaryTree( const BinaryTree < T >& t )
                {
                                _root = _Copy( t ._root);
                }

                 // t1 = t2 ==> t1.operator=(&t1, t2)
                 // 传统写法
                 //BinaryTree<T>& operator=(const BinaryTree<T>& t)
                 //{
                 //             if (this != &t)
                 //             {
                 //                             this->_Destory(this->_root);
                 //                             this->_root = _Copy(t._root);
                 //             }

                 //             return *this;
                 //}

                 // t1 = t2 ==> t1.operator=(&t1, t2)
                 // 现代写法 == 强盗式逻辑
                 // t1 = t1
                 /*BinaryTree<T>& operator=(BinaryTree<T> t)
                {
                                swap(this->_root, t._root);
                                return *this;
                }*/

                 // t1 = t2
                 BinaryTree < T >& operator=( const BinaryTree < T >& t )
                {
                                 if ( this != & t )
                                {
                                                 BinaryTree < T > tmp( t );
                                                swap( this ->_root, tmp._root);
                                }

                                 return * this ;
                }

                ~BinaryTree()
                {
                                _Destory(_root);
                                _root = NULL ;
                }

                 void PrevOrder()
                {
                                _PrevOrder(_root);
                                cout<<endl;
                }

                 void InOrder()
                {
                                _InOrder(_root);
                                cout<<endl;
                }

                 void PostOrder()
                {
                                _PostOrder(_root);
                                cout<<endl;
                }

                 /*size_t Size()
                {
                                return _Size(_root);
                }*/

                 size_t Size()
                {
                                 size_t size = 0;
                                _Size(_root, size);

                                 return size;
                }

                 size_t Depth()
                {
                                 return _Depth(_root);
                }

                 // 换一种思路实现
                 size_t LeafSize()
                {
                                 return _LeafSize(_root);
                }

                 size_t GetKLevel( size_t k )
                {
                                 assert (k > 0);
                                 return _GetKLevel(_root, k );
                }

                 Node * Find( const T & x )
                {
                                 return _Find(_root, x );
                }

                 void LevelOrder()
                {
                                 if (_root == NULL )
                                                 return ;

                                queue< Node *> q;
                                q.push(_root);

                                 while (!q.empty())
                                {
                                                 Node * front = q.front();
                                                q.pop();
                                                cout<<front->_data<< " " ;

                                                 if (front->_left)
                                                                q.push(front->_left);

                                                 if (front->_right)
                                                                q.push(front->_right);
                                }

                                cout<<endl;
                }

                 void PrevOrderNonR()
                {
                                stack< Node *> s;
                                 if (_root)
                                                s.push(_root);

                                 while (!s.empty())
                                {
                                                 Node * top = s.top();
                                                cout<<top->_data<< " " ;
                                                s.pop();

                                                 if (top->_right)
                                                                s.push(top->_right);

                                                 if (top->_left)
                                                                s.push(top->_left);
                                }

                                cout<<endl;
                }

                 void InOrderNonR()
                {
                                stack< Node *> s;
                                 Node * cur = _root;

                                 while (cur || !s.empty())
                                {
                                                 while (cur)
                                                {
                                                                s.push(cur);
                                                                cur = cur->_left;
                                                }

                                                 Node * top = s.top();
                                                cout<<top->_data<< " " ;
                                                s.pop();

                                                cur = top->_right;
                                }

                                cout<<endl;
                }

                 void PostOrderNonR()
                {
                                stack< Node *> s;
                                 Node * prev = NULL ;
                                 Node * cur = _root;

                                 while (cur || !s.empty())
                                {
                                                 while (cur)
                                                {
                                                                s.push(cur);
                                                                cur = cur->_left;
                                                }

                                                 Node * top = s.top();
                                                 if (top->_right == NULL || top->_right == prev)
                                                {
                                                                cout<<top->_data<< " " ;
                                                                s.pop();
                                                                prev = top;
                                                }
                                                 else
                                                {
                                                                cur = top->_right;
                                                }
                                }

                                cout<<endl;
                }

protected :
                 Node * _Copy( Node * root )
                {
                                 if ( root == NULL )
                                                 return NULL ;

                                 Node * newRoot = new Node ( root ->_data);
                                newRoot->_left = _Copy( root ->_left);
                                newRoot->_right = _Copy( root ->_right);

                                 return newRoot;
                }

                 void _Destory( Node * root )
                {
                                 if ( root == NULL )
                                                 return ;

                                _Destory( root ->_left);
                                _Destory( root ->_right);

                                 delete root ;
                }

              
              Node * _CreateTree( const T * a , size_t size ,
                                 const T & invalid , size_t & index )
                {
                                 Node * root = NULL ;
                                 if ( index < size &&  a [ index ] != invalid )
                                {
                                                root = new Node ( a [ index ]);
                                                root->_left = _CreateTree( a , size , invalid , ++ index );
                                                root->_right = _CreateTree( a , size , invalid , ++ index );
                                }
                                 return root;
                }

                 void _PrevOrder( Node * root )
                {
                                 if ( root == NULL )
                                                 return ;

                                cout<< root ->_data<< " " ;
                                _PrevOrder( root ->_left);
                                _PrevOrder( root ->_right);
                }

                 void _InOrder( Node * root )
                {
                                 if ( root == NULL )
                                                 return ;

                                _InOrder( root ->_left);
                                cout<< root ->_data<< " " ;
                                _InOrder( root ->_right);
                }

                 void _PostOrder( Node * root )
                {
                                 if ( root == NULL )
                                                 return ;

                                _PostOrder( root ->_left);
                                _PostOrder( root ->_right);
                                cout<< root ->_data<< " " ;
                }

                 /*size_t _Size(Node* root)
                {
                                if (root == NULL)
                                                return 0;

                                return _Size(root->_left)+ _Size(root->_right)+1;
                }*/

                 /*size_t _Size(Node* root)
                {
                                static size_t sSize = 0;
                                if (root == NULL)
                                                return sSize;

                                ++sSize;

                                _Size(root->_left);
                                _Size(root->_right);

                                return sSize;
                }*/

                 void _Size( Node * root , size_t & size )
                {
                                 static size_t sSize = 0;
                                 if ( root == NULL )
                                                 return ;

                                ++ size ;

                                _Size( root ->_left, size );
                                _Size( root ->_right, size );
                }

                 size_t _Depth ( Node * root )
                {
                                 if ( root == NULL )
                                {
                                                 return 0;
                                }

                                 int left = _Depth( root ->_left);
                                 int right = _Depth( root ->_right);

                                 return left > right ? left+1 : right+1;
                }

                 size_t _LeafSize( Node * root )
                {
                                 if ( root == NULL )
                                {
                                                 return 0;
                                }

                                 if ( root ->_left == NULL && root ->_right == NULL )
                                {
                                                 return 1;
                                }

                                 return _LeafSize( root ->_left) + _LeafSize( root ->_right);
                }

                 size_t _GetKLevel( Node * root , size_t k )
                {
                                 if ( root == NULL )
                                                 return 0;

                                 if ( k == 1)
                                                 return 1;

                                 return _GetKLevel( root ->_left, k -1) + _GetKLevel( root ->_right, k -1);
                }

                 Node * _Find( Node * root , const T & x )
                {
                                 if ( root == NULL )
                                                 return NULL ;

                                 if ( root ->_data == x )
                                                 return root ;

                                 Node * ret = _Find( root ->_left, x );
                                 if (ret)
                                                 return ret;

                                 return _Find( root ->_right, x );
                }

protected :
                 Node * _root;
};

void TestBinaryTree()
{
                 int a1[10] = {1, 2, 3, '#' , '#' , 4, '#' , '#' , 5, 6};

                 BinaryTree < int > t(a1, sizeof (a1)/ sizeof (a1[0]), '#' );
                t.PrevOrder();
                t.InOrder();
                t.PostOrder();

                cout<< "Tree Size?" <<t.Size()<<endl;
                cout<< "3 Level?" <<t.GetKLevel(3)<<endl;
                 BinaryTreeNode < int >* ret = t.Find(6);
                cout<< "Find 6 ?:" <<ret->_data<<endl;

                t.LevelOrder();
                t.PrevOrderNonR();
                t.InOrderNonR();
                t.PostOrderNonR();
}
23练习4.1 根据后序和中序遍历输出先序遍历（编程题）【PTA浙大版《数据结构（第2版）》题目集】
少侠PSY的博客
05-09 1290
二叉树的遍历
非递归方式实现二叉树四种遍历
Python、C++、HTML、Java
11-12 1471
【问题描述】 非递归方式实现二叉树的先序遍历、中序遍历、后序遍历和层序遍历。 提示：（1）利用先序建立二叉树序列；（2）求四种遍历结果。 【输入形式】 （1）先序建立二叉树序列 （2）非递归方式遍历 【输出形式】 四种遍历结果
二叉树遍历算法 （递归的、非递归的中序、前序、后序遍历 和 层次遍历 以及 求二叉树的宽度和深度）
09-22
二叉树遍历算法 （递归的、非递归的中序、前序、后序遍历 和 层次遍历 以及 求二叉树的宽度和深度）
二叉树层序遍历+深度计算+节点计算、叶子节点计算
tkrj7_的博客
11-25 1208
二叉树 层序遍历 public void levelTraversal(TreeNode root) { //存放节点值输出 ArraryList&lt;Integer&gt; list = new ArrayList&lt;Integer&gt;(); if(root==null) return; //队列先进先出 Queue&lt;TreeNode&gt; queue = new LinkedList&lt;TreeNode&gt;();
剑指offer-二叉树层次遍历求树深度-python
weixin_42766102的博客
04-27 443
# -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: def TreeDepth(self, pRoot): ...
二叉树的层次遍历 & 深度
大树先生的博客
04-18 6382
二叉树的层次遍历 & 利用层次遍历求二叉树的深度
二叉树的遍历及深度的计算
z3551906947的博客
04-06 2981
我们上一篇已经介绍了大量的二叉树知识，这下我们介绍一下其他的知识，接下来我们会了解到二叉树非递归后序遍历的简单版本，还有层序遍历，以及后面的二叉树的深度查找递归，非递归两种版本。这些都会帮助我们在以后的问题中解决很多的事的，所以接下来就要慢慢思考，它里面把好的整体思想。二叉树的根结点所在的层数为1，根结点的孩子结点所在的层数为2，以此下去。深度是指所有结点中最深的结点。
二叉树前中后序遍历及查找
xiaowanziddd的博客
02-06 962
二叉树前中后序遍历及查找 一、二叉树前中后序遍历 1、前序遍历：根结点 —&gt; 左结点 —&gt; 右结点 2、中序遍历：左结点 —&gt; 根结点 —&gt;右结点 3、后序遍历：左结点 —&gt; 右结点 —&gt;根结点 public class BinaryTreeDemo { public static void main(String[] args) { BinaryTree binaryTree = new BinaryTree(); HeroNod
二叉树链表作为存储按层遍历c语言,建立二叉树的二叉链表表示，实现二叉树的先序、中序、后序和按层次遍历，统计并输出结点个数。1）采用二叉链表存储结构建立二叉树，从键盘按先序输入二叉树的结点序列。如，建立...
weixin_39922929的博客
05-24 2208
typedef struct node{char data;struct node *lchild,*rchild;}bitree;bitree *root=NULL;//创建树bitree *CreateTree(char *sInPut){bitree *root,*s;bitree *Q[128];int front,rear;root=NULL;front=1;rear=0;char te...
链式二叉树的基本操作，前序、中序以及后序遍历（递归实现，非递归实现）【有图解】
最新发布
weixin_74461263的博客
12-28 999
设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。访问结点所做的操作依赖于具体的应用问题。既然是链式二叉树，那必须得有自己的结点类型，以下是链式二叉树结点类型的定义，为了避免过多重复的代码，下面的问题都统一使用该结点类型。相对于根结点的第k层结点的个数 = 相对于以其左孩子为根的第k-1层结点的个数 + 相对于以其右孩子为根的第k-1层结点的个数。
【树】二叉树的深度—层序遍历
Alvin的博客
12-24 474
给定二叉树的深度 题目描述： minimum-depth-of-binary-tree 求给定二叉树的最小深度。最小深度是指树的根结点到最近叶子结点的最短路径上结点的数量。 Given a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path ...
二叉树层序遍历_二叉树：看看这些树的最大深度
weixin_39602615的博客
12-13 269
❝二叉树的最大深度会求了，那么顺手把N叉树也做了吧❞104.二叉树的最大深度给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]，返回它的最大深度 3 。思路递归法本题其实也要后序遍历(左右中)，依然是因为要通过递归函数的返回值做计算树的高度。按照递归...
二叉树的深度（前序遍历）
胖墩的IT博客
03-21 1541
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 import java.util.LinkedList; import java.util.List; import java.util.Collections; /** public class TreeNode { int val = 0; TreeNode...
【练习】c++分别用层序遍历和递归求二叉树深度
qq_41358574的博客
04-25 334
递归求深度： struct node { int data; node* lchild;//指向左孩子的结点 node* rchild;//指向右孩子的结点 }; int depth(node* root) { int l, r; node* tem = new node; if (root == nullptr) return 0; if (root-&gt;lchild == nullptr &amp;&amp; root-&gt;rchild
数据结构与算法分析以层序列出二叉树节点
qq_28161649的博客
11-21 924
//头文件 #ifndef _Four35_H typedef struct queue *Queue; typedef struct QueueNode *Position; typedef struct TreeNode *Pos; typedef struct TreeNode *Tree; typedef Pos ElementType ; Queue InitQueue
二叉树的前中后和层序遍历详细图解（递归和非递归写法）
热门推荐
Monster_ii的博客
08-27 8万+
我家门前有两棵树，一棵是二叉树，另一棵也是二叉树。 遍历一棵二叉树常用的有四种方法，前序（PreOrder）、中序（InOrder）、后序（PastOrder）还有层序（LevelOrder）。 前中后序三种遍历方式都是以根节点相对于它的左右孩子的访问顺序定义的。例如根-&amp;gt;左-&amp;gt;右便是前序遍历，左-&amp;gt;根-&amp;gt;右便是中序遍历，左-&amp;gt;右-&amp;gt;根...
树：二叉树的层序遍历算法（超简洁实现及详细分析）
重庆李四
02-26 5万+
实现思路 我们来看看下图的二叉链表 如何实现层序遍历。 层序遍历顺序：ABECDG A为B、E的双亲结点，遍历顺序是 根-&amp;gt;左-&amp;gt;右 是不是。 而且每个结点都是这样的遍历顺序 有木有。那么我们完全可以采用队列的数据结构呗。A入队-&amp;gt;然后出队，出队时将其左右孩子入队，循环队列进行出队，每次出队将其左右孩子入队。当队列为空时，整棵树层序遍历完毕。还没明白请看下面过程。A-&amp;g...
二叉树 求节点、深度、前序、中序、后序遍历
xcc_2269861428的博客
03-02 549
package xcc.test; import java.util.LinkedList; import java.util.Queue; import java.util.Stack; import xcc.bean.TreeNode; public class TestErCha { /** * 第一种求二叉树节点个数(利用递归) * (1)如果二叉树为空，节点个数为0 ...
C语言实现二叉树的四种遍历和求深度与叶子结点个数
酒醉浮生的博客
09-04 9952
C语言实现二叉树的四种遍历和求深度与叶子结点个数使用链式存储实现二叉树使用顺序队列实现二叉树的层序遍历功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 使用链式存储实现二叉树 定义存储数据类型和链式二叉树 //定义数据类型 ty
采用二叉链表存储结构，编写主函数演示二叉树的基本操作，如建二叉树、判空、清空、先序遍历、中序遍历、后序遍历、层序遍历、查找值为e的结点、求二叉树深度、求二叉树叶子数、求二叉树结点总数
09-16
// 求二叉树深度 int getDepth(BinaryTreeNode* root) { if (root == NULL) return 0; int leftDepth = getDepth(root-&gt;left); int rightDepth = getDepth(root-&gt;right); return max(leftDepth, rightDepth) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值