二叉树的建立以及相关操作

最新推荐文章于 2024-09-22 13:00:38 发布
最新推荐文章于 2024-09-22 13:00:38 发布
阅读量410 收藏
点赞数
分类专栏： 二叉树 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010469982/article/details/15966399
版权

这些日子学习二叉树，拖了很长时间来敲二叉树。水平有限，希望各位大牛多多指正。（由于调试比较多，代码风格不太好）

#include <iostream>
#include <queue>
#include <stack>
using namespace std;

template <class T>
class Node{
	public:
		T element;         //数据
		Node <T>* leftChild;        //左孩子结点
		Node <T>* rightChild;       //右孩子结点
	public:
		Node(){
			element = 0;
			leftChild = rightChild = NULL;
		}
		Node(T el,Node<T> *l,Node<T> *r){
			element = el;
			leftChild = l;
			rightChild = r;
		}
		~Node(){}   //默认析构
		void setLeftChild(Node<T>* l);   //设置左孩子结点
		void setRightChild(Node<T>* r);   //设置右孩子结点
		void setValue(const T& val);   // 设置该结点数据
		T getvalue() const;        //返回该结点的数据

		bool isLeaf() const;  //判断该节点是否是叶子结点
		
};


template <class T>
void Node<T>::setValue(const T& val)
{
	element = val;
}


template <class T>
bool Node<T>::isLeaf() const
{
	if (leftChild == NULL && rightChild == NULL)
		return 1;
	else
		return 0;
}


template <class T>
T Node<T>::getvalue() const
{
	return element;
}


template <class T>
void Node<T>::setLeftChild(Node<T>* l)
{
	leftChild = l;
}


template <class T>
void Node<T>::setRightChild(Node<T>* r)
{
	rightChild = r;
}


//二叉树类
template <class T>
class Tree
{
	public:
		Node <T>* root;
	public:
		Tree();//默认构造
	
	~Tree();   //析构
	  	friend Node<T> *makeTree(Node <T>* root);  //建立树 ______///
		bool isEmpty() const;   //判断二叉树是否为空
		Node<T> * getRoot() const; //返回二叉树的根节点
		void del(Node<T>* r);

		void preOrder(Node<T>* root);//前序优先遍历
		void inOrder(Node<T>* root);//中序遍历
		void postOrder(Node<T>* root);//后序优先遍历

		friend void levelOrder();//广度优先遍历

		void preOrder();//前序优先遍历（非递归）
		void inOrder();//中序优先遍历（非递归）
		void postOrder();//后序优先遍历（非递归）

		void NodeCount(Node<T>* root);//求度为特定值的结点个数

		int High(Node<T>* root,int high);//求树的高度

		int MaxValue(Node<T>* root);//求最大的结点

		void Exchang(Node<T>* root);//交换每个结点的左孩子结点和右孩子结点

		void DelLeaf(Node<T>* root);//删除所有叶子结点

		int Width(Node<T>* root);//递归求二叉树的宽度

		bool JudgeComplete(Node<T>* root);//判断该二叉树是否为完全二叉树

};

template <class T>
Node<T> * Tree<T>::getRoot() const
{
	return root;
}

template <class T>
bool Tree<T>::isEmpty() const
{
	if (root == NULL)
		return 1;
	else
		return 0;
}

template <class T>
Tree<T>::Tree()
{
	root = NULL;
}

template <class T>
Tree<T>::~Tree()             //析构函数有问题
{
	Node <T>* temp;
	temp = root;
	if (temp != 0)
	{
		del(temp->leftChild);
		del(temp->rightChild);
	}
}

template <class T>
void Tree<T>::del(Node<T>* r)
{
	delete r;
}


template <class T>
Node <T>* makeTree(Node <T>* root)        // 递归 建立树   //
{
//	if (root)
//		root = new Node(el,left.root,right.root);
//	left.root = right.root = NULL;

	T te;
	cin>>te;
	

	if (te != -1)
	{
		root = new Node<T>;
		root->element = te;
	//	cout<<root->element<<"的左子树"<<endl;
		cout<<"输入"<<root->element<<"的左孩子"<<endl;
		root->leftChild = makeTree(root->leftChild);
	//	cout<<root->element<<"的右子树"<<endl;
		cout<<"输入"<<root->element<<"的右孩子"<<endl;
		root->rightChild = makeTree(root->rightChild);
	
	}

	else
	{
	//	cout<<root<<endl;
		root = NULL;
	}
	return root;     

}

