二叉搜索树（BST）

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;
	}
}

图论