/*
二叉排序树
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;
}
数据结构_二叉排序树
最新推荐文章于 2023-06-01 17:16:46 发布