【数据结构】二叉树的递归与非递归创建和遍历

二叉树遍历与操作
最新推荐文章于 2019-11-21 21:48:49 发布
原创 最新推荐文章于 2019-11-21 21:48:49 发布 · 531 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉树 #遍历 #创建 #递归 #非递归

本文介绍了一种使用递归和非递归方法实现二叉树遍历及操作的方法。通过具体的代码示例，详细解释了前序、中序、后序遍历等基本操作，并提供了树的创建、复制、销毁等高级功能。

下面代码所用到的测试用例画成树的样子长这样：


创建树时给的是数组，用‘#’代表非法值，即该结点为空。

二叉树的递归实现：

#pragma once
#include<iostream>
#include<queue>
using namespace std;

template<class T>
struct BinaryTreeNode
{
	BinaryTreeNode(T value=0)
	:_value(value), _left(NULL), _right(NULL)
	{}
	T _value;
	BinaryTreeNode<T>* _left;
	BinaryTreeNode<T>* _right;
};

template<class T>
class BinaryTree
{
public:
	typedef BinaryTreeNode<T> Node;
	BinaryTree()
	{}
	BinaryTree(T* a, size_t size, const T& invalid)
	{
		size_t index = 0;
		_root=_CreatTree( a, size,index, invalid);
	}
	BinaryTree(const BinaryTree<T>& bt)
	{
		_root = _Copy(bt._root);
	}
	BinaryTree<T>& operator=(BinaryTree<T>& bt)
	{
		if (this != &bt)
		{
			BinaryTree<T> tmp(bt);
			swap(tmp._root, _root);

		}
	}
	~BinaryTree()
	{
		_Distory(_root);
	}

