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

最新推荐文章于 2024-09-20 19:40:22 发布
最新推荐文章于 2024-09-20 19:40:22 发布
阅读量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;
}


未成年程序员
关注
专栏目录
二叉树的基本操作
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
二叉树的建立以及相关操作 超详细注释の C++代码 + 代码逻辑 + 图解二叉树递归过程！
一碗菜粥的博客
05-17 1284
二叉树的建立以及相关操作——超详细注释の C++代码 + 代码逻辑 + 图解二叉树递归过程！
C语言实现二叉树的建立与操作
qq_64404343的博客
11-16 1579
教会你如何使用c语言ko二叉树
二叉树建立及其基本操作
qq_35008554的博客
11-13 855
二叉树的建立 方法一：按完全二叉树的层次顺序，依次输入结点信息建立二叉链表。 基本思想：一般的二叉树添加虚结点成为完全二叉树；依次输入结点信息，每进入一个字符建立一个节点， 无论是否为虚拟节点，虚拟节点下可以继续接入虚拟节点。 若是第一个结点，则令其为根结点，否则将新结点插入到它的双亲结点上。 用队列来实现这种先入先操作的数据结构，这里我就数组实现队列了。 如此重复，直到输入结束符号“
二叉树的建立与基本操作
Cosmo9的博客
10-13 336
编写程序实现二叉树的如下操作：1) 建立二叉链表2) 二叉树的先序、中序、后序遍历3) 求二叉树的叶子结点个数4) 将二叉树中所有结点的左、右子树相互交换按完全二叉树的层次关系给出二叉树的遍历序列（#表示虚结点，数据结点为单一字符）。二叉树的凹入表示二叉树的先序序列、中序序列、后序序列二叉树叶子结点个数左、右子树相互交换后的二叉树的凹入表示左、右子树相互交换后的二叉树的先序序列、中序序列、后序序列。
二叉树的建立以及三种遍历操作
qq_38846633的博客
09-01 1万+
      由二叉树结点的性质可以确定的是，二叉树结构相比普通的链表结点而复杂，需要通过其左/右指针访问其左/右子树结点。而在熟悉了二叉树的结构后，需要注意的是二叉树的建立以及遍历操作。而建立与遍历两种操作，需要利用的是递归的思想，即保持每一个子集函数操作与其父函数相同。     首先明确三个概念，前序，中序，后序。这三种概念主要是访问结点及其子树的方式区别，在二叉树的构造以及遍历操作之中均有应...
