二叉树的基本操作

最新推荐文章于 2020-08-26 23:21:24 发布
最新推荐文章于 2020-08-26 23:21:24 发布
阅读量397 收藏 1
点赞数 2
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l__xing/article/details/79907681
版权

本篇着重介绍二叉树的一些基本操作，实现二叉树的一些基本接口。

二叉树的基本数据成员

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

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

};

二叉树的创建

BinaryTree()
    :_root(NULL)
    {}

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

//前序创建
Node* _CreateTree(T* arr, size_t n, const T& invalid, size_t& index)
{
    Node* root = NULL;
    if (index < n)
    {
	if (arr[index] != invalid)
	{
	    root = new Node(arr[index]);
	    root->_left = _CreateTree(arr, n, invalid, ++index);
	    root->_right = _CreateTree(arr, n, invalid, ++index);
	}
    }
		
    return root;
}

二叉树的拷贝

BinaryTree(const BinaryTree<T>& tree)
{    _root = _CopyTree(tree._root);
    if (NULL == root)
}

Node* _CopyTree(Node* root)
{
    Node* newroot = new Node(root->_data);
    {return NULL;    }
    newroot->_left = _CopyTree(root->_left);
    newroot->_right = _CopyTree(root->_right);    return newroot;
}
二叉树的销毁 
~BinaryTree()
{
    Destory(_root);
    _root = NULL;
}

void Destory(Node* root)
{
    if (NULL == root)
    return;
    Destory(root->_left);
    Destory(root->_right);

    delete root;
}

二叉树的扶植运算符重载

//第一种写法
/*BinaryTree& operator=(const BinaryTree<T>& tree)
{
    if (this != &tree)
    {
        Destory(_root);
	_CopyTree(tree._root);
    }
    return *this;
}*/

//第二种写法
BinaryTree& operator=(BinaryTree<T> tree)
{
    swap(_root, tree._root);
    return *this;
}

遍历——递归遍历

前序遍历

void Prevorder()
{
    _Prevorder(_root);
    cout << endl;
}
void _Prevorder(Node* root)
{
    if (root == NULL)
    {
	return;
    }

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

中序遍历

void Inorder()
{
    _Inorder(_root);
    cout << endl;
}
void _Inorder(Node* root)
{
    if (root == NULL)
    {
        return;
    }
    cout << root->_data << " ";
    _Inorder(root->_left);
    _Inorder(root->_right);
}

后序遍历

void PostOrder()
{
    _PostOrder(_root);
    cout << endl;
}
void _PostOrder(Node* root)
{
    if (root == NULL)
    {
        return;
}
    _PostOrder(root->_left);
    _PostOrder(root->_right);
    cout << root->_data << " ";
}

遍历——非递归遍历

前序非递归遍历

void PrevOrderNon()
{
    stack<Node*> s;
    Node* cur = _root;
    while (cur || !s.empty())
    {
	while (cur)
	{
	    s.push(cur);
	    cout << cur->_data << " ";
	    cur = cur->_left;
	}
	Node* top = s.top();
	s.pop();

	cur = top->_right;
    }
    cout << endl;
}

中序非递归遍历

void InorderNon()
{

    Node* cur = _root;
    stack<Node*> s;

    while (cur || !s.empty())
    {
        while (cur)
	{
	    s.push(cur);
	    cur = cur->_left;
	}
	Node* top = s.top();
	cout << top->_data << " ";
	cur = top->_right;
	s.pop();
    }
    cout << endl;
}

后序非递归遍历

void PostOrderNon()
{
    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 || top->_right == prev)
	{
            cout << top->_data << " ";
	    prev = top;
	    s.pop();
	}
	else
	{
	    cur = top->_right;
	}
    }
    cout << endl;
}

层序遍历

void LevelOrder()
{
    if (_root == NULL)
        return;
    queue<Node*> q;
    q.push(_root);
    while (!q.empty())
    {
	Node* cur = q.front();
	cout << cur->_data << " ";
	q.pop();
	if (cur->_left)
	    q.push(cur->_left);
	if (cur->_right)
	    q.push(cur->_right);
    }
    cout << endl;
}

求节点个数

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

void _Size(Node* root,size_t& size)
{
    if (root == NULL)
	return;
    _Size(root->_left,size);
    ++size;
    _Size(root->_right,size);
}

求叶子节点个数

size_t LeafSize()
{
    return _LeafSize(_root);
}

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

求树的深度

size_t Height()
{
    return _Height(_root);
}

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

    size_t LeftH = _Height(root->_left);
    size_t RightH = _Height(root->_right);
    return LeftH > RightH ? LeftH + 1 : RightH + 1;
}

