二叉树的基本操作

最新推荐文章于 2022-10-15 16:22:21 发布
最新推荐文章于 2022-10-15 16:22:21 发布
阅读量346 收藏 2
点赞数
文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zxd_bk/article/details/53576507
版权
二叉树:(1)每个结点都不大于2;(2)每个结点的孩子结点次序都不能颠倒。
满二叉树:深度为k的且有2^k-1个结点的二叉树
完全二叉树:深度为k，结点树为n的二叉树，如果其中结点1~n的位置序号分别与满二叉树的结点1~n的序号一一对应，则为完全二叉树。
满二叉树必为完全二叉树，完全二叉树不一定是满二叉树
二叉树的性质：
(1)在二叉树的第i层上之多有2^(i-1)结点
(2)深度为k的二叉树之多有2^k-1个结点
(3)对任意二叉树T，若叶子结点(度为0)的数为n0，而其度为2的结点数为n2，则n0=n2+1
(4)具有n的结点的完全二叉树的深度为(log2n)向下取整加1
(5)对于具有n个结点的完全二叉树，如果按照从上到下和从左到右的顺序对二叉树中的所有结点从1开始顺序编号，
则对于任意的序号为i的结点有：
1.如果i=1，则序号为i的结点是跟结点，无双亲结点；如果i>1，则序号为i的结点的双亲结点i/2向下取整
2.如果2*i > n，则序号为i的结点无右孩子，如果2*i <= n，则序号为i的结点的左孩子结点的序号为2*i
3.如果2*i+1 > n，则序号为i的结点无右孩子，如果2*i+1 <= n，则序号为i的结点的右孩子结点的序号为2*i+1 
#ifndef TreeHead_h__
#define TreeHead_h__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <iostream>

typedef struct _BTree
{
	char data;
	struct _BTree *lChild;
	struct _BTree *rChild;
}BTreeNode;

/************************************************************************/
/*									*/
/*		二叉树的基本操作---销毁、创建、判断是否为空 		*/
/*									*/
/************************************************************************/
//销毁一棵树
void DestroyBTree(BTreeNode **BTNode);
void DestroyBTree_Quene(BTreeNode **BTNode);

//创建一棵树
void CreateBTree(BTreeNode **BTNode);

//判断树是否为空
bool BTreeEmpty(BTreeNode *BTNode);

//删除左子树
void DeleteLeftTree(BTreeNode ** BTNode);

//删除右子树
void DeleteRightTree(BTreeNode **BTNode);

//输出树中的叶子结点
void PreOrderLeafNode(BTreeNode *BTNode);
/************************************************************************/
/*									*/
/*	根据遍历结果重新构建二叉树---前序和中序、后序和中序	        */
/*									*/
/************************************************************************/
//根据先序和中序构建二叉树
BTreeNode *CreateTreeBy_PreMid(char *prestr, char *midstr);//OK

/************************************************************************/
/*									*/
/*		二叉树的遍历---递归和非递归			        */
/*									*/
/************************************************************************/
//树的递归遍历
void PreOrderTraverse(BTreeNode *BTNode);
void InOrderTraverse(BTreeNode *BTNode);
void PostOrderTraverse(BTreeNode *BTNode);

//树的非递归遍历
void PreOrder(BTreeNode *BTNode);
void InOrder(BTreeNode *BTNode);
void PostOrder(BTreeNode *BTNode);

//层序遍历二叉树
void LayerOrder(BTreeNode *BTNode);

/************************************************************************/
/*									*/
/*		判断二叉树的属性---高度、结点个数、叶子结点个数         */
/*									*/
/************************************************************************/
//返回树的深度
int BTreeDepth(BTreeNode *BTNode);

//统计叶子结点的数目
int LeafCount(BTreeNode *BTNode);

//统计叶子结点数目的递归算法
int LeafCount_CUR(BTreeNode *BTNode);

//得到二叉树结点的个数
int GetBTreeLeafCount(BTreeNode *BTNode);