二叉树的建立及其基本操作实验报告
耗子煨汁的博客
11-01 1万+
一、实验目的 掌握二叉树的链式存储结构的建立方法和对二叉树的各种操作算法。利用二叉树的基本操作，构造哈夫曼树。 二、实验内容1 问题描述 (1)、按照前序次序建立一棵二叉树； (2)、用前、中、后序递归遍历的方法遍历二叉树； (3)、求二叉树的深度； 数据结构及算法设计 首先，使用结构体建立树的基本结构BTNode，包括data，lchild，rchild。 再按照前序次序建立一颗二叉树，第一个元素是根节点，遇到‘#’将该结点定为空结点，遍历字符串，就按照前序次序建立了一颗树。 然后按照前序递归遍历
十七、二叉树的建立与基本操作
qq_42582489的博客
11-01 2237
十七、二叉树的建立与基本操作 文章目录十七、二叉树的建立与基本操作题目描述解题思路上机代码一点建议 题目描述 编写程序实现二叉树的如下操作： 建立二叉链表 二叉树的先序、中序、后序遍历 求二叉树的叶子结点个数 将二叉树中所有结点的左、右子树相互交换 输入： 按完全二叉树的层次关系给出二叉树的遍历序列（#表示虚结点，数据结点为单一字符）。 输出： 二叉树的凹入表示 　　二叉树的先序序列、中序序列、后序序列 　　二叉树叶子结点个数 　　左、右子树相互交换后的二叉树的凹入表示 　　左、右子树相互交换后的二叉树
数据结构实验 二叉树的基本操作
热门推荐
weixin_45111284的博客
05-06 3万+
数据结构实验 二叉树的基本操作 实验环境： Visual C++ 实验目的： 1．掌握二叉树的定义； 2．掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深 度计算等。 实验内容： 用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度...
17. 二叉树的建立与基本操作
鱼香肉丝没有鱼的博客
10-28 1250
1 问题 编写程序实现二叉树的如下操作：1) 建立二叉链表2) 二叉树的先序、中序、后序遍历3) 求二叉树的叶子结点个数4) 将二叉树中所有结点的左、右子树相互交换 输入：　　扩展二叉树先序序列：ab#d##ce###。其中#代表空指针。 输出：　　二叉树的凹入表示　　二叉树的先序序列、中序序列、后序序列　　二叉树叶子结点个数　　左、右子树相互交换后的二叉树的凹入表示　　左、右子树相互交换后的二叉树的先序序列、中序序列、后序序列。 说明：　　在输出凹入表示的二叉树时，先输出根结点，然后依次输出左右子树，上
数据结构-二叉树的建立及遍历操作
05-23
数据结构-二叉树的建立及遍历操作
C++二叉树结构的建立与基本操作
09-04
在C++中，二叉树是一种重要的数据结构，它由一系列结点组成，每个结点最多有两个子结点...熟练掌握二叉树的建立和操作是提升编程技能的重要一环。通过练习和理解这些基本操作，可以为解决更复杂的问题打下坚实的基础。
二叉树的建立和操作
12-01
主要内容： 设计一个与二叉树基本操作相关的程序。程序的主要功能如下： ①以树状形式输出； ②以先序、中序、后序三种方式输出； ③统计输出二叉树的结点总数、叶子总数、树高。
二叉树建立遍历
01-03
本主题主要关注的是二叉树的建立以及它的遍历方法——中序遍历和后序遍历。 首先，我们需要理解如何建立二叉树。二叉树的建立通常有两种方式：一种是通过序列化数据（如字符串或数组）来构建，另一种是动态创建。...
数据结构 - 树与二叉树
kaneki_lh的博客
09-17 525
/数据域//左结点与右结点的指针。
【刷题】数据结构——Java常见数据结构
qq_42581685的博客
09-16 341
【代码】【刷题】数据结构——Java常见数据结构。
王道408考研数据结构-栈、队列和数组-第三章
最新发布
qq_55882840的博客
09-20 965
3.1 栈3.1.1 栈的基本概念1.栈的定义栈(Stack)是只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作，如图3.1所示。栈顶(Top)。线性表允许进行插入删除的那一端。栈底(Bottom)。固定的，不允许进行插入和删除的另一端。空栈。不含任何元素的空表。3.1.2 栈的顺序存储结构栈是一种操作受限的线性表，类似于线性表，它也有对应的两种存储方式。1.顺序栈的实现。
数据结构二
m0_73504072的博客
09-17 812
在64位得计ge算机下 共32个字节long 是占8个字节 但是32位得情况下24个字节 long 占4个字节但是所以可以分配在 char得内存地址中 ，所以占8个字节 而char占8个字节 而 double占8个字节24个字节。在计算机是这样存储得但计算机时小段存储所以在存储书记时低地址存在高位 而低地址存在低位 所以 存储方式应该是 0x 00050003。12 char被分配4个内存 short被分配到 x1 而float分配4个字节而x4则分配4个字节。④按照学生的分数进行排序。
数据结构强化（直播课）
宝藏Coder的空间
09-20 319
强化课笔记和重点
中序线索二叉树的建立与操作
"线索二叉树的建立、删除、插入、恢复线索" 线索二叉树是一种特殊的二叉链表，它的主要目的是为了...在设计和实现线索二叉树时，关键在于正确处理节点的空指针域，以及在操作后及时更新线索信息，以维护线索的完整性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值