	void PrevOrder()
	{
		_PrevOrder(_root);
		cout << endl;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	void PostOrder()
	{
		_PostOrder(_root);
		cout << endl;
	}
	void LevelOrder()  //层序遍历
	{
		_LevelOrder(_root);
		cout << endl;
	}

	size_t Size()
	{
		return _Size(_root);
	}
	size_t Depth()
	{
		return _Depth(_root);
	}
	size_t LeafSize()
	{
		return _LeafSize(_root);
	}
	size_t GetKLevel(size_t k)  //第K层结点个数
	{

	}
protected:

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

	Node* _Copy(Node* copyroot)
	{
		Node* root = NULL;
		if (copyroot!=NULL)
		{
			root = new Node(copyroot->_value);
			root->_left = _Copy(copyroot->_left);
			root->_right = _Copy(copyroot->_right);
		}
		return root;
	}

	Node* _PrevOrder(Node* root)
	{
		if (root)
		{
			cout << root->_value << " ";
			_PrevOrder(root->_left);
			_PrevOrder(root->_right);
		}
		return root;
	}

	Node* _InOrder(Node* root)
	{
		if (root)
		{
			_InOrder(root->_left);
			cout << root->_value<<" ";
			_InOrder(root->_right);
		}
		return root;
	}

	Node* _PostOrder(Node* root)
	{
		if (root)
		{
			_PostOrder(root->_left);
			_PostOrder(root->_right);
			cout << root->_value << " ";
		}
		return root;
	}

	void _LevelOrder(Node* root)
	{
		queue<Node*> q;
		q.push(root);
		while (!q.empty())
		{
			Node* tmp = q.front();
			cout << tmp->_value<<" ";
			
			if (tmp->_left)
				q.push(tmp->_left);
			if (tmp->_right)
				q.push(tmp->_right);
			q.pop();
		}
	}

	size_t _Size(Node* root)
	{
		size_t size = 0;
		if (root)
		{
			size = _Size(root->_left) + _Size(root->_right)+1;
		}
		return size;
	}

	size_t _Depth(Node* root)
	{
		size_t depth1 = 0;
		size_t depth2 = 0;
		if (root)
		{
			depth1 = _Depth(root->_left) + 1;
			depth2 = _Depth(root->_right) + 1;
		}
		return depth1 > depth2 ? depth1 : depth2;
	}

	size_t _LeafSize(Node* root)
	{
		if (root == NULL)
			return 0;
		else if (root->_left == NULL&&root->_right == NULL)
			return 1;
		return _LeafSize(root->_left) + _LeafSize(root->_right);
	}
private:
	Node* _root;
};

void test()
{
	int array[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
	int array1[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
	BinaryTree<int> bt(array, 10, '#');
	bt.PrevOrder();
	bt.InOrder();
	bt.PostOrder();
	cout << bt.Size() << endl;
	cout << bt.Depth() << endl;
	cout << bt.LeafSize() << endl;
	BinaryTree<int> bt2(array1, 15, '#');
	cout << bt2.Depth() << endl;
	cout << bt2.LeafSize() << endl;
	BinaryTree<int> bt3(bt);
	bt3.PrevOrder();
	BinaryTree<int> bt4=bt3;
	bt4.PrevOrder();
	bt4.LevelOrder();
}

递归的好处在于代码简练。但递归不容易理解。

非递归的二叉树(面试经常会考的):

#pragma once
#include<iostream>
#include<cassert>
#include<queue>
#include<stack>
using namespace std;

template<class T>
struct BinaryTreeNode
{
	BinaryTreeNode(T value = 0)
	:_value(value), _left(NULL), _right(NULL)
	{}
	T _value;
	BinaryTreeNode<T>* _left;
	BinaryTreeNode<T>* _right;
};

template<class T>
class BinaryTree
{
public:
	typedef BinaryTreeNode<T> Node;
	BinaryTree()
	{}
	explicit BinaryTree(T* a, size_t size, const T& invalid)    //构造函数，创建一棵树。
	{
		stack<Node*> s;
		size_t index = 0;
		Node* cur = NULL;
		while (index < size)
		{
			while ((index < size) && (a[index] != invalid))
			{
				if (index == 0)
				{
					_root = new Node(a[index++]);
					cur = _root;
				}
				else
				{
					cur->_left = new Node(a[index++]);
					cur = cur->_left;
				}
				s.push(cur);
			}
			index++;
			Node* top = s.top();
			s.pop();
			if ((index < size) && (a[index] != invalid))
			{
				cur = top;
				cur->_right = new Node(a[index++]);
				cur = cur->_right;
				s.push(cur);
			}
		}
	}

	BinaryTree(const BinaryTree<T>& bt)  //拷贝构造
	{
		Node* cur = bt._root;
		Node* root = NULL;
		stack<Node*>s;
		stack<Node*>s1;
		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				if (root == NULL)
				{
					root = new Node(cur->_value);
					_root = root;
				}
				else
				{
					root->_left = new Node(cur->_value);
					root = root->_left;
				}
				cur = cur->_left;
				s1.push(root);
			}
			Node* top = s.top();
			Node* top1 = s1.top();
			s.pop();
			s1.pop();

			cur = top->_right;
			if (cur)
			{
				root = top1;
				root->_right = new Node(cur->_value);
				root = root->_right;
				cur = cur->_left;
			}
		}
	}

	BinaryTree<T>& operator=(BinaryTree<T> bt)
	{
		swap(_root, bt._root);
		return *this;
	}

	void PrevOrderNoR()
	{
		Node* cur = _root;
		stack<Node*> s;
		while (cur || !s.empty())
		{
			while (cur)
			{
				cout << cur->_value << " ";
				s.push(cur);
				cur = cur->_left;
			}
			Node* top = s.top();
			s.pop();
			cur = top->_right;
		}
		cout << endl;
	}
	void InOrderNoR()
	{
		Node* cur = _root;
		stack<Node*> s;
		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				cur = cur->_left;
			}
			Node* top = s.top();
			s.pop();
			cout << top->_value << " ";
			cur = top->_right;
		}
		cout << endl;
	}

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

	size_t SizeNoR()
	{
		size_t size = 0;
		Node* cur = _root;
		stack<Node*> s;
		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				size++;
				cur = cur->_left;
			}
			Node* top = s.top();
			s.pop();
			cur = top->_right;
		}
		return size;
	}

	size_t DepthNoR()
	{
		if (_root == NULL)
			return 0;
		size_t depth = 0;
		Node* cur = NULL;
		queue<Node*> q;
		size_t VisitNum = 0;  //有多少数据出栈
		size_t NodeNum = 1;
		size_t LeveNum = 1;  //每一层最后一个数据的序号
		q.push(_root);
		while (!q.empty())
		{
			cur = q.front();
			q.pop();
			VisitNum++;
			
			if (cur->_left)
			{
				NodeNum++;
				q.push(cur->_left);
			}
			if (cur->_right)
			{
				NodeNum++;
				q.push(cur->_right);
			}
			if (LeveNum == VisitNum)
			{
				depth++;
				LeveNum = NodeNum;
			}
		}
		return depth;
	}

	size_t LeveNum()  //叶子节点个数
	{
		size_t count = 0;
		Node* cur = _root;
		stack<Node*> s; 
		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				if ((cur->_left == NULL) && (cur->_right == NULL))
					count++;
				cur = cur->_left;
			}

			Node* top = s.top();
			s.pop();
			cur = top->_right;
		}
		return count;
	}
	size_t GetKLeve(size_t k)  //得到第k层结点个数。
	{
		assert(k <= DepthNoR());
		if (k == 1)
			return 1;
		queue<Node*>q;
		size_t NodeNum = 1;
		size_t LeveNum = 1;
		size_t VisitNum = 0;
		size_t leve = 1;
		q.push(_root);
		while (!q.empty())
		{
			Node* cur = q.front();
			q.pop();
			VisitNum++;
			if (cur->_left)
			{
				q.push(cur->_left);
				NodeNum++;
			}
			if (cur->_right)
			{
				q.push(cur->_right);
				NodeNum++;
			}
			if (LeveNum == VisitNum)
			{
				leve++;
				if (leve == k)
					break;
				LeveNum = NodeNum;
			}
		}
		return NodeNum - VisitNum;
	}