/************************************************************************/
/*							 		*/
/*			根据条件返回结点---值、结点			*/
/*									*/
/************************************************************************/
//求二叉树中结点x的双亲结点
BTreeNode *Find_Parent(BTreeNode *BTNode, BTreeNode *node);

//返回节点x的左孩子，若结点无左孩子或者x不在树中，返回NULL
BTreeNode *LeftChild(BTreeNode *BTNode, BTreeNode *node);

//返回结点x的右孩子，若结点无右孩子或者x不在书中，返回NULL
BTreeNode *RightChild(BTreeNode *BTNode, BTreeNode *node);

//查找结点
BTreeNode *SearchNode(BTreeNode *BTNode, char value);

//给树的节点old赋值为new
void Assign(BTreeNode *BTNode, BTreeNode *Search, int newvalue);

/************************************************************************/
/*		 							*/
/*	判断二叉树的状态---相等、满二叉树、平衡二叉树、完全二叉树  	*/
/*									*/
/************************************************************************/
//判断两二叉树是否相等
bool IsEqual(BTreeNode *BTree1, BTreeNode *BTree2);

//判断二叉树是否为满二叉树
bool IsFullBTree(BTreeNode *BTNode);

//判断二叉树是否为完全二叉树
bool IsCompleteBTree(BTreeNode *BTNode);
//判断二叉树是否为平衡二叉树
bool IsBalanceBTree(BTreeNode *BTNode);

/************************************************************************/
/*									*/
/*			二叉树的其他操作			        */
/*									*/
/************************************************************************/

//交换二叉树的左右子女
void ExchangeChild(BTreeNode **BTNode);//OK

#endif // TreeHead_h__







#include <stack>
#include <queue>
#include "TreeHead.h"

//销毁一棵树
void DestroyBTree(BTreeNode **BTNode)
{
	if ((*BTNode) != NULL)
	{
		DestroyBTree(&(*BTNode)->lChild);
		DestroyBTree(&(*BTNode)->rChild);

		free((*BTNode));
		BTNode = NULL;
	}
}

//二叉树的非递归销毁方式
/************************************************************************/
/* 采用层序遍历的思想，销毁                                             */
/************************************************************************/
void DestroyBTree_Quene(BTreeNode **BTNode)
{
	std::queue<BTreeNode *> queueBTree;
	BTreeNode *TempNode = NULL;
	
	if ((*BTNode) == NULL)
	{
		return;
	}
	
	TempNode = *BTNode;

	queueBTree.push(TempNode);

	while(!queueBTree.empty())
	{
		TempNode = queueBTree.front();
		queueBTree.pop();

		if (TempNode->lChild != NULL)
		{
			queueBTree.push(TempNode->lChild);
		}

		if (TempNode->rChild != NULL)
		{
			queueBTree.push(TempNode->rChild);
		}

		free(TempNode);
	}
}

//创建一棵树
void CreateBTree(BTreeNode **BTNode)
{
	char ch;
	scanf("%c", &ch);

	if ('#' == ch)
	{
		*BTNode = NULL;
	}
	else
	{
		(*BTNode) = (BTreeNode *)malloc(sizeof(BTreeNode));
		(*BTNode)->data = ch;
		CreateBTree(&(*BTNode)->lChild);
		CreateBTree(&(*BTNode)->rChild);
	}
}

