(Tree)二叉树基本操作

//二叉树操作

#include<iostream>
#include<algorithm>
using namespace std;

//准备数据

#define MANLEN 20
typedef char DATA;
typedef struct CBT
{
	DATA data;
	struct CBT*left;
	struct CBT*right;
}CBTT;

//初始二叉树,设置一个根节点

CBTT* InitTree()
{
	CBTT* node;
	if (node = (CBTT*)malloc(sizeof(CBTT)))
	{
		cout << "请先输入一个根节点数据: " << endl;
		cin >> node->data;
		node->left = nullptr;
		node->right = nullptr;
		if (node != nullptr)
		{
			return node;
		}
		else
		{
			return nullptr;
		}

		return nullptr;



	}
}

//添加结点
void AddTreeNode(CBTT* treeNode)
{
	CBTT* pnode, *parent;
	DATA data;
	char menusel;

	if (pnode = (CBTT*)malloc(sizeof(CBTT)))
	{
		cout << "请输入要加入的数据: " << endl;
		cin >> pnode->data;
		pnode->left = nullptr;
		pnode->right = nullptr;

		cout << "请输入该结点的父结点数据: " << endl;
		fflush(stdin);
		cin >> data;
		parent = TreeFindNode(treeNode, data);
		if (!parent)
		{
			cout << "未找到该父节点!" << endl;
			free(pnode);
			return;
		}
		cout << "1.添加到左子树 \n 2.添加到右子树" << endl;
		do
		{
			menusel = getchar();
			menusel = '0';
			if (menusel == 1 || menusel == 2)
			{
				if (parent == nullptr)
				{
					cout << "不存在父结点，请先设置父结点" << endl;

				}
				else
				{
					switch (menusel)
					{
					case 1:
						if (parent->left)
						{
							cout << "左子树不为空" << endl;
						}
						else
						{
							parent->left = pnode;
						}
						break;
					case 2:
						if (parent->right)
						{
							cout << "右子树不为空" << endl;
						}
						else
						{
							parent->right = pnode;
						}
						break;
					default:
						cout << "无效参数" << endl;
					}
				}
			}


		} while (menusel!=1 && menusel!=2);


	}

}



//查找结点,先判断根是否为空然后递归查找左右子树
CBTT* TreeFindNode(CBTT* treeNode, DATA data)
{
	CBTT* ptr;

	if (treeNode == nullptr)
	{
		return nullptr;
	}
	else
	{
		if (treeNode->data == data)
		{
			return treeNode;
		}
		else
		{
			if (ptr = TreeFindNode(treeNode->left))
			{
				return ptr;
			}
			else if (ptr = TreeFindNode(treeNode->right))
			{
				return ptr;
			}
			else
			{
				return nullptr;
			}
		}
	}
}

//获取左子树
CBTT* TreeLeftNode(CBTT* treeNode)
{
	if (treeNode)
	{
		return treeNode->left;
	}
	else
	{
		return nullptr;
	}


}

//获取右子树
CBTT* TreeRightNode(CBTT* treeNode)
{
	if (treeNode)
	{
		return treeNode->right;
	}
	else
	{
		return nullptr;
	}


}

//计算二叉树的深度
int TreeDepth(CBTT* treeNode)
{
	int depleft, depright;
	if (treeNode == nullptr)
	{
		return 0;
	}
	else
	{
		depleft = TreeDepth(treeNode->left);
		depright = TreeDepth(treeNode->right);
		if (depleft > depright)
		{
			return depleft + 1;
		}
		else
		{
			return depright + 1;
		}
	}
}


//清空二叉树
void ClearTree(CBTT* treeNode)
{
	if (treeNode)
	{
		ClearTree(treeNode->left);
		ClearTree(treeNode->right);
		free(treeNode);
		treeNode = nullptr;
	}
}

//前序遍历

void preorderTrav(CBTT* treeNode)
{
	if (treeNode == nullptr)return;
	cout << treeNode->data;
	preorderTrav(treeNode->left);
	preorderTrav(treeNode->right);
}

//中序遍历

void preorderTrav(CBTT* treeNode)
{
	if (treeNode == nullptr)return;
	preorderTrav(treeNode->left);
	cout << treeNode->data;
	preorderTrav(treeNode->right);
}

//后续遍历

void preorderTrav(CBTT* treeNode)
{
	if (treeNode == nullptr)return;
	preorderTrav(treeNode->left);
	preorderTrav(treeNode->right);
	cout << treeNode->data;
}

//求二叉树高度
int getTreeHigh(CBTT* root)
{
	if (root == NULL)return 0;
	int left_high = getTreeHigh(root->left);
	int right_high = getTreeHigh(root->right);
	return max(left_high, right_high) + 1;
}