private:
	Node* _root;
};

void test()
{
	int array[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
	BinaryTree<int> bt(array, 10, '#');
	bt.PrevOrderNoR();
	bt.InOrderNoR();
	bt.PostOrderNoR();
	BinaryTree<int> bt1(bt);
	bt1.PrevOrderNoR();
	BinaryTree<int> bt2 = bt1;
	bt2.PrevOrderNoR();
	cout << bt.SizeNoR() << endl;
	cout << bt.DepthNoR() << endl;
	cout << bt.LeveNum() << endl;
	cout << bt.GetKLeve(3) << endl;
}

可以看到，非递归相对来说代码量能多点，但是比较容易理解，而且几个遍历过程代码十分相似，理解其中一个，后面几个都是类似的。

二叉树的递归及非递归建立（c/cpp）
woxiaosade的博客
08-07 4004
前言 自己最近在书写二叉树方面的内容时，在二叉树的建立部分出现了bug，想了很久才明白，在这里记录下，以后不要再犯 代码 先写几个递归建立二叉树的代码，再附一个非递归建立二叉树的方法 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct tree{ int data; struct tree * left;...
二叉树递归与非递归遍历
11-03
非递归遍历通过使用辅助数据结构（如栈）避免了深度递归，更适合处理大规模的二叉树。同时，它也可以通过适当修改实现其他特定顺序的遍历，如层次遍历（Level Order Traversal），通过队列来存储节点。 在实际应用...
数据结构c语言版建立二叉树，中序非递归遍历（实验报告）
07-22
编写程序，用先序递归的方法建立二叉树，建立二叉树后，用中序非递归方法遍历该二叉树，并输出遍历序列。
数据结构-二叉树递归-非递归实现
04-26
数据结构实验二叉树用递归实现先序遍历、中序遍历和后序遍历，用几种不同非递归方法实现了中序遍历，代码附有详细注释
二叉树的创建和递归与非递归遍历
weixin_33994429的博客
05-18 158
二叉树的创建 //index要给引用！！！ void _Create(Node *&pRoot,T *arr,T invalid,size_t sz,size_t &index) { if (arr[index] != invalid&&index < sz) ...
二叉树非递归遍历-二叉树非递归遍历-二叉树非递归遍历-二叉树非递归遍历
最新发布
09-09
/*********************************************************** ***********************************************************/ #include #include #include #define MS 50 struct BTreeNode ...
数据结构 二叉树的递归与非递归
09-15
总结来说，二叉树的递归与非递归遍历是数据结构中重要的操作。递归遍历简单直观，适用于小规模问题；非递归遍历则适用于处理大规模数据，避免了递归带来的栈空间限制。理解这两种方法并能灵活运用，对于理解和实现...
数据结构-非递归遍历二叉树
11-16
总之，非递归遍历二叉树是数据结构中的重要概念，它涉及栈和队列等基本数据结构的操作，以及逻辑控制的巧妙运用。掌握这些技巧，不仅可以帮助我们更好地理解和应用二叉树，也有助于提升我们的算法设计能力。
数据结构二叉树遍历递归，非递归
12-12
理解递归遍历后，非递归遍历的关键在于使用额外的数据结构（如栈或队列）来跟踪当前的遍历状态。非递归遍历的优势在于它避免了函数调用栈的深度限制，对于非常深的树，递归可能会导致栈溢出。 在实际编程中，根据...
数据结构::二叉树的非递归实现
海绵宝宝的欧尼~ 的博客
12-14 1160
#include using namespace std; #include #include template struct BinaryTreeNode { T _data; BinaryTreeNode* _left; //左孩子 BinaryTreeNode* _right; //右孩子 BinaryTreeNode(const T&x) :_data(x) ,_left
数据结构与算法学习记录--二叉树的创建，递归遍历，非递归遍历的实现
l31299的博客
09-01 315
package test; import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Stack; public class BinaryTree { /** * 用内部类申明结点结构 * */ class Node{ int value...
数据结构-代码实现-二叉树-非递归
WesenTCYS的博客
12-07 271
/*非递归用栈*/ #include&lt;iostream&gt; using namespace std; #define max 100 typedef struct bitnode{ char data; bitnode *lchild,*rchild; }bitnode,*bitree; class stack{ bitree *base; bitree *top; int ...
数据结构-----创建/递归非递归遍历二叉树
扇扇来驰的博客
08-15 1775
class BiTreeNode { public BiTreeNode left; public BiTreeNode right; public int value; public BiTreeNode(int value) { this.value = value; } } public class BiTree { public int count = 0; publi
【数据结构与算法】二叉树递归与非递归遍历
mick_seu的博客
10-05 914
在C/C++中，二叉树是一种非常重要的数据结构，它的各种遍历也是树结构学习的基础。这里我将刷刷 leetcode 上相关题目。 1、前序遍历（Preorder Traversal） 递归： class Solution { public: void preOrder(vector &res, TreeNode *root) { if(NULL
数据结构——二叉树的建立以及递归和非递归遍历二叉树
qq_45641726的博客
11-21 385
#c实现二叉树的建立以及遍历 typedef struct BiTree { char data; struct Ltree* Lch, * Rch; }LTree,* QLTree; QLTree create_tree(QLTree T) { //遍历方法创建二叉树 char c; scanf(“请输入结点的数据：%c”, &c); if (c == ‘#’) { T = NUL...
数据结构C语言版（作业）之 二叉树的创建，遍历（递归、非递归）
十七的博客
11-20 1307
1）二叉树的创建，递归遍历，深度，结点数，叶子数 #include&lt;iostream&gt; using namespace std; typedef struct bitnode{ char data; struct bitnode *lchild,*rchild; }bitnode,*bitree; void createbitree(bitree &amp;T){//创建二叉...
二叉树——创建和遍历（递归、非递归）
阿基美德的博客
06-01 1011
递归二叉树 非递归二叉树
实验四、5非递归创建遍历二叉树
Richard的专栏
06-17 975
二叉树递归与非递归遍历方法解析
资源摘要信息:"二叉树递归与非递归遍历" 二叉树是计算机科学中一种非常重要的数据结构，用于模拟具有“一对二”关系的数据。在二叉树的算法设计中，遍历是一个核心的操作，它指的是按照某种顺序访问二叉树中的每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值