二叉树的基本操作

最新推荐文章于 2020-04-28 16:36:07 发布
最新推荐文章于 2020-04-28 16:36:07 发布
阅读量428 收藏 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
关注
专栏目录
【算法笔记第9.5节-平衡二叉树 】问题 A: 算法9-9~9-12：平衡二叉树的基本操作
xunalove的博客
03-16 445
题目描述 平衡二叉树又称AVL树，它是一种具有平衡因子的特殊二叉排序树。平衡二叉树或者是一棵空树，或者是具有以下几条性质的二叉树： 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值； 3. 它的左右子树也分别为平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。 ...
平衡二叉树所涉及的一些算法
wangxiaohigh
12-06 286
今晚整那个ubuntu，什么也没弄成，唉，把算法先保留一下吧， 插入函数还没理解透彻呢 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define NULL 0 ...
HHUOJ 1656 算法9-9~9-12：平衡二叉树的基本操作
旺崽的博客
08-30 3276
HHUOJ 1656 算法9-9~9-12：平衡二叉树的基本操作 题目描述 平衡二叉树又称AVL树，它是一种具有平衡因子的特殊二叉排序树。平衡二叉树或者是一棵空树，或者是具有以下几条性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值； 它的左右子树也分别为平衡二叉树，且左子树和右子...
【机试练习】【C++】【codeup 1173 Problem A】算法9-9~9-12：平衡二叉树的基本操作
Me.Show
06-24 333
#include<cstdio> #include<cstring> #include<string> #include<vector> #include<algorithm> using namespace std; struct node{ int data = -1; int height = 1; node* lchild...
二叉树的一些基本操作
zxjkl123的博客
04-28 112
二叉树的一些基本操作 package bin1; //一、二叉树的一些基础操作 class TreeNode{ char value; TreeNode left; TreeNode right; public TreeNode(char value){ this.value=value; } } public class Binary...
二叉树基本操作
04-30
1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和...
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。 二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
c语言版本二叉树基本操作示例(先序递归非递归)共10页.p
10-29
本文将深入探讨C语言实现的二叉树基本操作，包括递归和非递归两种方法，以及先序遍历的概念。在标题和描述中提及的“c语言版本二叉树基本操作示例(先序递归非递归)共10页”很可能是一个详细的教程或代码示例集合，...
PAT1066 Root of AVL平衡二叉树的插入
weixin_44405344的博客
03-16 180
#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;
二叉树基本操作的实现
10-25
下面是二叉树基本操作的实现方法： 1. 创建二叉树：通过前序遍历的数组构建二叉树，其中 '#' 表示空节点。具体实现方法可以参考引用中的 BinaryTreeCreate 函数。 2. 销毁二叉树：遍历二叉树，依次释放每个节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值