二叉排序树Binary sort tree（BST）

1.二叉搜索树的概念

二叉排序数也叫二叉搜索树，有以下特点：
①：二叉搜索树的左节点永远小于父节点。
②：二叉搜索树的右节点永远大于父节点。
③：它的左右子树也分别为二叉搜索树

2.二叉搜索树的操作及应用

二叉搜索树本质还是二叉树，只是对节点各种需求有了不同的方式。
1.名字叫二叉搜索树，那么其查找方式肯定很棒
由于它的特点，当树不为空的时候，我们只需要去比较要搜索的值与各个节点的值，如果大于该节点，那么就在该节点的右子树去寻找，如果小于该节点，那么就在该节点的左子树去寻找。
具体示例图如下：
例如：插入一段数据{4，7，3，2，9，6，5}时，二叉搜索树的存储结构如下：

可以看到，每一个节点都符合左子树小于父节点，右子树大于父节点的特点，所以我们查找的时候就特别容易。
重要的是：每个节点映射到水平面上的时候，顺序是有序的，所以我们对其进行中序遍历，肯定会得到一个有序的数字，而且是从小到大。
2.二叉搜索树的插入
①：如果二叉搜索树为空，则直接插入到根节点
②：如果二叉搜索树不为空，那么就与其每个几点进行比较
情况的图如下：

如果加入10这个节点，那么就将比较三次，最终将10放到最右边的节点。
3.二叉搜索树的删除
删除的情况有三种：
①：删除的节点没有左右子树
②：删除的节点有左右子树任意一颗树
③：删除的节点左右子树都有
面对这三种情况，我们发现，只有一课子树和没有左右子树的节点非常好删除，直接对节点进行删除后，让其父节点的子树为nullptr或者连接其子节点即可。
而左右子树都有的节点，我们发现，我们可以在该节点的左子树去寻找最大的节点或者在右子树去寻找最小的节点就不会破环二叉搜索树的结构，然后交换两者，将交换的左子树最大节点或者右子树最小的节点进行删除，那么情况就变大为小，成了删除具有一个子树的节点情况了。
4.二叉搜索树的性能分析
①：由于插入和删除都需要去在二叉树中去进行查找，那么查找的效率便是二叉搜索树的效率。
②：查找主要是通过与节点的比较来选择方向的，那么就与二叉树的深度有关，如果深度深，那么比较次数就多。
③：对于同一个数组，由于数的插入顺序不同，可能会出现不同的情况：

所以最终我们可以得出：
①：具有n个节点的最好的情况下（为完全二叉树），平均比较次数为：
②：具有n个节点的最坏情况下（单支树），平均比较次数为：

3.二叉搜索树的模拟实现

template<class Type>
class BST;
template<class Type>
class BSTNode
{
	friend class BST<Type>;
public:
	BSTNode(Type d= Type(), BSTNode* left = nullptr, BSTNode* right = nullptr) 
		:date(d),leftchild(left), rightchild(right)
	{
	}
	~BSTNode()
	{}
private:
	Type date;
	BSTNode* leftchild;
	BSTNode* rightchild;
};
template<class Type>
class BST
{
public:
	BST() :root(nullptr)
	{}
	BST(vector<Type>& iv) :root(nullptr)
	{
		for (const auto& e : iv)
		{
			Insert(e);
		}
	}
	
public:
	Type min()
	{
		return min(root);
	}
	Type max()
	{
		return max(root);
	}
	void Order()
	{
		Order(root);
	}
public:
	Type min(BSTNode<Type>* t);
	Type max(BSTNode<Type>* t);
	void Order(BSTNode<Type>*& t);
	void Insert(const Type v)
	{
		Insert(root, v);
	}
	void Remove(const Type v)
	{
		Remove(root, v);
	}
protected:
	void Insert(BSTNode<Type>*& t,const Type &v);
	void Remove(BSTNode<Type>*& t, const Type &v);
private:
	BSTNode<Type>* root;
};
template<class Type>
void BST<Type>::Order(BSTNode<Type>*& t)
{
	if (t != nullptr)
	{
		Order(t->leftchild);
		cout << t->date << " ";
		Order(t->rightchild);
	}
}
template<class Type>
Type BST<Type>::max(BSTNode<Type>* t)
{
	if (t != nullptr)
		t = t->rightchild;
	return t->date;
}
template<class Type>
Type BST<Type>::min(BSTNode<Type>* t)
{
	if (t != nullptr)
		t = t->leftchild;
	return t->date;
}
template<class Type>
void BST<Type>::Remove(BSTNode<Type>*& t, const Type &v)
{
	if (t == nullptr)
		return;
	if (t->date < v)
		Remove(t->rightchild, v);
	else if (t->date > v)
		Remove(t->leftchild, v);
	else
	{
		BSTNode<Type> *p;
		if (t->leftchild != nullptr && t->rightchild != nullptr)
		{
			p = t->leftchild;
			while (p->rightchild != nullptr)
				p = p->rightchild;
			t->date = p->date;
			Remove(t->leftchild, p->date);
		}
		else
		{
			if (t->leftchild != nullptr)
				p = t->leftchild;
			else
				p = t->rightchild;
			delete p;
			t = p;
		}
	}
}
template<class Type>
void BST<Type>::Insert(BSTNode<Type>*& t,const Type &v)
{
	if (t == nullptr)
	{
		t = new BSTNode<Type>(v);
		return;
	}
	if (v < t->date)
	{
		Insert(t->leftchild, v);
	}
	if (v > t->date)
	{
		Insert(t->rightchild, v);
	}
}