template<class T>
bool Tree<T>::JudgeComplete(Node<T>* root)       //判断是否为完全二叉树
{
	queue<Node<T> *> nodeQueue;
	Node <T>* pointer = root;

	if(pointer)
		nodeQueue.push(pointer);
	while (!nodeQueue.empty())
	{
		pointer = nodeQueue.front();
//		cout<<pointer->element<<" ";
		if (pointer == NULL)
			break;
		nodeQueue.pop();
		nodeQueue.push(pointer->leftChild);
		nodeQueue.push(pointer->rightChild);
	}
	while (!nodeQueue.empty())
	{
		pointer = nodeQueue.front();
		if (pointer != NULL)
			return 0;
		nodeQueue.pop();
	}
	return 1;
}





//统计二叉树的宽度
template<class T>
int Tree<T>::Width(Node<T>* root)
{
	int l = 0;
	int r = 0;
	if (root)
	{
		if (root->leftChild == NULL && root->rightChild == NULL)
			return 1;
		else
		{
			if (root->leftChild != NULL)
				l = Width(root->leftChild);
			if (root->rightChild != NULL)
				r = Width(root->rightChild);
		}
	}

	return l+r;
}







//删除所有叶子结点

Node<int>* temp;
template<class T>

void Tree<T>::DelLeaf(Node<T>* root)
{
	
	if (root)
	{
		if (root->leftChild == NULL && root->rightChild == NULL)
		{
			if (temp->leftChild == root)
			{
				temp->leftChild = NULL;
				delete root;
				root = NULL;
			}
			else if (temp->rightChild == root)
			{
				temp->rightChild = NULL;
				delete root;
				root = NULL;
			}
		}
	
	if (root)	
	{	
		temp = root;
		DelLeaf(root->leftChild);
		DelLeaf(root->rightChild);
	}
	}
}






//交换每个结点的左孩子结点和右孩子结点
template<class T>
void Tree<T>::Exchang(Node<T>* root)
{
	Node<T>* p;  //temp
	if (root)
	{
/*		if (root->leftChild == NULL)
			root->leftChild = root->rightChild;
		else if (root->rightChild == NULL)
			root->rightChild = root->leftChild;*/
//		else
//		{
			p = root->leftChild;
			root->leftChild = root->rightChild;
			root->rightChild = p;
//		}
	Exchang(root->leftChild);
	Exchang(root->rightChild);
	}

}






//求最大值的元素
template<class T>
int Tree<T>::MaxValue(Node<T>* root)
{
	int a;
	if (root)
	{
		if (root->leftChild == NULL && root->rightChild == NULL)
			return root->element;
		else if (root->leftChild == NULL)
		{
			if (root->element >= MaxValue(root->rightChild))
				return root->element;
			else
				return MaxValue(root->rightChild);
		}
		else if (root->rightChild == NULL)
		{
			if (root->element >= MaxValue(root->leftChild))
				return root->element;
			else
				return MaxValue(root->leftChild);
		}
		else
		{
		if (root->element >= MaxValue(root->leftChild))
			a = root->element;
		else           //(root->element < MaxValue(root->leftChild))
			a = MaxValue(root->leftChild);
		if (a >= MaxValue(root->rightChild))
			return a;
		else
			return MaxValue(root->rightChild);
		}
	}
//	if (root->leftChild == NULL && root->rightChild == NULL)
//		return root->element;
}





//计算特定度的结点个数
int count0 = 0;
int count1 = 0;
int count2 = 0;
template<class T>
void Tree<T>::NodeCount(Node<T>* root)
{ 
	if (root)
	{
		NodeCount(root->leftChild);
		if (root->leftChild == NULL && root->rightChild == NULL)
			count0++;
		if ((root->leftChild == NULL && root->rightChild != NULL) || (root->leftChild != NULL && root->rightChild == NULL))
			count1++;
		if (root->leftChild != NULL && root->rightChild != NULL)
			count2++;
		NodeCount(root->rightChild);
	}
}


template<class T>
int Tree<T>::High(Node<T>* root,int high)       //求树的高度
{
	if (root)
	{
		if (root->leftChild == NULL && root->rightChild == NULL)
			high = 0;
		else
		{
			if (High(root->leftChild,high) >= High(root->rightChild,high))
				high += High(root->leftChild,high);
			else
				high += High(root->rightChild,high);
		}

	}
	return high;
}