求第k层节点个数

size_t Get_KLevel(size_t k)
{
    return _Get_KLevel(_root,k);
}

size_t _Get_KLevel(Node* root, size_t k)
{
    if (NULL == root)
	return 0;
    if (k == 1)
    return 1;
    return _Get_KLevel(root->_left, k-1) + _Get_KLevel(root->_right, k-1);
}

判断该数是不是完全二叉树

//判断思路：最下一层必须是连续的叶子节点，
//给每个节点设一个flag，空为false当出现上一节点为空，当前节点不为空时则该树不是完全二叉树
bool IsCompleteTree()
{
    queue<Node*> q;
    if (_root)
        q.push(_root);
    else
	return false;

    bool flag = true;
    //节点为空就将flag置false
    while (!q.empty())
    {
        Node* front = q.front();
	q.pop();
	if (front->_left)//左数不为空
	{
	    if (flag == false)//判断上一个节点是否为空
		return false;


            q.push(front->_left);
	}
	else
	    flag = false;


	if (front->_right)//右树不为空
	{
	    if (flag == false)//判断上一个节点是否为空
		return false;


	    q.push(front->_right);
	}
	else
	    flag = false;


    }
    return true;
}

查找

Node* Find(const T& data) {     return _Find(_root,data); } Node* _Find(Node* root, const T& data) {     if (root == NULL)     return NULL;     if (data == root->_data)         return root;     Node* ret1 = _Find(root->_left,data);     if (ret1) return ret1;     Node* ret2 = _Find(root->_right, data);     if (ret2) return ret2;     return NULL; }
源码： 
#include<iostream>
#include<stack>
#include<queue>
#include<assert.h>
using namespace std;

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

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

};

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

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

	//前序创建
	Node* _CreateTree(T* arr, size_t n, const T& invalid, size_t& index)
	{
		Node* root = NULL;
		if (index < n)
		{
			if (arr[index] != invalid)
			{
				root = new Node(arr[index]);
				root->_left = _CreateTree(arr, n, invalid, ++index);
				root->_right = _CreateTree(arr, n, invalid, ++index);
			}
		}
		
		return root;
	}

	BinaryTree(const BinaryTree<T>& tree)
	{
		_root = _CopyTree(tree._root);
	}

	Node* _CopyTree(Node* root)
	{
		if (NULL == root)
		{
			return NULL;
		}

		Node* newroot = new Node(root->_data);
		newroot->_left = _CopyTree(root->_left);
		newroot->_right = _CopyTree(root->_right);

		return newroot;
	}

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

	void Destory(Node* root)
	{
		if (NULL == root)
			return;
		Destory(root->_left);
		Destory(root->_right);

		delete root;
	}

	//第一种写法
	/*BinaryTree& operator=(const BinaryTree<T>& tree)
	{
		if (this != &tree)
		{
			Destory(_root);
			_CopyTree(tree._root);
		}
		return *this;
	}*/

	//第二种写法
	BinaryTree& operator=(BinaryTree<T> tree)
	{
		swap(_root, tree._root);
		return *this;
	}


public:
	//递归

	//前序遍历
	void Prevorder()
	{
		_Prevorder(_root);
		cout << endl;
	}
	void _Prevorder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}

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

	//中序遍历
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
	void _Inorder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_data << " ";
		_Inorder(root->_right);
	}

	//后序遍历
	void PostOrder()
	{
		_PostOrder(_root);
		cout << endl;
	}
	void _PostOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		_PostOrder(root->_left);
		_PostOrder(root->_right);
		cout << root->_data << " ";
	}

	//层序遍历
	void LevelOrder()
	{
		if (_root == NULL)
			return;
		queue<Node*> q;
		q.push(_root);
		while (!q.empty())
		{
			Node* cur = q.front();
			cout << cur->_data << " ";
			q.pop();
			if (cur->_left)
				q.push(cur->_left);
			if (cur->_right)
				q.push(cur->_right);
		}
		cout << endl;
	}

	//非递归
	//前序遍历
	void PrevOrderNon()
	{
		stack<Node*> s;
		Node* cur = _root;
		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				cout << cur->_data << " ";
				cur = cur->_left;
			}
			Node* top = s.top();
			s.pop();

			cur = top->_right;
		}
		cout << endl;
	}

	//中序遍历
	void InorderNon()
	{

		Node* cur = _root;
		stack<Node*> s;

		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				cur = cur->_left;
			}
			Node* top = s.top();
			cout << top->_data << " ";
			cur = top->_right;
			s.pop();
		}
		cout << endl;
	}

	//后序遍历
	void PostOrderNon()
	{
		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 || top->_right == prev)
			{
				cout << top->_data << " ";
				prev = top;
				s.pop();
			}
			else
			{
				cur = top->_right;
			}
		}
		cout << endl;
	}
