数据结构_二叉排序树

/*
二叉排序树
1. 根节点大于左子树
2. 根节点小于或等于右子树
3. 每个子树也是一颗二叉排序树
*/

#pragma once

//二叉树节点
template<class T>
struct BSTNode
{
	T data;
	BSTNode<T> *pLeft;
	BSTNode<T> *pRight;
};

//操作二叉排序树
template<class T>
class CBinarySortTree
{
public:
	CBinarySortTree();
	~CBinarySortTree();

public:
	// 创建二叉树
	bool CreateTree(const T data[], const UINT nNum);

	// 插入数据
	bool InsertData(const T data);

	// 删除数据
	bool DeleteData(const T data);

	// 通过数据获取节点
	BSTNode<T> * GetNodeByData(BSTNode<T> *pNode, const T data);

	// 前序遍历二叉树
	bool PreOrderData(BSTNode<T> *pNode);

	// 中序遍历二叉树
	bool InOrderData(BSTNode<T> *pNode);

	// 后续遍历二叉树
	bool AfterOrderData(BSTNode<T> *pNode);

	// 清空树
	bool ClearTree();

	// 判断数据是否存在
	bool IsDataExists(const T data);

public:
	// 二叉树的根节点
	BSTNode<T> *m_pRoot;
};

template<class T>
CBinarySortTree<T>::CBinarySortTree()
	:m_pRoot(NULL)
{}

template<class T>
CBinarySortTree<T>::~CBinarySortTree()
{
	ClearTree();
}

template<class T>
bool CBinarySortTree<T>::ClearTree()
{

	return true;
}

template<class T>
bool CBinarySortTree<T>::CreateTree(const T data[], const UINT nNum)
{
	if (nNum < 1)
	{
		return false;
	}

	for (int i = 0; i < nNum; i++)
	{
		if (!InsertData(data[i]))
		{
			return false;
		}
	}

	return true;
}

template<class T>
bool CBinarySortTree<T>::InsertData(const T data)
{
	BSTNode<T> *pNode = new BSTNode<T>;
	if (!pNode)
	{
		return false;
	}

	pNode->data = data;
	pNode->pLeft = NULL;
	pNode->pRight = NULL;

	if (!m_pRoot)
	{
		m_pRoot = pNode;
	}
	else
	{
		BSTNode<T> *pRoot = m_pRoot;
		BSTNode<T> *pTemp = NULL;
		while (pRoot)
		{
			pTemp = pRoot;
			pRoot = (data < pRoot->data) ? pRoot->pLeft : pRoot->pRight;
		}

		if (data < pTemp->data)
		{
			pTemp->pLeft = pNode;
		}
		else
		{
			pTemp->pRight = pNode;
		}
	}

	return true;
}

template<class T>
bool CBinarySortTree<T>::PreOrderData(BSTNode<T> *pNode)
{
	if (!pNode)
	{
		return false;
	}
	else
	{
		const char *pType = typeid(T).name();
		if (0 == strcmp(pType, "float"))
		{
			TRACE("\n=》 %f\n", pNode->data);
		}
		else if (0 == strcmp(pType, "int"))
		{
			TRACE("\n=》 %d\n", pNode->data);
		}
		else if (0 == strcmp(pType, "char"))
		{
			TRACE("\n=》 %c\n", pNode->data);
		}

		PreOrderData(pNode->pLeft);
		PreOrderData(pNode->pRight);
	}

	return true;
}

template<class T>
bool CBinarySortTree<T>::InOrderData(BSTNode<T> *pNode)
{
	if (pNode)
	{
		InOrderData(pNode->pLeft);

		const char *pType = typeid(T).name();
		if (0 == strcmp(pType, "int"))
		{
			TRACE("\n=》 %d\n", pNode->data);
		}
		else if (0 == strcmp(pType, "float"))
		{
			TRACE("\n=》 %f\n", pNode->data);
		}
		else if (0 == strcmp(pType, "char*"))
		{
			TRACE("\n=》 %c\n", pNode->data);
		}

		InOrderData(pNode->pRight);
	}

	return true;
}

template<class T>
bool CBinarySortTree<T>::AfterOrderData(BSTNode<T> *pNode)
{
	if (pNode)
	{
		AfterOrderData(pNode->pLeft);
		AfterOrderData(pNode->pRight);

		const char *pType = typeid(T).name();
		if (0 == strcmp(pType, "int"))
		{
			TRACE("\n=》 %d\n", pNode->data);
		}
		else if (0 == strcmp(pType, "float"))
		{
			TRACE("\n=》 %f\n", pNode->data);
		}
		else if (0 == strcmp(pType, "char*"))
		{
			TRACE("\n=》 %c\n", pNode->data);
		}
	}

	return true;
}

template<class T>
bool CBinarySortTree<T>::IsDataExists(const T data)
{
	BSTNode<T> *pNode = m_pRoot;
	return GetNodeByData(pNode, data) == NULL ? false : true;
}

template<class T>
BSTNode<T> *CBinarySortTree<T>::GetNodeByData(BSTNode<T> *pNode, const T data)
{
	if (!pNode)
	{
		return NULL;
	}

	if (data == pNode->data)
	{
		return pNode;
	}
	else if (data < pNode->data)
	{
		GetNodeByData(pNode->pLeft, data);
	}
	else
	{
		GetNodeByData(pNode->pRight, data);
	}
}

void F_DataStructBST_Test()
{
	int nArray[] = { 10, 4, 5, 11, 9, 23, 0, 8, 90, 118, 29 };

	CBinarySortTree<int> SortTree;
	bool bSuc = SortTree.CreateTree(nArray, sizeof(nArray) / sizeof(int));

	SortTree.PreOrderData(SortTree.m_pRoot);
	SortTree.InOrderData(SortTree.m_pRoot);
	SortTree.AfterOrderData(SortTree.m_pRoot);

	BSTNode<int> *pNode = SortTree.GetNodeByData(SortTree.m_pRoot, 90);
	if (pNode->pLeft)
	{
		TRACE("\n\n=> %d", pNode->pLeft->data);
	}

	bSuc = SortTree.IsDataExists(910);
	bSuc = SortTree.IsDataExists(0);

	SortTree.InsertData(25);
	SortTree.InsertData(3);
	SortTree.PreOrderData(SortTree.m_pRoot);
	bSuc = SortTree.IsDataExists(3);

	return;
}