//广度优先遍历
template <class T>
void levelOrder(Node <T>* root)
{
	queue<Node<T> *> nodeQueue;
	Node <T>* pointer = root;
	
	cout<<"=====广度优先遍历====="<<endl;

	if(pointer)
		nodeQueue.push(pointer);
	while (!nodeQueue.empty())
	{
		pointer = nodeQueue.front();
		cout<<pointer->element<<" ";
		nodeQueue.pop();
		if (pointer->leftChild)
			nodeQueue.push(pointer->leftChild);
		if (pointer->rightChild)
			nodeQueue.push(pointer->rightChild);
	}
}

//前序遍历
template <class T>
void Tree<T>::preOrder(Node<T>* root)
{
	//cout<<"======前序遍历======";
	if (root != NULL)
	{
		cout<<root->element<<"  ";
		preOrder(root->leftChild);
		preOrder(root->rightChild);
	}
}

//中序遍历
template <class T>
void Tree<T>::inOrder(Node<T>* root)
{
	if (root != NULL)
	{
		
		inOrder(root->leftChild);
		cout<<root->element<<"  ";
		inOrder(root->rightChild);
	}
}

//后序遍历
template <class T>
void Tree<T>::postOrder(Node<T>* root)
{
	if (root != NULL)
	{
		postOrder(root->leftChild);
		postOrder(root->rightChild);
		cout<<root->element<<"  ";
	}
}


template <class T>
void Tree<T>::preOrder()     //前序遍历二叉树（非递归形式）
{
	stack<Node<T> *> nodestack;
	Node <T>* pointer = root;   //保存根节点
	
	cout<<"========前序遍历二叉树（非递归）========="<<endl;
	while(!nodestack.empty() || pointer)
	{
		if (pointer){
			cout<<pointer->element<<"  ";
			if (pointer->rightChild != NULL)
				nodestack.push(pointer->rightChild);
			pointer = pointer->leftChild;
		}
			else
			{
				pointer = nodestack.top();
				nodestack.pop();
			}
	}
}

template <class T>
void Tree<T>::inOrder()      //中序遍历二叉树（非递归形式 ）
{
	stack<Node<T> *> nodestack;
	Node <T>* pointer = root;//保存根节点

	cout<<"========中序遍历二叉树（非递归）========="<<endl;
	while (!nodestack.empty() || pointer)
	{
		if (pointer){
			nodestack.push(pointer);

			
		//	cout<<pointer->element<<"  ";
		
			pointer = pointer->leftChild;
		
		}
		else
		{
			pointer = nodestack.top();
			cout<<pointer->element<<"  ";
			pointer = pointer->rightChild;
			nodestack.pop();
		}
	}
}

template <class T>
/*void Tree<T>::postOrder()//后序优先遍历（非递归）
{
	stack<Node<T> *> nodestack;
	Node <T>* pointer = root;
	int temp = 0;
	int s = 0;
	while (!nodestack.empty() || pointer)
	{
		if (pointer && s == 0){
			nodestack.push(pointer);
			pointer = pointer->leftChild;
			temp = 0;
			s = 0;
		}
		else if (pointer && s == 1)
		{
			pointer = nodestack.top();
			nodestack.pop();
		}
		else if(temp == 0)
		{
			temp = 1;
			pointer = nodestack.top();
			pointer = pointer->rightChild;
		//	nodestack.pop();
		}
		else 
		{
			cout<<pointer->element<<"  ";
			pointer = nodestack.top();
			nodestack.pop();
			s = 1;
			
		}
	}
}*/

void Tree<T>::postOrder() //后序优先遍历
{
	stack<Node <T>*> nodestack;
	Node <T>* pointer = root;
	Node <T>* pre = root;//保存前一个被访问的结点
	cout<<"========后序遍历二叉树（非递归）========="<<endl;
	while (pointer)
	{
		for (;pointer->leftChild != NULL;pointer = pointer->leftChild)
			nodestack.push(pointer);//将所有左孩子结点压栈

		while (pointer != NULL && (pointer->rightChild == NULL || pointer->rightChild == pre)){
			cout<<pointer->element<<"  ";
			pre = pointer;
			if (nodestack.empty())
				return;
			pointer = nodestack.top();//
			nodestack.pop();
		}

		nodestack.push(pointer);
		pointer = pointer->rightChild;  //转向右子树
	}
}


