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

最新推荐文章于 2024-01-25 21:49:27 发布
最新推荐文章于 2024-01-25 21:49:27 发布
阅读量715 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树 遍历 算法
版权声明：本文为博主原创文章，遵循 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
关注
专栏目录
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
头歌数据结构二叉树的二叉链表存储及基本操作 第1关：先序遍历创建二叉链表存储的二叉树及遍历操作 第2关：计算二叉树的高度、总节点个数和叶子节点个数 第3关：层次遍历二叉树 第4关：递归实现二叉树左右子树交换 第5关：非递归实现二叉树左右子树交换 第6关：非递归实现二叉树的中序遍历 稳过
二叉树实现及相关操作知识梳理
GangStudyIT的博客
04-20 409
树型结构 前言 树型结构在生活中是非常常见的一种结构，应用范围很广，就用一个简单的例子来说。计算机中的文件目录就是一个树型结构，一般创建一个文件，如果文件中没有文件那么就相当于一个空树，如果里面有文件，就相当于这个文件的子树，以此类推，就形成了树型结构的文件目录。 在学习中我们主要学习二叉树的一些特性，把树细化学习。 二叉树的概念 二叉树是结点的有限集合，该集合或者为空，或者...
数据结构-二叉树的遍历（代码实现）
2302_80362563的博客
01-25 1401
遍历方法共有四种，前篇已经介绍过，性质上分为深度优先和广度优先。
数据结构 二叉树的层次遍历 c/c++实现
weixin_63676550的博客
12-01 1004
数据结构，二叉树的层次遍历 c/c++。此处，我们用T表示二叉树的根节点，出谁的时候，T 的指针就会移动到哪里，假设根节点是A，那么第一次首先是A，然后入队A的左右孩子。每出一个根，此时T的指针就指向谁，此时同时入队谁的左右孩子，顺序就不会错。上面那个代码实现，看似T的指针好像一直没有更新，但仔细观察队列的出队和入队的函数，会发现，每次出/入队的时候，都会用T保存已经出队或入队的元素地址，以此来完成对根节点指针T的更新。
二叉树的实现及其遍历
yang_9613的博客
03-26 201
递归搞得我怀疑人生，写个二叉树缓解一下心情...... 满二叉树： 包含2^k-1个节点 每层的节点数为2^(k-1) 完全二叉树： 除了最后一层所有层的节点都是满的
java实现二叉树遍历算法（源代码）
最新发布
04-30
### Java实现二叉树遍历算法详解 #### 一、引言 在计算机科学中，二叉树是一种常用的数据结构，广泛应用于各种算法和数据处理场景。为了更好地理解和操作二叉树，掌握其遍历算法至关重要。本文将详细介绍如何使用...
Objective-C实现二叉树遍历算法（源代码）
04-30
### Objective-C 实现二叉树遍历算法 #### 一、引言 本文将详细介绍如何在Objective-C中实现一个简单的二叉树算法。这包括定义一个二叉树节点的类`BinaryTreeNode`，用于存储数据及指向左右子节点的指针；接着定义...
二叉树遍历算法
08-04
在实际应用中，二叉树遍历算法不仅限于简单的数据结构操作。它们在构建解析树、编译器设计、图形渲染和游戏AI等领域都有重要作用。例如，编译器中的词法分析和语法分析就依赖于二叉树遍历，而游戏中的路径查找问题...
php实现的二叉树遍历算法示例
12-20
在本文中，我们将深入探讨如何使用PHP实现二叉树的三种基本遍历算法：前序遍历、中序遍历和后序遍历。...这些遍历算法在实际编程中广泛应用于树形结构的数据操作，如文件系统遍历、表达式求值等场景。
二叉树各种遍历算法的C++实现
05-19
这些遍历算法对于理解和操作二叉树至关重要，无论是在构建搜索算法、树的复制、序列化还是其他数据处理任务中。在实际应用中，二叉树的遍历算法常常被用于解决复杂的问题，如查找、排序、数据压缩等。通过熟练掌握...
二叉树（二叉查找树）的遍历（前中后序），添加，查找，删除，节点个数等基础操作，java实现及代码演示。
m0_74000465的博客
05-21 918
二叉树是一种常用的树结构。对于树，我们称每一个节点的子节点个数为度；二叉树就是任意一个度小于等于2树，也就是说，二叉树中任意节点的子节点个数小于等于2；二叉查找树是指按照一定规则次序排列的二叉树，这种二叉树左子树的任意节点的值小于当前节点，右子树的任意节点的值大于当前节点，二叉查找树中不能有重复数据。这是我通过随意数据画出的二叉查找树，之后的操作都将用这组数据作为测试；
二叉树的存储结构和二叉树的遍历方法以及实现代码
qq_51141456的博客
05-25 2029
实现代码在上述代码段中，函数为 PostOrder1(BiTree TT)、InOrder1(BiTree TT)、PreOrder1(BiTree TT)；如果二叉树如下图中所示，补全节点使其成为完全二叉树的方法太浪费空间；给定一个序列，在给定一个遍历的方法，能否将还原出二叉树呢？下图中的左右 要理解为树木，不要片面的理解成节点；答案是：不能，如下图，给定先序遍历 123。先看动图看遍历步骤，再看实例；先序遍历序列+中序遍历序列。后序遍历序列+中序遍历序列。层次遍历序列+中序遍历序列。
层次遍历二叉树
weixin_46314022的博客
11-17 1727
void HierarchyOrder(BiTreeNode* root) // 二叉树的层次遍历（队列实现） // 参数：二叉树根节点root // 输出：二叉树的层次遍历，中间没有空格，末尾不换行。 { // 请在这里补充代码，完成本关任务 /********** Begin *********/ queue<BiTreeNode*> q; if(root!=NULL) { q.push(root); } while(!
数据结构-例题实训作业-二叉树相关
Junds0的博客
11-07 926
本关任务：以先序的方式建立二叉树后，补充代码，统计该二叉树的节点数，叶子数，满节点数，计算数的高度。本关任务：以先序的方式建立二叉树后，补充代码，完成对该二叉树的先序遍历，中序遍历和后序遍历。本关任务：以先序的方式建立二叉树后，补充代码，在二叉树中查找某节点是否存在。请按先序顺序依次输入树的节点（包括空节点，以#表示）请按先序顺序依次输入树的节点（包括空节点，以#表示）请按先序顺序依次输入树的节点（包括空节点，以#表示）在以下空白处补写代码，以先序方式完成二叉树的建立。在以下空白处补写代码，完成任务要求。
头歌（C语言）-数据结构与算法-二叉树-先序遍历/中序遍历
weixin_59436900的博客
05-04 2706
为使实验程序简洁直观，下面的部分实验程序中的一些功能实现仍以调用库函数程序"btrechar.h"中的函数的形式给出，并假设该库函数中定义了二叉树指针和结点类型分别为bitre和bnode，以及部分常用运算，例如构建二叉树、以某种方式显示二叉树等。：为使实验程序简洁直观，下面的部分实验程序中的一些功能实现仍以调用库函数程序"btrechar.h"中的函数的形式给出，并假设该库函数中定义了二叉树指针和结点类型分别为bitre和bnode，以及部分常用运算，例如构建二叉树、以某种方式显示二叉树等。
数据结构——二叉树遍历及常见操作c代码实现
weixin_45491420的博客
06-28 342
二叉树遍历及常见操作代码实现。
二叉树的遍历操作
奈川直子
11-13 3317
一、操作要求 1.假设二叉树的结点值是字符，先根据输入一棵二叉树标明空子树的完整先根遍历序列或者根据输入一棵二叉树的先根遍历序列和中根遍历序列或者根据输入一棵二叉树的后根遍历序列和中根遍历序列，建立一棵以二叉链表表示的二叉树，并输出建立后的二叉树的先根、中根、后根遍历序列，观察其建立的二叉树是否正确； 2.复制上述建立的二叉树，并输出复制后的二叉树的后根遍历序列，观察其复制操作是否正确； 3.判断复制后形成的二叉树是否与原二叉树相等,如果相等,则报告“这两棵树是相等的，复制操作成功”，否则报告“这两棵
遍历二叉树的代码实现
1+1=王的博客
08-08 1658
二叉树的遍历先序遍历（根--左--右）递归法非递归法中序遍历（左--根--右）递归法非递归法后序遍历（左--右--根）递归法非递归法层序遍历 先序遍历（根–左--右） 递归法 void PreOrder(BiTree T){ if(T != NULL){ visit(T); //访问根节点 PreOrder(T->lchild); //递归遍历左子树 PreOrder(T->rchild); //递归遍历右子树 } } 非递归法 void PreOrder(BiTree
二叉树的遍历
LeeBlog
08-28 206
【遍历方式简介】 前序遍历: 先输出父节点，再遍历左子树和右子树 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点 【代码片段】 创建二叉树结点 class HeroNode { private int no; private String name; private HeroNode left; //默认null...
二叉树遍历算法实现与程序文件Project2
- 代码实现二叉树及其遍历算法需要良好的编程习惯和调试技巧。 - 实现时需要定义合适的数据结构来表示树的节点，并且可能需要辅助函数来实现特定的逻辑。 - 调试过程中，打印节点访问信息有助于理解算法运行的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值