public:

	//size节点个数
	int Size()
	{
		size_t size = 0;
		_Size(_root,size);
		return size;
	}

	void _Size(Node* root,size_t& size)
	{
		if (root == NULL)
			return;
		_Size(root->_left,size);
		++size;
		_Size(root->_right,size);
	}

	//叶子节点个数
	size_t LeafSize()
	{
		return _LeafSize(_root);
	}

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

	//树的高度
	size_t Height()
	{
		return _Height(_root);
	}

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

		size_t LeftH = _Height(root->_left);
		size_t RightH = _Height(root->_right);
		return LeftH > RightH ? LeftH + 1 : RightH + 1;
	}

	//求第K层节点个数
	size_t Get_KLevel(size_t k)
	{
		return _Get_KLevel(_root,k);
	}

	size_t _Get_KLevel(Node* root, size_t k)
	{
		if (NULL == root)
			return 0;
		if (k == 1)
			return 1;
		return _Get_KLevel(root->_left, k-1) + _Get_KLevel(root->_right, k-1);
	}

	//判断思路：最下一层必须是连续的叶子节点，
	//给每个节点设一个flag，空为false当出现上一节点为空，当前节点不为空时则该树不是完全二叉树
	bool IsCompleteTree()
	{
		queue<Node*> q;
		if (_root)
			q.push(_root);
		else
			return false;

		bool flag = true;
		//节点为空就将flag置false
		while (!q.empty())
		{
			Node* front = q.front();
			q.pop();
			if (front->_left)//左数不为空
			{
				if (flag == false)//判断上一个节点是否为空
					return false;

				q.push(front->_left);
			}
			else
				flag = false;

			if (front->_right)//右树不为空
			{
				if (flag == false)//判断上一个节点是否为空
					return false;

				q.push(front->_right);
			}
			else
				flag = false;

		}
		return true;
	}

	//查找
	Node* Find(const T& data)
	{
		return _Find(_root,data);
	}

	Node* _Find(Node* root, const T& data)
	{
		if (root == NULL)
			return NULL;
		if (data == root->_data)
			return root;

		Node* ret1 = _Find(root->_left,data);
		if (ret1)
			return ret1;

		Node* ret2 = _Find(root->_right, data);
		if (ret2)
			return ret2;

		return NULL;
	}

protected:
	Node* _root;
};

测试用例：

int main()
{
	int array[] = { 1, 2, 3, '#', '#', 4, 40, '#', '#', '#', 5, 6, '#', '#', '#' };
	BinaryTree<int> t(array, sizeof(array) / sizeof(int), '#');
	t.Prevorder();
	t.PrevOrderNon();
	t.Inorder();
	t.InorderNon();
	t.PostOrder();
	t.PostOrderNon();
	t.LevelOrder();
	cout << "节点个数size为：" << t.Size() << endl;
	cout << "叶子节点Leaf Size：" << t.LeafSize() << endl;
	cout << "高度Height：" << t.Height() << endl;
	cout << "IsCompleteTree?" << t.IsCompleteTree() << endl;
	cout << "第K层节点个数 Level Size：" << t.Get_KLevel(4) << endl;

	BinaryTree<int> t1(t);
	t1.PrevOrderNon();

	system("pause");
	return 0;
}

测试结果：


