003 二叉树

一、构造二叉树

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

class SerchTree
{
private:
	TreeNode* root;
public:
	SerchTree();

	//插入节点
	void Insert_Node(TreeNode* root, int val)
	{
		if (NULL == root)
			root = new TreeNode(val);
		else
		{
			if (val < root->val)
				Insert_Node(root->left, val);
			else 
			{
				//一样大就往左走吧
				Insert_Node(root->right, val);
			}
		}
	}

	//从数组中构造二叉搜索树
	void Create_SerchTree(vector<int>& vec)
	{
		int sz = vec.size();
		for (int i = 0; i < sz; i++)
		{
			Insert_Node(root, vec[i]);
		}
	}

	//搜索某个节点是否存在
	bool SerchNode(TreeNode* root, int val)
	{
		if (NULL == root)
			return false;
		if (val < root->val)
			return SerchNode(root->left, val);
		else if (val > root->val)
			return SerchNode(root->right,val);
		else
			return true;
	}

	//删除节点
	void DelNode(TreeNode* node)
	{
		TreeNode* temp;
		if (NULL == node->right)
		{
			//如果右子节点为空
			temp = node;
			node = node->left;
			delete temp;
		}
		else
		{
			//如果右子节点不空
			temp = node;
			while (NULL != temp->left)
			{
				temp = temp->left;
			}
			node->val = temp->val;
			delete temp;
		}
	}

	//删除某个节点
	void DelSerchNode(TreeNode* root, int val)
	{
		if (NULL == root)
			return;
		if (val < root->val)
			return DelSerchNode(root->left, val);
		else if (val > root->val)
			return DelSerchNode(root->right);
		else
			DelNode(root);
	}

	//计算二叉树的最大深度
	int maxDepth(Node x)
	{
		//1.如果根节点为空，最大深度为0；
		if (x == NULL)
			return 0;

		int max = 0;
		int maxL = 0;
		int maxR = 0;

		//2.计算左子树的最大深度
		if (x.left != NULL)
			maxL = maxDepth(x.left);

		//3.计算右子树的最大深度；
		if (x.right != NULL)
			maxR = maxDepth(x.right);

		//4.当前树的最大深度=左子树的最大深度和右子树的最大深度中的较大者+1
		max = maxL > maxR ? maxL + 1 : maxR + 1;
		return max;
	}
}

二、遍历二叉树

#include<stdio.h>
#include<malloc.h>

struct BTNode
{
	int data;	//数据域
	struct BTNode* pLchild;//左子树指针域，L是左，child是孩子，左子树
	struct BTNode* pRchild;//右子树指针域，R是左，child是孩子，右子树
};

void PreTraverseBTree(struct BTNode* pT);//先序遍历二叉树
void InTraverseBTree(struct BTNode* pT);//中序遍历二叉树
void PostTraverseBTree(struct BTNode* pT);//后序遍历二叉树
struct BTNode* CreateBTree(void);//创建二叉树

int main(void)
{
	struct BTNode* pT = CreateBTree();
	printf("先序遍历：\n");
	PreTraverseBTree(pT);
	printf("中序遍历：\n");
	InTraverseBTree(pT);
	printf("后序遍历：\n");
	PostTraverseBTree(pT);
	
	return 0;
}

struct BTNode* CreateBTree(void)//创建二叉树，并返回顶层根节点的地址
{
	struct BTNode* pA = (struct BTNode*)malloc(sizeof(struct BTNode));//创建A节点
	struct BTNode* pB = (struct BTNode*)malloc(sizeof(struct BTNode));//创建B节点
	struct BTNode* pC = (struct BTNode*)malloc(sizeof(struct BTNode));//创建C节点
	struct BTNode* pD = (struct BTNode*)malloc(sizeof(struct BTNode));//创建D节点
	struct BTNode* pE = (struct BTNode*)malloc(sizeof(struct BTNode));//创建E节点

	pA->data = 'A';//A节点数据域内的数据
	pB->data = 'B';//B节点数据域内的数据
	pC->data = 'C';//C节点数据域内的数据
	pD->data = 'D';//D节点数据域内的数据
	pE->data = 'E';//E节点数据域内的数据

	pA->pLchild = pB;//根据二叉树知道A节点左子树指针域指向B节点
	pA->pRchild = pC;//根据二叉树知道A节点右子树指针域指向C节点
	pB->pLchild = pB->pRchild = NULL;//根据二叉树知道B节点左、右子树的指针域为空NULL
	pC->pLchild = pD;//根据二叉树知道C节点左子树指针域指向D
	pC->pRchild = NULL;//根据二叉树知道C节点右子树指针域指向D
	pD->pLchild = NULL;//根据二叉树知道D节点左子树指针域为空NULL
	pD->pRchild = pE;//根据二叉树知道D节点右子树指针域指向E节点
	pE->pLchild = pE->pRchild = NULL;//根据二叉树知道E节点左、右子树指针域为空NULL

	return pA;//返回顶层根节点A的地址
}


//先序遍历
void PreTraverseBTree(struct BTNode* pT)
{
	if (pT != NULL)//根节点A的地址不为空，二叉树创建成功
	{
		printf("%c\n", pT->data);//先序遍历根节点
		if (NULL != pT->pLchild)//根节点左子树指针域不为空NULL
		{
			PreTraverseBTree(pT->pLchild);//先序遍历左子树
		}
		if (NULL != pT->pRchild)//根节点右子树指针域不为空NULL
		{
			PreTraverseBTree(pT->pRchild);//先序遍历右子树
		}
		//pT->pLchild可以代替整个左子树
	}
}

//中序遍历
void InTraverseBTree(struct BTNode* pT)
{
	if (pT != NULL)//根节点的地址不为空，二叉树创建成功
	{
		if (NULL != pT->pLchild)
		{
			InTraverseBTree(pT->pLchild);//中序遍历左子树
		}
		printf("%c\n", pT->data);//中序遍历根节点
		if (NULL != pT->pRchild)
		{
			InTraverseBTree(pT->pRchild);//中序遍历右子树
		}
		//pT->pLchild代表整个左子树
	}
}

//后序遍历
void PostTraverseBTree(struct BTNode* pT)
{
	if (pT != NULL)
	{
		if (NULL != pT->pLchild)
		{
			PostTraverseBTree(pT->pLchild);//后序遍历左子树
		}
		if (NULL != pT->pRchild)
		{
			PostTraverseBTree(pT->pRchild);//后序遍历右子树
		}
		printf("%c\n", pT->data);//后序遍历根节点
		//pT->pLchild 可以代表整个左子树
	}
}

结果

先序遍历：
A
B
C
D
E
中序遍历：
B
A
D
E
C
后序遍历：
B
E
D
C
A