二叉树进阶

二叉搜索树

概念

• 二叉搜索树又称二叉排序树，它要么是一棵空树，要么是具有以下性质的二叉树：
  1. 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；
  2. 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值；
  3. 它的左右子树也分别为二叉搜索树，因此二叉搜索树中不能出现重复值；

操作

1. 二叉搜索树的查找
   • 如果该树为空，则结束查找；
   • 如果根结点的值等于要查找的值，则返回根结点；
   • 如果根结点的值大于要查找的值，则向根结点左子树查找；
   • 如果根结点的值小于要查找的值，则向根结点右子树查找；
   • 完全遍历完二叉搜索树后还是没找到，那么就表示不包含该值；
2. 二叉搜索树的插入
   • 如果该树为空，那么则直接插入为根结点；
   • 如果该树不为空，则开始向下查找插入的位置，大了就向左，小了就向右，直到走到为空的位置，则为空的位置就是要插入的位置；
3. 二叉搜索树的删除
   • 删除节点无孩子结点或者只有左孩子节点：
     删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点
   • 删除节点无孩子节点或者只有右孩子节点：
     删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点
   • 删除节点既有左孩子，又有右孩子：
     在它的右子树中寻找中序下的第一个结点(也就是右子树中的最左节点)，然后交换最左节点与删除节点的值，然后来处理该最左节点的删除情况；（或者找左子树的最右节点也可）

实现

#include<iostream>
using namespace std;

template<class T>
struct BSNode{
	//数据节点的构造函数
	BSNode(const T& data)
		:_data(data)
		,_left(nullptr)
		,_right(nullptr)
	{}
	//存放的数据
	T _data;
	//指向节点的左孩子
	BSNode<T>* _left;
	//指向节点的右孩子
	BSNode<T>* _right;
};

