【数据结构】二叉搜索树的C++实现和优化测试

私有成员变量

private:
	struct Node {
		Key key;//键
		Value value;//值
		Node* left;//左子树
		Node* right;//右子数
		Node(Key k, Value v)//节点类型
		{
			key = k;
			value = v;
			left = NULL;
			right = NULL;
		}
		Node(Node* node)//构造函数
		{
			key = node->key;
			value = node->value;
			left = node->left;
			right = node->right;
		}
	};
	Node* root;//成员变量 根节点
	int count;//元素数量

公有成员函数（外界接口）
难点插入删除

	myBST()
	{
		root = NULL;
		count = 0;
	}
	~myBST()
	{
		delete_ROOT(root）;
	}
	// 前序遍历
	void preOrder() {
		preOrder(root);
	}

	// 中序遍历
	void inOrder() {
		inOrder(root);
	}

	// 后序遍历
	void postOrder() {
		postOrder(root);
	}
	//层序遍历 通过构建队列
	void levelOrder()
	{
		queue<Node*> q;
		q.push(root);
		while (!q.empty())
		{
			Node* tmp = q.front();//取出头结点
			q.pop();
			if(tmp->left)
				q.push(tmp->left);//左节点进入队列
			if(tmp->right)
				q.push(tmp->right);//右节点进队列
		}
	}
	int size()
	{
		return count;
	}
	bool isEmpty()
	{
		return count == 0;
	}
	bool contain(Key key)
	{
		return contain(root, key);
	}
	Value* search(Key key)
	{
		return search(root, key);
	}
	//递归 返回root*类型
	void insert(Key k, Value v)
	{
		root = insert(root, k, v);//这棵树的头结点是node
	}
	//递归 返回空指针
	void insert_3(Key k, Value v)
	{
		insert_3(root, k, v);//这棵树的头结点是node
	}
	//非递归 使用二级指针
	void insert_2(Key k, Value v)
	{
		Node** tmp = &root;
		while ((*tmp) != NULL)
		{
			if ((*tmp)->key == k) {
				(*tmp)->value = v;
				//return root; 
			}
			else if ((*tmp)->key > k) { tmp = &((*tmp)->left); }
			else { tmp = &((*tmp)->right); }
		}
		(*tmp) = new Node(k, v);
		///return root;
	}
	//非递归 一级指针 判断父亲节点（或者可以增加一个临时变量记录父节点，没有尝试）
	void insert_4(Key k, Value v)
	{
		Node* tmp = root;
		while ((tmp) != NULL)
		{
			if ((tmp)->key == k) { (tmp)->value = v; return; }
			else if ((tmp)->key > k) {
				if (!tmp->left)
				{
					tmp->left = new Node(k, v);
					return;
				}
				else
				{
					tmp = tmp->left;
				}
			}
			else {
				if (!tmp->right)
				{
					tmp->right = new Node(k, v);
					return;
				}
				else
					tmp = ((tmp)->right);
			}
		}
		root = new Node(k, v);
	}
	Key minimum()
	{
		assert(count != 0);
		return minimum(root)->key;
	}
	Key maxmum()
	{
		assert(count != 0);
		return maxmum(root)->key;
	}
	void removeMin()
	{
		if (root != NULL)
			removeMin(root);
	}
	void removeKey(Key key)
	{
		removeKey(root, key);
	}

私有成员函数

	void delete_ROOT(Node* node)
	{
		if(node==NULL)
		{
			return ;
		}
		delete_ROOT(node->left);
		delete_ROOT(node->right);
		delete node;
		count--;
	}
	
	void preOrder(Node* node)
	{
		cout << node->key << endl;
		preOrder(node->left);
		preOrder(node->right);
	}
	void postOrder(Node* node)
	{
		
		postOrder(node->left);
		postOrder(node->right);
		cout << node->key << endl;
	}
	void inOrder(Node* node)
	{
		inOrder(node->left);
		cout << node->key << endl;
		inOrder(node->right);
	}

	bool contain(Node* node, Key key)
	{
		if (node == NULL)
		{
			return false;
		}

		if (node->key == key)
		{
			return true;
		}
		else if (node->key > key)
		{
			return contain(node->left, key);
		}
		else
			return contain(node->right, key);
	}
	Value* search(Node* node, Key key)
	{
		if (node == NULL)
		{
			return NULL;
		}
		if (node->key == key)
		{
			return &node->value;
		}
		else if (node->key > key)
		{
			return search(node->left, key);
		}
		else
		{
			return search(node->right, key);
		}
	}
	//如果不这样做的话 原始的数1-2-3 给3增加一个节点 3-4 3-4和3对于2来说 是不一样的节点 所以必须每个返回值都得是Node* 改一个每一层的子节点都发生了变化
	Node* insert(Node* node, Key k, Value v)//传过来节点的值
	{
		if (node == NULL)//结束条件
		{
			node = new Node(k, v);//增加新节点
			count++;//当前树的count增加
			return node;
		}
		if (node->key == k)
		{
			node->value = v;
		}
		else if (node->key < k)
		{
			node->right = insert(node->right, k, v);//传过来的是
		}
		else { node->left = insert(node->left, k, v); }
		return node;
	}
	void insert_3(Node*& node, Key k, Value v)
	{
		if (node == NULL)
		{
			node = new Node(k, v);//增加新节点
			count++;//当前树的count增加
			return;
		}
		if (node->key == k)
		{
			node->value = v;
		}
		else if (node->key < k)
		{
			insert_3(node->right, k, v);//传过来的是地址
		}
		else { insert_3(node->left, k, v); }
	}
	Node* minimum(Node* node)
	{
		if (node->left == NULL)
		{
			return node;
		}
		return minimum(node->left);
	}
	Node* maxmum(Node* node)
	{
		if (node->right == NULL)
		{
			return node;
		}
		return maxmum(node->right);
	}
	Node* removeMin(Node* node)
	{
		if (node->left == NULL)//找到最左边的节点
		{
			Node* tmp = node->right;//缓存右节点
			delete node;
			count--;
			return tmp;//把右节点return回去
		}
		node->left = removeMin(node->left);//新节点代替原来的左节点
		return node;
	}
	Node* removeMax(Node* node)
	{
		if (node->right == NULL)
		{
			Node* tmp = node->left;//缓存左节点
			delete node;
			count--;
			return tmp;//把左节点return回去
		}
		node->right = removeMax(node->right);//新节点代替原来的右节点
		return node;
	}
	Node* removeKey(Node* node,Key key)
	{
		if (node == NULL)
		{
			return NULL;
		}
		if (node->key > key)
		{
			node->left = removeKey(node->left,key);//从左节点中remove 左节点换成新的值
		}
		else if (node->key < key)
		{
			node->right = removeKey(node->right, key);
		}
		else
		{
			if (node->left == NULL)//没有左子树 删除 用右子树替代
			{
				Node* tmp = node->right;
				delete node;
				count--;
				return tmp;
			}
			else if (node->right == NULL)
			{
				Node* tmp = node->left;
				delete node;
				count--;
				return tmp;
			}
			else
			{	
				//找到右子树的最小值
				Node* tmp = new(minimum(node->right));//使用返值进行拷贝构造 构造一个新的值 因为之前的被delete掉了 
				/*Node* tmp = new Node;
				tmp->key = minimum(node->right)->key;
				tmp->value = minimum(node->right)->value;*/
				count++;//提前把count加上
				//更新右子树
				tmp->right = removeMin(node->right);//这里会count--	
				//更新左子树
				tmp->left = node->left;
				//删除节点
				delete node;
				count--;
				return tmp;
			}
		}
	}