BST树有如下特点:
1、若它的左子树不为空,则左子树上所有的节点值都小于它的根节点值。
2、若它的右子树不为空,则右子树上所有的节点值均大于它的根节点值。
3、它的左右子树也分别可以充当为二叉查找树。
定义节点
#include<iostream>
#include<vector>
#include<stack>
using namespace std;
typedef int KeyType;
typedef struct BstNode
{
KeyType key;
BstNode* leftchild;
BstNode* parent;
BstNode* rightchild;
}BstNode, * BSTree;
创建新节点
BstNode* Buynode(KeyType kx)
{
BstNode* s = (BstNode*)malloc(sizeof(BstNode));
if (nullptr == s) exit(1);
memset(s, 0, sizeof(BstNode));
s->key = kx;
return s;
}
释放节点
void Freenode(BstNode* p)
{
free(p);
}
递归方法查找值
BstNode* SearchValue(BstNode* ptr, KeyType kx)
{
if (ptr == nullptr || ptr->key == kx)
return ptr;
else if (kx < ptr->key)
return SearchValue(ptr->leftchild, kx);
else
return SearchValue(ptr->rightchild, kx);
}
非递归方法查找值
BstNode* FindValue(BstNode* ptr, KeyType kx)
{
while (ptr != nullptr && ptr->key != kx)
{
ptr = kx < ptr->key ? ptr->leftchild : ptr->rightchild;
}
return ptr;
}
插入新数据
bool Insert(BstNode *&ptr,KeyType kx)
{
if (ptr == nullptr)
{
ptr = Buynode(kx);
return true;
}
BstNode* pa = nullptr;
BstNode* p = ptr;
while (p != nullptr && p->key != kx)
{
pa = p;
p = kx < p->key ? p->leftchild : p->rightchild;
}
if (p != nullptr && p->key == kx) return false;
p = Buynode(kx);
p->parent = pa;
if (p->key < pa->key)
{
pa->leftchild = p;
}
else
{
pa->rightchild = p;
}
return true;
}
判断是否是BST
bool Is_BST(BstNode* ptr)
{
bool res = true;
if (ptr == nullptr) return res;
BstNode* pre = nullptr;
std::stack<BstNode*> st;
while (ptr != nullptr || !st.empty())
{
while (ptr != nullptr)
{
st.push(ptr);
ptr = ptr->leftchild;
}
ptr = st.top(); st.pop();
if (pre != nullptr && pre->key >= ptr->key)
{
res = false;
break;
}
pre = ptr;
ptr = ptr->rightchild;
}
return res;
}
删除数据
BstNode* Next(BstNode* ptr)
{
while (ptr != nullptr && ptr->leftchild != nullptr)
{
ptr = ptr->leftchild;
}
return ptr;
}
bool Remove(BstNode*& ptr, KeyType kx)
{
bool res = false;
if (ptr == nullptr) return res;
BstNode* p = ptr;
while (p != nullptr && p->key != kx)
{
p = kx < p->key ? p->leftchild : p->rightchild;
}
if (p == nullptr) return false;
if (p->leftchild != nullptr && p->rightchild != nullptr)
{
BstNode* nt = Next(p->rightchild);
p->key = nt->key;
p = nt;
}
BstNode* pa = p->parent;
BstNode* child = p->leftchild != nullptr ? p->leftchild : p->rightchild;
if (child != nullptr) child->parent = pa;
if (pa == nullptr)
{
ptr = child;
}
else
{
if (pa->leftchild == p)
{
pa->leftchild = child;
}
else
{
pa->rightchild = child;
}
}
Freenode(p); p = nullptr;
return true;
}
寻找最小节点
BstNode* First(BstNode* ptr) // Min
{
while (ptr != nullptr && ptr->leftchild != nullptr)
{
ptr = ptr->leftchild;
}
return ptr;
}
寻找最大节点
BstNode* Last(BstNode* ptr) // Max
{
while (ptr != nullptr && ptr->rightchild != nullptr)
{
ptr = ptr->rightchild;
}
return ptr;
}
寻找直接前驱节点
BstNode* Prev(BstNode* ptr)
{
if (ptr == nullptr) return nullptr;
if (ptr->leftchild != nullptr)
{
return Last(ptr->leftchild);
}
else
{
BstNode* pa = ptr->parent;
while (pa != nullptr && pa->rightchild != ptr)
{
ptr = pa;
pa = ptr->parent;
}
return pa;
}
}
寻找直接后续节点
迭代器++ 实现原理
BstNode* Next(BstNode* ptr)
{
if (ptr == nullptr) return nullptr;
if (ptr->rightchild != nullptr)
{
return First(ptr->rightchild);
}
else
{
BstNode* pa = ptr->parent;
while (pa != nullptr && pa->leftchild != ptr)
{
ptr = pa;
pa = ptr->parent;
}
return pa;
}
}
图论