【数据结构】＜KV＞模型二叉搜索树实现

KV模型二叉搜索树：

#include<iostream>
using namespace std;
template <class K,class V>
struct BNode{
	K _key;
	V _val;
	typedef BNode<K, V> Node;
	Node* _left;
	Node* _right;

	BNode(const K& key, const V&val)
		:_key(key)
		, _val(val)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template <class K, class V>
class BTree{
public:
	typedef BNode<K, V> Node;

	Node* find(const K& key){
		Node* node = root;
		while (node){
			if (node->_key == key){
				return node;
			}
			else if (node->_key > key){
				node = node->_left;
			}
			else{
				node = node->_right;
			}
		}
		return node;
	}
	//深拷贝（递归实现）
	Node* copy(Node* root){
		if (root == nullptr){ return nullptr; }
		Node* node = new Node(root->_key, root->_val);
		node->_left = copy(root->_left);
		node->_right = copy(root->_right);
		return node;
	}

	BTree()
		:root(nullptr)
	{}

	BTree(const BTree<K, V>& btree)
		:root(copy(btree.root))
	{}

	bool insert(const K& key, const V&val){
		//空树插入就是根节点
		if (root == nullptr){
			root = new Node(key, val);
			return true;
		}
		//需要父节点辅助插入
		Node* node = root;
		Node* partent = nullptr;
		//先要保证树里面没有相同的key
		while (node){
			partent = node;
			if (node->_key == key){
				return false;
			}
			else if (node->_key > key){
				node = node->_left;
			}
			else{
				node = node->_right;
			}
		}
		//调用构造先建立一个节点
		Node* newnode = new Node(key, val);
		//用插入位置的父节点找位置插入
		if (partent->_key > key){
			partent->_left = newnode;
		}
		else{
			partent->_right = newnode;
		}
		return true;
	}

	void inorder(){
		return _inorder(root);
		cout << endl;
	}

	void _inorder(Node* root){
		if (root){
			_inorder(root->_left);
			cout << root->_key << "->" << root->_val << " ";
			_inorder(root->_right);
		}
	}

	void destory(Node* root){
		if (root){
			destory(root->_left);
			destory(root->_right);
			cout << "destory" << root->_key << "->" << root->_val <<endl;
			delete root;
		}
	}

	~BTree(){
		if (root){
			destory(root);
			root=nullptr;
		}
	}

		bool myearse(const K& key){
			Node* node = root;
			Node* partent = nullptr;
			//需要删除的节点首先要保证树里存在
			while (node){
				partent = node;
				if (node->_val){
					break;
				}
				else if (node->_key > key){
					node = node->_left;
				}
				else{
					node = node->_right;
				}
			}
			//删除的节点没有左和右节点也会走第一个判断删除
			//删除的节点只有左节点
			if (node->_left == nullptr){
				if (node == root){ root = node->_right; }
				else{
					if (node == partent->left){
						partent->_left = node->_right;
					}
					else{
						partent->_right = node->_right;
					}
				}
				delete node;
			}
			//删除的节点只有左节点
			else if (node->_right == nullptr){
				if (node == root){ root = node->_left; }
				else{
					if (node == partent->left){
						partent->_left = node->_left;
					}
					else{
						partent->_right = node->_left;
					}
				}
				delete node;
			}
			else{//左右子树都存在的情况
			//1.找节点左子树的最右节点替代
				Node* leftrightnode = node->_left;
				//找最右节点而不是最右节点的右节点（nullptr）
				//所以while的条件是这样
				while (leftrightnode->right){
					partent = leftrightnode;
					leftrightnode = leftrightnode->_right;
				}
				//交换删除节点和他的左子树的最右节点
				swap(leftrightnode->_key, node->_key);
				swap(leftrightnode->_val, node->_val);
				//此时他的左子树的最右节点可以删除了
				if (partent->_left = leftrightnode){
					//因为左子树的最右节点右子树为空，所以把他的左节点接过来
					partent->_left = leftrightnode->_left;
				}
				else{
					partent->_right = leftrightnode->_left;
				}
				delete leftrightnode;
			}
			return true;
		}

	
private:
	Node* root;

};

void test(){
	//BTree tree;
	BTree<int, int> tree;
	tree.insert(1, 3);
	tree.insert(2, 3);
	tree.insert(3, 3);
	tree.insert(5, 3);
	tree.insert(4, 3);
	tree.insert(7, 3);
	tree.insert(9, 3);
	tree.inorder();
}
int main(){
	test();
	system("pasue");
	return 0;
}