二叉树的遍历算法实现、以及所有简单操作

最新推荐文章于 2022-12-19 22:05:05 发布
最新推荐文章于 2022-12-19 22:05:05 发布
阅读量707 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树 遍历 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_shuai20/article/details/63684204
版权

二叉树的遍历分为先序遍历，中序遍历，后序遍历，层序遍历；

先序遍历：根节点->左子树->右子树

       递归思想：判断根节点是否为空，若不为空则打印根节点数据，然后调用函数取根节点左子树的数据，然后再调用函数取右子树的数据。

      递归实现：

void PrevOrder() //前序遍历
	{
		cout << "前序遍历为：";
		_PrevOrder(_root);
		cout << endl;
	}

void _PrevOrder(Node* root)  //根->左子树->右子树
	{
		if (root == NULL)
			return;

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

非递归思想：定义一个栈q,定义一个节点p指针指向根节点;将p压入栈后，取该节点的值，并且让p=p的左子树同时压入q栈中，直到左子树为空，这个时候取栈的栈顶元素，然后删除栈顶元素，并将p节点设置为根节点的右子树节点。让其再重复其上述操作。

简单流程图：



非递归实现：

	void PrevOrder_NonR()
	{
		stack<Node*> q;
		Node* p = _root;
		while (p != NULL || !q.empty())
		{
			while (p != NULL)
			{
				q.push(p);
				cout << p->_value << " ";
				p = p->_left;
			}
				Node* node = q.top();
				q.pop();
				p = node->_right;
		}
		cout << endl;
	}
中序遍历：

递归实现：

void InOrder()//中序遍历
	{
		cout << "中序遍历为：";
		_InOrder(_root);
		cout << endl;
	}

	void _InOrder(Node* root)//左子树->根节点->右子树
	{
		if (root == NULL)
			return;

		_InOrder(root->_left);
		cout << root->_value << " ";
		_InOrder(root->_right);
	}
非递归想法： 定义一个栈，定义一个节点p指针指向根节点，然后将这个树的所有左子树压入栈中，然后取其栈顶的元素，然后将栈顶pop掉，让p=栈顶节点的右子树，然后重复上面的步骤。

非递归实现：

void InOrder_NonR()
	{
		stack<Node*> q;
		Node* p = _root;
		while (p != NULL || !q.empty())
		{
			while (p != NULL)
			{
				q.push(p);
				p = p->_left;
			}
	
				Node* node = q.top();
				cout << node->_value << " ";
				q.pop();
				p = node->_right;
		}
		cout << endl;
	}
后序遍历：

递归实现：

void PostOrder()//后序遍历
	{
		cout << "后序遍历为：";
		_PostOrder(_root);
		cout << endl;
	}

void _PostOrder(Node* root)//左子树->右子树->根节点
	{
		if (root == NULL)
			return;

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

非递归实现：定义一个栈，定义一个节点指针p指向树的根节点；再定义一个节点指针prev指向上次所访问的指针，如果栈不为空或者节点p不等于NULL;则将该树的所有左子树压入栈中，然后取栈顶元素，如果这个栈顶元素的右子树为空或者是上次访问的指针，那么说明这个栈顶元素的左右子树已经遍历了，那么就打印该元素节点的数据， 如果这个栈顶元素的右子树不为空或者是不是上次访问的指针，那么就让p指向栈顶元素的右子树，然后重复上述操作。 

void PostOrder_NonR()
	{
		stack<Node*> s;
		Node* p = _root;
		Node* prev = NULL;
		while (p != NULL || !s.empty())
		{
			while (p != NULL)
			{
				s.push(p);
				p = p->_left;
			}
			Node* node = s.top();
			if (node->_right == NULL || prev == node->_right)
			{
				cout <<node->_value << " ";
				s.pop();
				prev = node;
			}
			else
			{
				p = node->_right;
			}
		}
		cout << endl;
	}

层序遍历： 

	void LevelOrder() //层序遍历
	{
		cout << "层序遍历为：";
		if (_root != NULL)
		{
			queue<Node*> q;
			q.push(_root);

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

				if (front->_left)
					q.push(front->_left);
				if (front->_right)
					q.push(front->_right);
			}
		}
		cout << endl;
	}


计算深度算法： 

size_t Depth() //计算树的深度
	{
		return _Depth(_root);
	}
size_t _Depth(Node* root)
	{
		if (root == NULL)
			return 0;
		size_t left = _Depth(root->_left);
		size_t right = _Depth(root->_right);
		if (left > right)
		{
			return (left + 1);
		}
		return (right + 1);
	}

计算节点算法：

size_t Size() //统计结点数量
	{
		return _Size(_root);
	}
size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

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

计算叶节点算法：

size_t LeafSize() //统计叶结点的数量
	{
		return _LeafSize(_root);
	}
size_t _LeafSize(Node* root)
	{
		size_t count = 0;
		if (root == NULL)
			return 0;

		if (root->_left == NULL && root->_right == NULL)
			return 1;
		else
			return _LeafSize(root->_left) + _LeafSize(root->_right);
	}

计算满结点算法：

size_t FullSize()//计算满二叉树的结点个数
	{
		return _FullSize(_root);
	}
size_t _FullSize(Node* root)
	{
		if (root == NULL)
			return 0;
		else if (root->_left == NULL && root->_right == NULL)
			return 0;
		else if (root->_left != NULL && root->_right == NULL)
			return _FullSize(root->_left);
		else if (root->_left == NULL && root->_right != NULL)
			return _FullSize(root->_right);
		else if (root->_left != NULL && root->_right != NULL)
			return _FullSize(root->_left) + _FullSize(root->_right) + 1;
	}

寻找节点算法：

Node* Find(const size_t& x)
	{
		return _Find(_root,x);
	}
Node* _Find(Node* root,const size_t& x )
	{
		if (root == NULL)
			reutrn NULL;

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

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

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


求K层节点数算法：

size_t GetKleve(size_t K) //获取K层结点个数
	{
		return _GetKleve(_root, K);
	}
size_t _GetKleve(Node* root, size_t K)
	{
		assert(K > 0);
		if (root == NULL)
			return 0;
		if (K == 1)
			return 1;
		return _GetKleve(root->_left, K - 1) + _GetKleve(root->_right, K - 1);
	}

全部代码实现： 

#include<iostream>
using namespace std;
#include<queue>
#include<stack>
#include<assert.h>
template<class T>
struct binarytreeNode
{
	T _value;
	binarytreeNode<T>* _left;  //左子树
	binarytreeNode<T>* _right;  //右子树
	binarytreeNode(const T& value)
		:_value(value)
		, _left(NULL)
		, _right(NULL)
	{}
};

template<class T>
class binarytree
{
	typedef binarytreeNode<T> Node;
public:
	binarytree()
		:_root(NULL)
	{}
	binarytree(T* arr, size_t n, const T& invalid = T())
	{
		size_t index = 0;
		_root = _Greatree(arr, n, invalid, index);
	}
	~binarytree()
	{
		_Destory(_root);
	}
	binarytree(const binarytree<T>& t)
	{
		_root = Copy(t._root);
	}
	
	binarytree<T>& operator=(const binarytree<T>& t)
	{
		if (this != t)
		{
			Node* newNode = Copy(t._root);
			_Destory(_root);
			_root = newNode;
		}
		return *this;
	}
	void PrevOrder() //前序遍历
	{
		cout << "前序遍历为：";
		_PrevOrder(_root);
		cout << endl;
	}
	void PrevOrder_NonR()
	{
		stack<Node*> q;
		Node* p = _root;
		while (p != NULL || !q.empty())
		{
			while (p != NULL)
			{
				q.push(p);
				cout << p->_value << " ";
				p = p->_left;
			}
				Node* node = q.top();
				q.pop();
				p = node->_right;
		}
		cout << endl;
	}

	void InOrder()//中序遍历
	{
		cout << "中序遍历为：";
		_InOrder(_root);
		cout << endl;
	}

	void InOrder_NonR()
	{
		stack<Node*> q;
		Node* p = _root;
		while (p != NULL || !q.empty())
		{
			while (p != NULL)
			{
				q.push(p);
				p = p->_left;
			}
	
				Node* node = q.top();
				cout << node->_value << " ";
				q.pop();
				p = node->_right;
		}
		cout << endl;
	}
	void PostOrder()//后序遍历
	{
		cout << "后序遍历为：";
		_PostOrder(_root);
		cout << endl;
	}
	void PostOrder_NonR()
	{
		stack<Node*> s;
		Node* p = _root;
		Node* prev = NULL;
		while (p != NULL || !s.empty())
		{
			while (p != NULL)
			{
				s.push(p);
				p = p->_left;
			}
			Node* node = s.top();
			if (node->_right == NULL || prev == node->_right)
			{
				cout <<node->_value << " ";
				s.pop();
				prev = node;
			}
			else
			{
				p = node->_right;
			}
		}
		cout << endl;
	}
	void LevelOrder() //层序遍历
	{
		cout << "层序遍历为：";
		if (_root != NULL)
		{
			queue<Node*> q;
			q.push(_root);

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

				if (front->_left)
					q.push(front->_left);
				if (front->_right)
					q.push(front->_right);
			}
		}
		cout << endl;
	}

	size_t Size() //统计结点数量
	{
		return _Size(_root);
	}

	size_t Depth() //计算树的深度
	{
		return _Depth(_root);
	}

	size_t LeafSize() //统计叶结点的数量
	{
		return _LeafSize(_root);
	}

	size_t FullSize()//计算满二叉树的结点个数
	{
		return _FullSize(_root);
	}

	size_t GetKleve(size_t K) //获取K层结点个数
	{
		return _GetKleve(_root, K);
	}
	Node* Find(const size_t& x)
	{
		return _Find(_root,x);
	}

protected:
	void _PrevOrder(Node* root)  //根->左子树->右子树
	{
		if (root == NULL)
			return;

		cout << root->_value << " ";
		_PrevOrder(root->_left);
		_PrevOrder(root->_right);
		
	}
	void _InOrder(Node* root)//左子树->根节点->右子树
	{
		if (root == NULL)
			return;

		_InOrder(root->_left);
		cout << root->_value << " ";
		_InOrder(root->_right);
	}
	void _PostOrder(Node* root)//左子树->右子树->根节点
	{
		if (root == NULL)
			return;

		_PostOrder(root->_left);
		_PostOrder(root->_right);
		cout << root->_value << " ";
	}
	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

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

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

		if (root->_left == NULL && root->_right == NULL)
			return 1;
		else
			return _LeafSize(root->_left) + _LeafSize(root->_right);
	}

	size_t _FullSize(Node* root)
	{
		if (root == NULL)
			return 0;
		else if (root->_left == NULL && root->_right == NULL)
			return 0;
		else if (root->_left != NULL && root->_right == NULL)
			return _FullSize(root->_left);
		else if (root->_left == NULL && root->_right != NULL)
			return _FullSize(root->_right);
		else if (root->_left != NULL && root->_right != NULL)
			return _FullSize(root->_left) + _FullSize(root->_right) + 1;
	}
	size_t _GetKleve(Node* root, size_t K)
	{
		assert(K > 0);
		if (root == NULL)
			return 0;
		if (K == 1)
			return 1;
		return _GetKleve(root->_left, K - 1) + _GetKleve(root->_right, K - 1);
	}

	size_t _Depth(Node* root)
	{
		if (root == NULL)
			return 0;
		size_t left = _Depth(root->_left);
		size_t right = _Depth(root->_right);
		if (left > right)
		{
			return (left + 1);
		}
		return (right + 1);
	}

	Node* _Find(Node* root,const size_t& x )
	{
		if (root == NULL)
			reutrn NULL;

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

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

		return _Find(root->_right, x);
	}
	Node* _Greatree(T* arr, size_t n,const T& invalid , size_t& index)
	{
		Node * node = NULL;
		if (arr[index] != invalid && index < n)
		{
			node = new Node(arr[index]);
			node->_left = _Greatree(arr, n, invalid, ++index);
			node->_right = _Greatree(arr, n, invalid, ++index);
		}

	  return node;
	}
	Node* Copy(Node* root)
	{
		if (root == NULL)
			return NULL;
		Node* newNode = new Node(root->_value);
		newNode->_left = Copy(root->_left);
		newNode->_right = Copy(root->_right);

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

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

		delete root;
	}
private:
	Node* _root;
};