//判断树是否为空
bool BTreeEmpty(BTreeNode *BTNode)
{
	if (BTNode == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//求二叉树中结点x的双亲结点
BTreeNode *Find_Parent(BTreeNode *BTNode, BTreeNode *node)
{
	BTreeNode *Temp = NULL;

	if (NULL == BTNode || node == BTNode->lChild || node == BTNode->rChild)
	{
		return BTNode;
	}

	Temp = Find_Parent(BTNode->lChild, node);
	
	if (NULL == Temp)
	{
		Temp = Find_Parent(BTNode->rChild, node);
	}
	return Temp;
}

//返回节点x的左孩子，若结点无左孩子或者x不在树中，返回NULL
BTreeNode *LeftChild(BTreeNode *BTNode, BTreeNode *node)
{
	BTreeNode *Result = NULL;

	if (BTNode != NULL)
	{
		if(BTNode->lChild != NULL && BTNode->lChild == node || BTNode->rChild == node)
		{
			Result = node->lChild;
		}
		else
		{
			LeftChild(BTNode->lChild, node);
			LeftChild(BTNode->rChild, node);
		}
	}
	
	return Result;
}

//返回结点x的右孩子，若结点无右孩子或者x不在书中，返回NULL
BTreeNode *RightChild(BTreeNode *BTNode, BTreeNode *node)
{
	BTreeNode *Result = NULL;

	if (NULL != BTNode)
	{
		if (NULL != BTNode && BTNode->lChild == node || node == BTNode->rChild)
		{
			Result = BTNode->lChild->rChild;
		}
		else
		{
			RightChild(BTNode->lChild, node);
			RightChild(BTNode->rChild, node);
		}
	}

	return Result;
}

//返回树的深度
int BTreeDepth(BTreeNode *BTNode)
{
	int hLeft = 0;
	int hRight = 0;
	int max = 0;

	if (NULL != BTNode)
	{
		hLeft = BTreeDepth(BTNode->lChild);
		hRight = BTreeDepth(BTNode->rChild);
		
		max = hLeft > hRight ? hLeft : hRight;
		
		return (max+1);
	}
	else
	{
		return 0;
	}
}

//给树的节点old赋值为new
void Assign(BTreeNode *BTNode, BTreeNode *Search, int newvalue)
{
	if (NULL == BTNode || NULL == Search)
	{
		return;
	}

	if (NULL != BTNode)
	{
		if (NULL != BTNode && BTNode == Search)
		{
			BTNode->data = newvalue;
		}
		else
		{
			Assign(BTNode->lChild, Search, newvalue);
			Assign(BTNode->rChild, Search, newvalue);
		}
	}
}

//树的递归遍历
void PreOrderTraverse(BTreeNode *BTNode)
{
	if (NULL != BTNode)
	{
		printf("%c-", BTNode->data);
		PreOrderTraverse(BTNode->lChild);
		PreOrderTraverse(BTNode->rChild);
	}
}

void InOrderTraverse(BTreeNode *BTNode)
{
	if (NULL != BTNode)
	{
		InOrderTraverse(BTNode->lChild);
		printf("%c-", BTNode->data);
		InOrderTraverse(BTNode->rChild);
	}
}

void PostOrderTraverse(BTreeNode *BTNode)
{
	if (NULL != BTNode)
	{
		PostOrderTraverse(BTNode->lChild);
		PostOrderTraverse(BTNode->rChild);
		printf("%c-", BTNode->data);
	}
}

//树的非递归遍历
/************************************************************************/
/*从跟结点开始，只要当前结点存在或者栈不空，就重复下面操作				*/
/*(1)如果当前结点存在，则进栈并遍历左子树								*/ 
/*(2)否则推占并访问，然后遍历右子树                                     */
/************************************************************************/
//借助栈，在打印当前节点后分别记录其右、左孩子
void PreOrder(BTreeNode *BTNode)
{
	BTreeNode *TempTree = BTNode;
	std::stack<BTreeNode *> stackBTree;

	printf("非递归前序遍历为:");

	while (NULL != TempTree || !stackBTree.empty())
	{
		while (NULL != TempTree)
		{
			printf("%c-", TempTree->data);
			stackBTree.push(TempTree);
			TempTree = TempTree->lChild;
		}
		TempTree = stackBTree.top();
		stackBTree.pop();
		TempTree = TempTree->rChild;
	}
	printf("\b  \n");
}

//1.使用栈进行回溯
//2.每打印完一个节点，要对其右孩子做处理
//3.每个节点都需要不断找到最左边的孩子进行打印
void InOrder(BTreeNode *BTNode)
{
	BTreeNode *TempTree = BTNode;
	std::stack<BTreeNode *> stackBTree;

	printf("非递归中序遍历为:");

	while (NULL != TempTree || !stackBTree.empty())
	{
		while (NULL != TempTree)
		{
			stackBTree.push(TempTree);
			TempTree = TempTree->lChild;
		}

		TempTree = stackBTree.top();
		printf("%c-", TempTree->data);
		
		stackBTree.pop();

		TempTree = TempTree->rChild;
	}
	printf("\b  \n");
}

void PostOrder(BTreeNode *BTNode)
{
	BTreeNode *TempBTree = BTNode;
	BTreeNode *TempFlag = NULL;
	std::stack<BTreeNode *> stackBTree;

	printf("非递归后序遍历为：");

	while (NULL != TempBTree || !stackBTree.empty())
	{
		while (NULL != TempBTree)
		{
			stackBTree.push(TempBTree);
			TempBTree = TempBTree->lChild;
		}
		
		if(!stackBTree.empty())
		{
			TempBTree = stackBTree.top();

			if ((NULL == TempBTree->rChild) || (TempFlag == TempBTree->rChild))
			{
				printf("%c-", TempBTree->data);
				
				TempFlag = TempBTree;
				stackBTree.pop();
				TempBTree = NULL;
			}
			else
			{
				TempBTree = TempBTree->rChild;
			}
		}
	}
	printf("\b  \n");
}

//输出树中的叶子结点
/***********************************************************************************/
/* 输出叶子结点可以用三种遍历方法中任意一中实现，只需要在输出时判断左右孩子是否为空*/
/***********************************************************************************/
void PreOrderLeafNode(BTreeNode *BTNode)
{
	printf("叶子结点为：");

	if (NULL != BTNode)
	{
		if (NULL == BTNode->lChild && NULL == BTNode->rChild)
		{
			printf("%c-", BTNode->data);
		}
		PreOrderLeafNode(BTNode->lChild);
		PreOrderLeafNode(BTNode->rChild);
	}
	printf("\b  \n");
}

//统计叶子结点的数目
/***************************************************************************************/
/* 统计叶子结点数目可以用三种遍历方法中任意一中实现，只需要在输出时判断左右孩子是否为空*/
/***************************************************************************************/
int LeafCount(BTreeNode *BTNode)
{
	int leafcount = 0;

	if (NULL != BTNode)
	{
		if (NULL == BTNode->lChild && NULL == BTNode->rChild)
		{
			leafcount++;
		}
		LeafCount(BTNode->lChild);
		LeafCount(BTNode->rChild);
	}

	return leafcount;
}

//得到二叉树结点的个数
int GetBTreeLeafCount(BTreeNode *BTNode)
{
	//1+left+right
	if(NULL == BTNode)
	{
		return 0;
	}
	else
	{
		return (1+GetBTreeLeafCount(BTNode->lChild)+GetBTreeLeafCount(BTNode->rChild));
	}
}

//统计叶子结点数目的递归算法
/*如果根结点为空，则返回0
  如果根结点的左右子树为空，返回1
  否则返回左右子树的和*/
int LeafCount_CUR(BTreeNode *BTNode)
{
	int leafcount = 0;
	
	if (NULL == BTNode)
	{
		leafcount = 0;
	}
	else if ((NULL == BTNode->lChild) && (NULL == BTNode->rChild))
	{
		leafcount = 1;
	}
	else
	{
		leafcount = LeafCount_CUR(BTNode->lChild) + LeafCount_CUR(BTNode->rChild);
	}

	return leafcount;
}

//判断两二叉树是否相等
bool IsEqual(BTreeNode *BTree1, BTreeNode *BTree2)
{
	bool equalLeft, equalRight;

	if (NULL == BTree1 && NULL == BTree2)
	{
		return true;
	}
	else if (NULL == BTree1 || NULL == BTree2)
	{
		return false;
	}
	else
	{
		equalLeft = IsEqual(BTree1->lChild, BTree1->lChild);
		equalRight = IsEqual(BTree2->rChild, BTree2->rChild);

		return(equalLeft && equalRight);
	}
}

//求从二叉树跟结点到r结点之间的路径
void Path(BTreeNode *BTNode, BTreeNode *GoalNode)
{
	BTreeNode *Temp1 = BTNode;
	BTreeNode *Temp2 = NULL;
	std::stack<BTreeNode *> stackBtree;

	while (Temp1 != NULL || !stackBtree.empty())
	{
		while(Temp1 != NULL)
		{
			stackBtree.push(Temp1);
			Temp1 = Temp1->lChild;
		}
		
		if (!stackBtree.empty())
		{
			Temp1 = stackBtree.top();

			if (Temp1->rChild == NULL || Temp1->rChild == Temp2)
			{
				if (Temp2 == GoalNode)
				{
					for (int i = 1; i < stackBtree.size(); i++)
					{
						printf("%c-", stackBtree.top());
						stackBtree.pop();
					}
					return;
				}
				else
				{
					Temp2 = Temp1;
					stackBtree.pop();
					Temp1 = NULL;
				}
			}
			else
			{
				Temp1 = Temp1->rChild;
			}
		}
		
	}

}

//层序遍历二叉树
/*
(1)若二叉树为空，则直接返回
(2)将二叉树的根节点放到队列
(3)若队列非空，则执行下面操作：
	队头元素出队，并访问
	若该结点的左孩子非空，则将该结点的左孩子如队列
	若该节点的右孩子非空，则将该结点的右孩子入对列
*/
void LayerOrder(BTreeNode *BTNode)
{
	BTreeNode *Temp = NULL;
	std::queue<BTreeNode *> queueBTree;

	printf("树的层序遍历为:");

	if (NULL == BTNode)
	{
		return;
	}

	queueBTree.push(BTNode);

	while(!queueBTree.empty())
	{
		Temp = queueBTree.front();
		printf("%c-", Temp->data);

		if (Temp->lChild != NULL)
		{
			queueBTree.push(Temp->lChild);
		}
		if (Temp->rChild != NULL)
		{
			queueBTree.push(Temp->rChild);
		}

		queueBTree.pop();
	}

	printf("\b  \n");
}

//交换二叉树的左右子女
void ExchangeChild(BTreeNode **BTNode)
{
	if ((*BTNode) != NULL)
	{
		BTreeNode *Temp = NULL;

		if ((*BTNode)->lChild != NULL || (*BTNode)->rChild != NULL)
		{
			Temp = (*BTNode)->lChild;
			(*BTNode)->lChild = (*BTNode)->rChild;
			(*BTNode)->rChild = Temp;

			ExchangeChild(&(*BTNode)->lChild);
			ExchangeChild(&(*BTNode)->rChild);
		}
	}
}

//删除左子树
void DeleteLeftTree(BTreeNode ** BTNode)
{
	if (NULL == (*BTNode))
	{
		return;
	}
	else
	{
		DeleteLeftTree(&(*BTNode)->lChild);
		(*BTNode)->lChild = NULL;
	}
}

//删除右子树
void DeleteRightTree(BTreeNode **BTNode)
{
	if (NULL == (*BTNode))
	{
		return;
	}
	else
	{
		DeleteRightTree(&(*BTNode)->rChild);
		(*BTNode)->rChild = NULL;
	}
}

//查找结点
BTreeNode *SearchNode(BTreeNode *BTNode, char value)
{
	BTreeNode *Result = NULL;

	if (NULL == BTNode)
	{
		return NULL;
	}
	else if(value == BTNode->data)
	{
		return BTNode;
	}
	else
	{
		Result = SearchNode(BTNode->lChild, value);
		if (NULL != Result)
		{
			return Result;
		}
		else
		{
			return SearchNode(BTNode->rChild, value);
		}
	}
}

//判断二叉树是否为满二叉树
bool IsFullBTree(BTreeNode *BTNode)
{	
	int high = 0;
	bool Result = false;

	if (NULL != BTNode)
	{
		high = BTreeDepth(BTNode);
	}

	if(pow(2, high)-1 == GetBTreeLeafCount(BTNode))
	{
		Result = true;
	}
	return Result;
}

//判断二叉树是否为完全二叉树
bool IsCompleteBTree(BTreeNode *BTNode)
{
	//层序遍历一个二叉树，一旦找到一个不含有子节点或者只含有一个左孩子节点之后，那么
    //后续的所有节点都必须是叶子节点，否则该树就不是完全二叉树

	std::queue<BTreeNode *> queueBTree;
	
	if (NULL != BTNode)
	{
		queueBTree.push(BTNode);

		BTreeNode *Cur = NULL;
		bool bFlag = false;

		while (!queueBTree.empty())
		{
			Cur = queueBTree.front();
			queueBTree.pop();

			if (Cur != NULL)
			{
				if (bFlag != false)
				{
					return false;
				}
				queueBTree.push(Cur->lChild);
				queueBTree.push(Cur->rChild);
			}
			else
			{
				bFlag = true;
			}
		}
		return true;
	}
	return true;
}

//判断二叉树是否为平衡二叉树
bool IsBalanceBTree(BTreeNode *BTNode)
{
	if(NULL == BTNode)
	{
		return false;
	}

	int high_left = BTreeDepth(BTNode->lChild);
	int high_right = BTreeDepth(BTNode->rChild);

	if (abs((high_left-high_right) <= 1))
	{
		return true;
	}
	return false;
}

//根据先序和中序构建二叉树
BTreeNode *CreateTreeBy_PreMid(char *prestr, char *midstr)
{
	int length = strlen(prestr);
	if (NULL == prestr || NULL == midstr || length <= 0)
	{
		return NULL;
	}

	char RootValue = prestr[0];//根结点
	//建立跟结点
	BTreeNode *Root = (BTreeNode *)malloc(sizeof(BTreeNode));
	Root->data = RootValue;
	Root->lChild = Root->rChild = NULL;

	int length_left = 0;
	int length_right = 0;
	int i = 0;

	while (i < length && midstr[i] != RootValue)
	{
		i++;
	}

	length_left = i;
	length_right = length - length_left - 1;

	if (length_left > 0)
	{
		Root->lChild = CreateTreeBy_PreMid(prestr+1, midstr);
	}

	if (length_left > 0)
	{
		Root->rChild = CreateTreeBy_PreMid(prestr+length-length_right,
			midstr+length-length_right);
	}

	return Root;
}


//测试
#include "TreeHead.h"
/************************************************************************/
/*                      A B D # F # # # C E # # #                       */
/*		A B C # # D E # # F # # G H # I # # J # #		*/
/************************************************************************/
int main(void)
{

	BTreeNode *Root = NULL;
	BTreeNode *Test = NULL;

/************************************************************************/
/*				二叉树的创建与遍历	 	  	*/
/************************************************************************/

	//创建二叉树
	printf("请输入要创建树的结点：");
	CreateBTree(&Root);

	//统计二叉树结点的个数
	printf("二叉树结点的总个数为：%d\n", GetBTreeLeafCount(Root));

	//前序递归遍历
	printf("该树的递归前序遍历为：");
	PreOrderTraverse(Root);
	printf("\b  \n");	
	
	//中序递归遍历
	printf("该树的递归中序遍历为：");
	InOrderTraverse(Root);
	printf("\b  \n");

	//后续递归遍历
	printf("该树的递归后序遍历为：");
	PostOrderTraverse(Root);
	printf("\b  \n");
	
	//二叉树的深度测试
	printf("树的深度为：%d\n", BTreeDepth(Root));

	//非递归的前、中、后续遍历
	PreOrder(Root);
	InOrder(Root);
	PostOrder(Root);
	LayerOrder(Root);

	//交换后左右子树的输出
	printf("左右子树交换后为：\n");
	ExchangeChild(&Root);

	//销毁树
	//DestroyBTree(&Root);
	
	//删除左右子树
// 	DeleteLeftTree(&Root);
// 	DeleteRightTree(&Root);

	PreOrder(Root);
	InOrder(Root);
	PostOrder(Root);
	LayerOrder(Root);

/************************************************************************/
/*				 根据给定值查找结点、修改结点的值                       */
/************************************************************************/
	BTreeNode *Result = NULL;
	BTreeNode *Res = NULL;
	
	Result = SearchNode(Root, 'A');
	std::cout << "查找到的结点为" << Result->data <<std::endl;

	Assign(Root, Result, 'O');

	PreOrder(Root);
	InOrder(Root);
	PostOrder(Root);
	LayerOrder(Root);
// 
// 	Res = LeftChild(Root, Result);
/*	printf("结点的左孩子为%c\n", Res->data);*/

/************************************************************************/
/*				判断二叉树是否为空、相等、平衡、满二叉                  */
/************************************************************************/

	//二叉树是否为空
	if(BTreeEmpty(Root))
	{
		printf("该二叉树是空的\n");
	}
	else
	{
		printf("该二叉树非空\n");
	}

	//判断二叉树是否相等
	if(IsEqual(Root, Test))
	{
		printf("两棵树相等\n");
	}
	else
	{
		printf("两棵树不相等\n");
	}

	//判断二叉树是否为满二叉树
	if (IsFullBTree(Root) == true)
	{
		printf("是满二叉树\n");
	}
	else
	{
		printf("不是满二叉树\n");
	}
	
	//判断二叉树是否为完全二叉树
	if (IsCompleteBTree(Root) == true)
	{
		printf("是完全二叉树\n");
	}
	else
	{
		printf("不是完全二叉树\n");
	}

	//二叉树是否是平衡二叉树
	if (IsBalanceBTree(Root) == true)
	{
		printf("是平衡二叉树\n");
	}
	else
	{
		printf("不是平衡二叉树\n");
	}

/************************************************************************/
/*				 根据给定的序列还原二叉树                               */
/************************************************************************/

	std::cout<<"----------根据给定的序列还原二叉树----------"<<std::endl;
	BTreeNode *Node_1 = NULL;
	BTreeNode *Node_2 = NULL;

	char preStr[] = "ABDECF";
	char midStr[] = "DBEAFC";
	char posStr[] = "DEBFCA";

	Node_1 = CreateTreeBy_PreMid(preStr, midStr);
	PostOrder(Node_1);
	LayerOrder(Node_1);

	Node_2 = CreateTreeBy_MidPos(midStr, posStr);
	PreOrder(Node_2);
	LayerOrder(Node_2);

	return 0;
}

/*
线索二叉树：
可以得到结点在遍历序列中前驱和后继的信息
方法：利用二叉链表中的空链域，将遍历过程中结点的前驱、后继信息保存下来

若结点有左孩子，则其lChild域指向其左孩子，否则lChild域指向其前驱结点
若结点有右孩子，则其rChild域指向其有孩子，否则rChild域指向其后继结点

树的遍历：
树的先跟遍历<<----------->>二叉树的前序遍历
树的后跟遍历<<----------->>二叉树的中序遍历
*/














                

        

    

  



    


                



	

		

			

				
					
二叉树基本操作

				
			

			

				

					m0_55250791的博客
				

				

					08-07
					
					673
					
				

			

		

		

			
				
无摘要

			
		

	



                

            
              



	

		

			

				
					
二叉树的基本操作（总结）

				
			

			

				

					ParadiseHeaven的博客
				

				

					11-21
					
					1223
					
				

			

		

		

			
				
二叉树的基本操作

二叉树的定义决定了其大多数操作都可以由递归去实现

本文通过递归和非递归两种方式实现二叉树的基本操作（加深对原理的理解）

1.二叉树的声明

 


typedef char ElementType; 
typedef struct TreeNode* BinTree;
struct TreeNode{
    ElementType Data;
    struct Tre...

			
		

	



              


  
              

                


	

		

			

				
					
二叉树的基本操作(简单易懂)

				
			

			

				

					weixin_30802171的博客
				

				

					11-13
					
					2312
					
				

			

		

		

			
				
二叉树基本操作
1.初始化
2.建树
3.销毁树
4.插入操作
5.查找元素值为e的节点的指针
6.查找元素值为e的节点左节点的值
7.查找元素值为e的节点右节点的值
8.删除左子树
9.删除右子树
10.先序遍历
11.中序遍历
12.后序遍历

计算叶子节点数
14.计算非叶子节点数
15.计算树的深度
我输入的树按先序输入
ABC##D##EF#G##HI###


代码
#include&...

			
		

	





	

		

			

				
					
二叉树基础操作

				
			

			

				

					weixin_63178060的博客
				

				

					10-15
					
					1289
					
				

			

		

		

			
				
层序遍历相对于前三种遍历，需要用队列进行辅助操作，具体操作：定义一个队列，首先将二叉树的第一个结点入队，while循环判断该队列是否为空，不为空的话，则先进行出队，然后判断该树的左又子树是否为空，不为空则入队。在销毁时，不能先销毁根结点，因为其左子树和右子树是通过根结点访问的，如果根结点先被销毁，则其左子树和右子树在后序程序中无法被访问，会出现错误。满二叉树：一个二叉树，如果其每一层的结点都达到最大值，即结点个数为2^k-1，k为二叉树层数，则该树为满二叉树。（n0为度为0的结点，n2为度为2的结点）

			
		

	



		

			
		



	

		

			

				
					
二叉树及其基本操作

				
			

			

				

					adorable_的博客
				

				

					03-29
					
					502
					
				

			

		

		

			
				
二叉树及其基本操作
概念
二叉树特点：
•每个结点最多有两个子树，即二叉树不存在度大于2的结点
•二叉树的子树有左右之分，其子树的次序不能颠倒

			
		

	





	

		

			

				
					
实验四 二叉树基本操作的实现

				
			

			

				

					12-18
				

			

		

		

			
				
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...

			
		

	





	

		

			

				
					
二叉树基本操作的程序实现.zip_二叉树的基本操作

				
			

			

				

					09-21
				

			

		

		

			
				
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。  二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...

			
		

	





	

		

			

				
					
二叉树-基于C语言实现的二叉树基本操作.zip

					
最新发布

				
			

			

				

					04-26
				

			

		

		

			
				
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。  在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...

			
		

	





	

		

			

				
					
c语言版本二叉树基本操作示例(先序递归非递归)共10页.p

				
			

			

				

					10-29
				

			

		

		

			
				
本文将深入探讨C语言实现的二叉树基本操作，包括递归和非递归两种方法，以及先序遍历的概念。在标题和描述中提及的“c语言版本二叉树基本操作示例(先序递归非递归)共10页”很可能是一个详细的教程或代码示例集合，...

			
		

	





	

		

			

				
					
二叉树基本操作（一）

				
			

			

				

					lxt-st
				

				

					08-20
					
					518
					
				

			

		

		

			
				
目录

一、二叉树的概念

二、二叉树的分类

满二叉树 && 完全二叉树

三、二叉树的基本操作

1、二叉树的创建

2、二叉树的销毁

3、求二叉树的高度 

4、求二叉树叶子结点的个数

5、求二叉树结点的个数

6、求二叉树第 K 层结点的个数 

7、判断一个节点是否在一棵二叉树中 

注：完整代码请至 Github 查看：https://github.com/...

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值