Kuroba_thief
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
1914 Problem A 树查找
子衿
03-13 162
问题 A: 树查找 时间限制:1 Sec内存限制:32 MB 提交:205解决:118 [提交][状态][讨论版][命题人:外部导入] 题目描述 有一棵树，输出某一深度的所有节点，有则输出这些节点，无则输出EMPTY。该树是完全二叉树。 输入 输入有多组数据。 每组输入一个n(1&lt;=n&lt;=1000)，然后将树中的这n个节点依次输入，再输入一个d代表深度。 输...
平衡二叉树及其操作实现
DX奥特曼的博客
01-11 2959
[问题描述] 实现平衡二叉排序树的创建、插入、删除、查询操作，并求出所构建平衡二叉排序树的平均查找长度ASL。 [基本要求] （1）以二叉链表作为平衡二叉树的存储结构； （2）输入一个关键字序列，建立对应的平衡二叉树； （3）向平衡二叉树中插入一个结点（关键字）； （4）从平衡二叉树中删除一个结点（关键字）； （5）计算平衡二叉树的平均查找长度； （6）销毁平衡二叉树。 ...
数据结构之二叉树的使用技巧（一）
10-20 136
经常看到有些人写关于二叉树的一些博客，说了很多概念，然后建立二叉树那块的方法真是让我拙计啊，看到好多人是这样建立的，代码大概是这样： public class BinaryTree { int data; BinaryTree left; BinaryTree right; public BinaryTree(int d,BinaryTree l,BinaryTre...
【机试练习】【C++】【codeup 1173 Problem A】算法9-9~9-12：平衡二叉树的基本操作
Me.Show
06-24 294
#include<cstdio> #include<cstring> #include<string> #include<vector> #include<algorithm> using namespace std; struct node{ int data = -1; int height = 1; node* lchild...
PAT1066 Root of AVL平衡二叉树的插入
weixin_44405344的博客
03-16 141
#include &lt;stdio.h&gt; #include&lt;iostream&gt; #include &lt;string.h&gt; #include &lt;string&gt; #include &lt;algorithm&gt; #include &lt;map&gt; #include &lt;vector&gt; #include &lt;set&gt;
二叉树基本操作
04-30
1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和...
二叉树基本操作_二叉树基本操作_
10-02
实现了基本的二叉树算法，利用链表实现，计算树高，插入删除等
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
二叉树 二叉树_基于C语言实现的二叉树基本操作
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
数据结构二叉树的基本操作，比较基础，初学者专用吧。。。
二叉树 基本操作
04-21
先序、中序、后序遍历二叉树(递归算法)!;3.中序遍历二叉树(非递归算法)!求二叉树的高度!求二叉树的叶子个数!;对于树中每一个元素值为x的结点，删去以它为根的子树，并释放相应的空间!借助队列实现二叉树的层次遍历!
1919 Problem A 二叉排序树
子衿
03-14 207
问题 A: 二叉排序树 时间限制:1 Sec内存限制:32 MB 提交:298解决:126 [提交][状态][讨论版][命题人:外部导入] 题目描述 输入一系列整数，建立二叉排序数，并进行前序，中序，后序遍历。 输入 输入第一行包括一个整数n(1&lt;=n&lt;=100)。接下来的一行包括n个整数。 输出 可能有多组测试数据，对于每组数据，将题目所给数据建立一个二...
*平衡二叉树基本操作*
Soleil的博客
08-11 353
typedef struct bitnode//存储结构 {     int data;     int d;     struct bitnode *lchild, *rchild; }* bitree; int deep(bitree &t)//求平衡因子 {     if(!t)         return -1;     return t->d; }
二叉树的基本操作<2>
cyd_csdn的博客
04-28 151
////根据先序遍历结果构造一棵树--“abd###c##”TreeNode* CreatTree(TreeNodeType cur[],size_t *index,size_t size,TreeNodeType null_value){ if(*index == size){ exit(0); } if(cur[*index] == null_value){ return NULL; } ...
『数据结构与算法』解读树(Tree)和二叉树(Binary Tree)！
AI新视界
08-26 510
『数据结构与算法』解读树和二叉树！ 文章目录一. 树1.1. 树的定义1.2. 树的基本术语1.3. 树的性质二. 二叉树2.1. 二叉树的定义2.2. 几种特殊的二叉树2.3. 二叉树的性质 ►之前解读的内容如下： 『数据结构与算法』解读链表！ 『数据结构与算法』解读栈和队列+STL！ 一. 树 1.1. 树的定义 ►树是 n(n≥0)n(n \geq 0)n(n≥0)个节点的有限集。当 n=0n = 0n=0 时，称为空树。在任意一颗非空树中应满足： ①有且仅有一个特定的称为根的结点。 ②
HHUOJ 1656 算法9-9~9-12：平衡二叉树的基本操作
旺崽的博客
08-30 3254
HHUOJ 1656 算法9-9~9-12：平衡二叉树的基本操作 题目描述 平衡二叉树又称AVL树，它是一种具有平衡因子的特殊二叉排序树。平衡二叉树或者是一棵空树，或者是具有以下几条性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值； 它的左右子树也分别为平衡二叉树，且左子树和右子...
二叉树基本操作的实现
10-25
下面是二叉树基本操作的实现方法： 1. 创建二叉树：通过前序遍历的数组构建二叉树，其中 '#' 表示空节点。具体实现方法可以参考引用中的 BinaryTreeCreate 函数。 2. 销毁二叉树：遍历二叉树，依次释放每个节点的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值