测试用例：
void Text()
{
	int array[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
	binarytree<int> a(array, sizeof(array) / sizeof(array[0]), '#');
	a.PrevOrder();
	a.PrevOrder_NonR();
	a.InOrder();
	a.InOrder_NonR();
	a.PostOrder();
	a.PostOrder_NonR();
	a.LevelOrder();
	cout << a.Size() << endl;
	cout << a.LeafSize() << endl;
	cout << a.Depth() << endl;
	cout << a.FullSize() << endl;

	cout << a.GetKleve(1) << endl;
	cout << a.GetKleve(2) << endl;
	cout << a.GetKleve(3) << endl;
	binarytree<int> b(a);
}







BabysBreath_hl
关注
专栏目录
二叉树的实现各种遍历算法
09-29
二叉树的实现各种遍历算法，插入删除成员函数非常全。二叉树的实现各种遍历算法，插入删除成员函数非常全
实现二叉树各种遍历算法
分享技术干货，锻炼表达能力
12-23 4338
目录前言一、题目1.二叉树的各种遍历过程及遍历算法设计。2.实现二叉树各种遍历算法总结 前言 提示：记得关注我哦！！！ 一、题目 1.二叉树的各种遍历过程及遍历算法设计。 （1） 先序遍历二叉树； （2） 中序遍历二叉树； （3）后序遍历二叉树。 2.实现二叉树各种遍历算法 代码如下（示例）： #include<stdio.h> #include<malloc.h> #define MaxSize 100 typedef char ElemType; typedef stru
二叉树遍历方法
qq_44813266的博客
05-27 458
方法一：先序遍历： 遍历顺序：根节点–>左孩子–>右孩子 遍历顺序：A–>B–>D–>H–>I–>E–>J–>C–>F–>G 先序遍历的递归实现： 很简单，自己想一下递归的过程就行 代码如下： #include<bits/stdc++.h. using namespace std; struct node//这是二叉树的基本结...
二叉树遍历算法实现(C#2.0)
chbaicheng的专栏
02-14 1546
本人用C#2.0实现了二叉树的定义,怎么构造一颗已知的二叉树,用几种常规的算法（先序,中序,后序,层次）遍历二叉树。希望能给有需要人带来帮助,也希望能得到大家的指点。有关C#数据结构的书在书店里找到,网上也是极少,如果你有好的学习资源别忘了告诉我。先谢了。数据结构对一个程序员来说,现在是太重要了,数据结构学得好的人,逻辑思维一定很强,在程序设计的时候,就不会觉得太费劲了。而且是在设计多层应用程
二叉树的遍历算法
weixin_45726569的博客
11-13 490
我们都知道二叉树是一种数据结构，它有四种遍历方式，前序遍历，中序遍历，后序遍历和层次遍历。 前序遍历首先访问根节点，然后遍历左子树，最后遍历右子树。 中序遍历是先遍历左子树，然后访问根节点，然后遍历右子树。 后序遍历是先遍历左子树，然后遍历右子树，最后访问树的根节点。 层序遍历就是逐层遍历树结构。 那么他们的遍历算法怎么实现呢? 前序遍历，中序和后序遍历一般可以通过递归和迭代两种方式实现，思路基本相同，主要考虑遍历的先后问题。 递归容易理解，迭代得使用栈来帮我们保持数据。 前序遍历递归 定义 preorde
二叉树遍历算法
08-04
在实际应用中，二叉树遍历算法不仅限于简单的数据结构操作。它们在构建解析树、编译器设计、图形渲染和游戏AI等领域都有重要作用。例如，编译器中的词法分析和语法分析就依赖于二叉树遍历，而游戏中的路径查找问题...
php实现的二叉树遍历算法示例
12-20
在本文中，我们将深入探讨如何使用PHP实现二叉树的三种基本遍历算法：前序遍历、中序遍历和后序遍历。...这些遍历算法在实际编程中广泛应用于树形结构的数据操作，如文件系统遍历、表达式求值等场景。
java实现二叉树遍历算法（源代码）
最新发布
04-30
### Java实现二叉树遍历算法详解 #### 一、引言 在计算机科学中，二叉树是一种常用的数据结构，广泛应用于各种算法和数据处理场景。为了更好地理解和操作二叉树，掌握其遍历算法至关重要。本文将详细介绍如何使用...
Objective-C实现二叉树遍历算法（源代码）
04-30
### Objective-C 实现二叉树遍历算法 #### 一、引言 本文将详细介绍如何在Objective-C中实现一个简单的二叉树算法。这包括定义一个二叉树节点的类`BinaryTreeNode`，用于存储数据及指向左右子节点的指针；接着定义...
二叉树各种遍历算法的C++实现
05-19
这些遍历算法对于理解和操作二叉树至关重要，无论是在构建搜索算法、树的复制、序列化还是其他数据处理任务中。在实际应用中，二叉树的遍历算法常常被用于解决复杂的问题，如查找、排序、数据压缩等。通过熟练掌握...
二叉树建立及遍历算法实现
06-03
建立二叉树，实现二叉树的先序、中序、后序的递归遍历算法，输出遍历结果。 实现二叉树的先序、中序、后序和层次遍历的非递归算法，输出遍历结果。
二叉树遍历的流程图(递归+非递归+前中后序)
11-05
辛辛苦苦画的图啊，才两分，便宜你们了~ppt格式的，可以随便改哦~
二叉树的遍历及实现
weixin_46323638的博客
04-18 2059
二叉树的遍历 所谓二叉树的遍历是直观的感受二叉树结构的最简单的方法。 利用某种规则对二叉树中的每一个结点都进行相应操作。 在此主要介绍四种遍历方式： 前序遍历 前序遍历就是由根开始的先左再右的循环结构。 具体可表现为： 其最终遍历结果为：A B D H I E J C F K G 中序遍历 中序遍历实际上就是一种树结构投影到一条线上的投影 最终遍历结果为：H D I B J E A F K C G 后序遍历 我们可以将后序遍历理解为摘果子，先摘矮的好摘的再摘高的。即先
二叉树遍历实现
qq_41648804的博客
08-24 346
在二叉树的操作中，二叉树的遍历是基本的操作，对于二叉树的遍历操作，主要分为： 前序遍历 中序遍历 后序遍历 层次遍历 直接见代码： #include <iostream> #include <stack> #include <queue> #include <malloc.h> using namespace std; typedef struct BiTNode { int data; struct BiTNode *left,
二叉树的三种遍历算法的实现
一滴水，一缕光
08-20 3543
二叉树与一般树的区别 一般树的子树不分次序，而二叉树的子树有左右之分 二叉树的存贮：每个节点只需要两个指针域（左节点，右节点）,有的为了操作方便也会 增加指向父级节点的指针，除了指针域以外，还会有一个数据域用来保存当前节点的信息   二叉树的特点： 性质1：在二叉树的第i层上至多有2^(i-1)个节点(i &gt;= 1) 性质2：深度为k的二叉树至多有2^k-1个节点(k &gt;=...
二叉树遍历算法的应用
weixin_39137699的博客
05-23 1605
今天开始复习数据结构，感觉基础的东西一点还不会 “遍历”是二叉树各种操作的基础，通过遍历操作可以把对节点的输出延伸到对节点的判别，计数等操作，可以解决一些关于二叉树其他实际问题，如果在遍历过程生成节点，这样就能建立二叉树的存储结构。 于是就开始记录书上的基本操作。 1.先序遍历建立二叉链表 先序遍历的访问顺序是：根左右。 void CreateBiTree(BiTree &T){ cin...
二叉树四种遍历的实现
阿润菜菜的博客
12-19 433
前序/中序/后序的递归结构遍历以及层序遍历。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
二叉树遍历算法详解：递归与非递归实现
"这篇文档是关于二叉树遍历的课程设计报告，涵盖了...这个课程设计是全面理解和熟练应用二叉树遍历算法的重要实践，对于计算机科学的学习者来说，这是一个宝贵的锻炼机会，有助于他们建立坚实的理论基础和实践经验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值