int main()
{
	Tree<int> t;

	t.root = makeTree(t.root);
/*	
//	cout<<t.getRoot();
	levelOrder(t.root);
	cout<<endl<<"======前序遍历======"<<endl;
	t.preOrder(t.root);
	cout<<endl<<"======中序遍历======"<<endl;
	t.inOrder(t.root);
	cout<<endl<<"======后序遍历======"<<endl;
	t.postOrder(t.root);

	cout<<endl;
	t.preOrder();
	
	cout<<endl;
	t.inOrder();
	
	cout<<endl;
	t.postOrder();
*/
	t.NodeCount(t.root);            //计算度为0,1,2的结点的个数
	cout<<"度为0的结点的个数为："<<count0<<endl<<"度为1的结点的个数为："<<count1<<endl<<"度为2的结点的个数为："<<count2<<endl;

	cout<<"该二叉树的高度为："<<t.High(t.root,1)<<endl;

	cout<<"该二叉树的最大元素的值为:"<<t.MaxValue(t.root)<<endl;

/*	t.Exchang(t.root);
	cout<<"每个结点的左孩子结点和右孩子结点都已经交换"<<endl;
	t.preOrder();

	t.DelLeaf(t.root);
	cout<<"删除叶子结点后的结果:"<<endl;
	t.preOrder();

	cout<<"该二叉树的宽度为："<<t.Width(t.root)<<endl;
*/
	if (t.JudgeComplete(t.root))
		cout<<"该二叉树是完全二叉树";
	else
		cout<<"该二叉树不是完全二叉树";
	return 0;
}