template<class T>
class BSTree {
public:
	typedef BSNode<T> Node;
	//构造函数
	BSTree()
		:root(nullptr)
	{}
	//析构函数
	~BSTree() {
		if (root) {
			//调用销毁二叉搜索树的函数
			destory(root);
			root = nullptr;
		}
	}
	//复制一份二叉搜索树
	Node* copy(Node* root) {
		//走到空的结点则递归返回
		if (root == nullptr)
			return nullptr;
		//否则就复制当前节点
		Node* idx = new Node(root->_data);
		//复制当前节点的左孩子
		idx->_left = copy(root->_left);
		//复制当前节点的右孩子
		idx->_right = copy(root->_right);
		return idx;
	}
	//拷贝构造
	BSTree(const BSTree<T>& tree)
		:root(copy(tree->root))
	{}
	//查找结点
	Node* find(const T& val) {
		Node* idx = root;
		//循环遍历查找
		while (idx) {
			//如果结点值等于要查找的值，那么返回结点
			if (idx->_data == val)
				return idx;
			//如果结点值大于要查找的值，则走向左孩子查找
			else if (idx->_data > val)
				idx = idx->_left;
			//如果结点值小于要查找的值，则走向右孩子查找
			else
				idx = idx->_right;
		}
	}
	//插入一个结点
	bool insert(const T& val) {
		//如果是空树，则插入到根节点
		if (root == nullptr) {
			root = new Node(val);
			return true;
		}
		//接线来就是循环遍历树，找到一个合适的位置
		//为找到合适的位置的父结点
		Node* tmp = root;
		//为找到的合适位置
		Node* idx = root;
		while (idx) {
			tmp = idx;
			if (idx->_data == val)
				return false;
			else if (idx->_data > val)
				idx = idx->_left;
			else
				idx = idx->_right;
		}
		//找到位置后判断是要插入到左边还是右边
		idx = new Node(val);
		if (tmp->_data > val)
			tmp->_left = idx;
		else
			tmp->_right = idx;
		return true;
	}
	//将二叉搜索树有序打印出来
	void inorder() {
		_inorder(root);
		cout << endl;
	}
	//删除节点
	bool erase(const T& val) {
		//在树中找到要删除的结点
		Node* cur = root;
		Node* parent = root;
		//循环遍历树，找到要删除的结点，并且保存该节点的父结点
		while (cur) {
			if (cur->_data == val)
				break;
			parent = cur;
			if (cur->_data > val)
				cur = cur->_left;
			else
				cur = cur->_right;
		}
		//是否找到要删除节点，没找到则返回失败
		if (cur == nullptr)
			return false;
		//要删除的结点没有左孩子的情况
		if (cur->_left == nullptr) {
			//删除节点为根结点
			if(cur == root){}
			else if (parent->_left == cur)
				parent->_left = cur->_right;
			else
				parent->_right = cur->_right;
			delete cur;
			cur = nullptr;
		}
		//要删除结点没有右孩子的情况
		else if (cur->right == nullptr) {
			//删除节点为根结点
			if (cur == root) {}
			else if(parent->left == cur)
				parent->left = cur->left;
			else
				parent->right = cur->left;
			delete cur;
			cur = nullptr;
		}
		//要删除节点左右孩子都存在
		else {
			//先保留要删除的结点
			Node* _root = cur;
			//然后开始找删除节点左子树中的最右节点
			parent = cur;
			cur = cur->_left;
			while (cur->_right) {
				parent = cur;
				cur = cur->_right;
			}
			//找到最右节点后交换最右节点与要删除节点的值，此时最右节点就是要删除的节点了
			swap(_root->_data, cur->_data);
			//然后判断删除节点是左孩子还是右孩子
			if (parent->_left == cur)
				//将删除节点的左子树赋给父节点的左边
				parent->_left = cur->_left;
			else
				//将删除节点的左子树赋给父节点的右边
				parent->_right = cur->_left;
			delete cur;
		}
		return true;
	}
private:
	//二叉搜索树中序遍历，此遍历结果是有序的
	void _inordef(Node* root) {
		if (root) {
			//先遍历左孩子，再遍历当前节点，最后遍历右孩子
			_inorder(root->_left);
			cout << root->_data << " ";
			_inorder(root->_right);
		}
	}
	//销毁二叉树
	void destory(Node* root) {
		if (root) {
			//删除左右孩子之后，再删除根结点
			destory(root->_left);
			destory(root->_right);
			delete root;
		}
	}
	Node* root;
};

int main() {

	return 0;
}

应用

1. K 模型
   • 概念：K 模型即只有 key 作为关键码，结构中只需要存储 key 值即可，关键码就是需要搜索到的值；
   • 举例：给一个单词 word，判断该单词是否拼写正确，具体方式如下：
     以单词集合中的每个单词作为 key，构建一棵二叉搜索树，在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误；
2. KV 模型
   • 概念：结构中存储两个数据——关键码和存储值，每一个关键码 key，都有与之对应的存储值 Value，即<Key, Value>的键值对；
   • 操作：KV 模型的二叉树在操作时不需要比较存储的值的关系，只需要比较关键码的大小，并且存储值可以重复出现，但是关键码只能唯一；
   • 举例：该种方式在现实生活中非常常见
     • 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word，chinese>就构成一种键值对；
     • 比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对；
   • 实例：比实现一个简单的英汉词典，可以通过英文找到与其对应的中文，具体实现方式如下：
     • 以<英文单词，中文含义>为键值对构造二叉搜索树，注意：二叉搜索树构建时需要比较，键值对比较时只比较关键码 key；
     • 查询英文单词时，只需给出英文单词，就可快速找到与其对应的 key，因为这相当于是二分查找，时间复杂度很低；

性能分析

• 插入和删除操作都必须先查找，因此查找效率代表了二叉搜索树中各个操作的性能；
• 对有 n 个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的正相关函数，即结点越深，则比较次数越多；
• 而且对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
  • 最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log₂N
  • 最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N