未成年程序员
关注
专栏目录
C++二叉树结构的建立与基本操作
09-04
在C++中，二叉树是一种重要的数据结构，它由一系列结点组成，每个结点最多有两个子结点...熟练掌握二叉树的建立和操作是提升编程技能的重要一环。通过练习和理解这些基本操作，可以为解决更复杂的问题打下坚实的基础。
二叉树的建立和操作
12-01
主要内容： 设计一个与二叉树基本操作相关的程序。程序的主要功能如下： ①以树状形式输出； ②以先序、中序、后序三种方式输出； ③统计输出二叉树的结点总数、叶子总数、树高。
二叉树的建立及操作
07-13
二叉树是一种特殊的树数据结构，它每个节点最多有两个子节点，通常分为左子节点和右子节点。在计算机科学中，二叉树是数据结构和算法的重要组成部分，...熟练掌握二叉树的建立和操作，将为你的编程技能打下坚实的基础。
二叉树基本操作
04-30
1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和...
二叉树_二叉树的基础操作_
09-30
这些操作都是建立在对二叉树结构理解的基础上，通过递归或迭代的方式来实现。 总结来说，二叉树是一种重要的数据结构，它的基础操作包括节点定义、树的生成以及遍历。理解和熟练掌握这些操作是学习更高级算法和数据...
Pandas_数据结构详解
2201_75415080的博客
09-19 1216
DataFrame是一个表格型的==结构化==数据结构，它含有一组或多组有序的列（Series），每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame是Pandas中最基本的数据结构，Series的许多属性和方法在DataFrame中也一样适用.两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。
数据结构：二叉树（一）
2303_78940834的博客
09-21 749
ps：偷懒了几天，接着更新。
数据结构——二叉树堆的专题
imaima666的博客
09-19 794
如果有一个关键码的集合K = {K0 ，K1 ，K2 ，K3…) i = 0，1， 2…，则称为(或将。
数据结构—树
最新发布
2301_80151359的博客
09-22 429
在文件系统中，树结构被广泛应用，它通过父结点和子结点之间的关系来表示不同层级的文件和文件夹之间的关联。树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系。若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点。以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙。一个结点含有的子树的根结点称为该结点的子结点；1.有一个特殊的结点，称为根结点，根结点没有前驱结点。具有相同父结点的结点互称为兄弟结点(亲兄弟)；
每日学习一个数据结构-哈夫曼树Huffman Tree
wendao76的专栏
09-20 577
哈夫曼树的主要应用领域包括数据压缩和传输优化。例如，在文件压缩软件中，使用哈夫曼编码可以有效地减少文件大小，从而节省存储空间或加快文件在网络上的传输速度。哈夫曼树（Huffman Tree）是一种特殊的二叉树，用于最小化带权路径长度，通常应用于数据压缩。假设有四个字符A、B、C、D，它们的频率分别为5、9、12、13。通过这种方式，可以有效地压缩原始数据。
Java 中 Map 常用类和数据结构详解
J老熊
09-19 1361
在Java编程中，Map是一种重要的数据结构，广泛应用于各种场景，Map实现了键值对（key-value）的存储方式，使得开发者能够快速检索、更新和操作数据。本篇文章将详细讲解Java中常用的Map类及其底层数据结构，并通过电商交易系统中的实际应用场景来分析每种Map的使用场景和区别。
数据结构：顺序表
qq_71391318的博客
09-19 1202
顺序表的基本功能
数据结构之“队列”
2402_83250773的博客
09-19 574
队列的入数据，出数据，取队头尾元素，有效个数
集合框架底层使用了什么数据结构
2401_83418369的博客
09-19 586
集合框架（Collection Framework）是Java标准库的一部分，它提供了一系列接口和实现类，用于处理不同类型的集合。这些集合可以用于存储和操作对象，如列表、集合、映射等。集合框架的底层数据结构是多种多样的，具体取决于集合实现类的选择。
【算法与数据结构复习】| 堆结构和堆排序
qq_48232837的博客
09-20 280
今天跟着左程云算法课25复习了堆结构和堆排序相关内容。对于一个数据nums，我们可以将其理解为一个完全二叉树。完全二叉树就是指按照层次来添加数，每层满了再往下一层添加。对于数组中下标i，其父节点的下标为(i-1)/2，左孩子的下标为2*i+1，右孩子的下标为2*i+2。在堆结构中有两个重要的步骤：1）i位置的数，向上调整大根堆。2）i位置的数，向下调整大根堆，当前堆大小为size。
Pandas中DataFrame表格型数据结构
weixin_43597208的博客
09-19 534
series是有一组数据与一组索引（行索引）组成的数据结构，而dataframe是由一组数据与一对索引（行索引和列索引）组成的表格型数据结构。总结：直接以字典的形式传入dataframe时，字典的key值就相当于列索引，如果没有设置行索引，行索引还是使用从0开始的默认索引，同样可以使用index参数自定义行索引。2.当传入一个嵌套列表时，会根据嵌套列表数显示成多列数据，行、列索引同样是从0开始的默认索引。1.只传入一个单一列表时，该列表的值会显示成一列，且行和列都是从0列开始的默认索引。
【数据结构-差分】【hard】力扣995. K 连续位的最小翻转次数
sjsjs11的博客
09-19 1212
k位翻转 就是从 nums 中选择一个长度为 k 的 子数组 ，同时把子数组中的每一个 0 都改成 1 ，把子数组中的每一个 1 都改成 0。翻转 A[0],A[1],A[2]: A变成 [1,1,1,1,0,1,1,0]翻转 A[4],A[5],A[6]: A变成 [1,1,1,1,1,0,0,0]翻转 A[5],A[6],A[7]: A变成 [1,1,1,1,1,1,1,1]输入：nums = [0,0,0,1,0,1,1,0], K = 3。输入：nums = [0,1,0], K = 1。
数据结构 ——— 算法的时间复杂度
weixin_55341642的博客
09-20 429
在实际中我们计算时间复杂度时，并不一定要计算精确的执行次数，只需要大概的执行次数，那么就需要使用大O的渐进表示法
【探索数据结构与算法】插入排序：原理、实现与分析（图文详解）
2302_80220709的博客
09-16 1143
因此，第i个元素需要比较i次（其中i从2开始，直到n），总共需要进行的比较次数大约为1 + 2 + 3 + ... + (n-1) = n(n-1)/2，时间复杂度为O(n^2)。当输入数组已经是排序状态时，插入排序的性能最优。插入排序是一种原地排序算法，它只需要一个额外的存储空间来暂存当前需要插入的元素（即“key”），而不需要额外的数组来存储排序过程中的数据。在插入排序过程中，如果两个相等的元素，后面的元素不会移动到前面元素的前面，而是直接插入到与它相等的元素之后，从而保持了原有的相对顺序。
中序线索二叉树的建立与操作
"线索二叉树的建立、删除、插入、恢复线索" 线索二叉树是一种特殊的二叉链表，它的主要目的是为了...在设计和实现线索二叉树时，关键在于正确处理节点的空指针域，以及在操作后及时更新线索信息，以维护线索的完整性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值