C++实现二叉搜索树BinarySearchTree

C++实现int类型元素的二叉搜索树

#include <iostream>
using namespace std;

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode() :val(0), left(nullptr), right(nullptr) {}
	TreeNode(int val, TreeNode* left, TreeNode* right) :val(val), left(left), right(right) {}
};
class BinarySearchTree {
public:
	BinarySearchTree() :root(nullptr) {}
	BinarySearchTree(const BinarySearchTree& obj) {
		root = clone(obj.root);
	}
	~BinarySearchTree() {
		clean(root);
	}
	void preorder(TreeNode* node) {
		if (node != nullptr)
		{
			cout << node->val << " ";
			preorder(node->left);
			preorder(node->right);
		}
	}
	int findMin(TreeNode* node) {
		if (node != nullptr)
		{
			while (node->left != nullptr)
			{
				node = node->left;
			}
		}
		return node->val;
	}
	int findMax(TreeNode* node) {
		if (node != nullptr)
		{
			while (node->right != nullptr)
			{
				node = node->right;
			}
		}
		return node->val;
	}
	void insert(TreeNode*& node, int data) {
		if (node == nullptr) {
			node = new TreeNode(data, nullptr, nullptr);
		}
		else if (data < node->val) {
			insert(node->left, data);
		}
		else if (data > node->val) {
			insert(node->right, data);
		}
		else;
	}
	bool find(TreeNode* node, int data) {

		if (node == nullptr)
		{
			return false;
		}
		else if (data < node->val) {
			find(node->left, data);
		}
		else if (data > node->val) {
			find(node->right, data);
		}
		else {
			return true;
		}
	}
	//非递归
	bool findV2(TreeNode* node, int data) {
		while (node != nullptr)
		{
			if (data < node->val)
			{
				node = node->left;
			}
			else if (data > node->val)
			{
				node = node->right;
			}
			else {
				return true;
			}
		}
		return false;
	}
	void remove(TreeNode*& node, int data) {

		if (node == nullptr)
		{
			return;
		}
		else if (data < node->val) {
			remove(node->left, data);
		}
		else if (data > node->val) {
			remove(node->right, data);
		}
		else {
			if (node->left != nullptr && node->right != nullptr) //左右两边都不空
			{
				node->val = findMin(node->right);
				remove(node->right, node->val);
			}
			else {//左边空、右边空、左右空
				TreeNode* oldNode = node;
				node = (node->left != nullptr) ? node->left : node->right;
				delete oldNode;
			}
		}
	}
	void clean(TreeNode*& node) {
		if (node != nullptr)
		{
			clean(node->left);
			clean(node->right);
			delete node;
		}
		node = nullptr;
	}
	TreeNode* clone(TreeNode* node) {
		if (node == nullptr)
		{
			return nullptr;
		}
		else {
			return new TreeNode(node->val, clone(node->left), clone(node->right));
		}
	}
public:
	TreeNode* root;
};

int main() {
	BinarySearchTree tree;
	tree.insert(tree.root, 3);
	tree.insert(tree.root, 2);
	tree.insert(tree.root, 4);
	tree.insert(tree.root, 1);
	tree.insert(tree.root, 5);
	tree.insert(tree.root, 6);
	tree.preorder(tree.root);
	cout << endl;
	int min = tree.findMin(tree.root);
	cout << "min: " << min << endl;
	int max = tree.findMax(tree.root);
	cout << "max: " << max << endl;
	bool isFind = tree.find(tree.root, 2);
	cout << boolalpha;
	cout << "isFind: " << isFind << endl;
	tree.remove(tree.root, 2);//删除树的一个节点
	tree.preorder(tree.root);
	cout << endl;
	BinarySearchTree tree2(tree);//copy树
	tree2.preorder(tree2.root);
	cout << endl;
	tree.clean(tree.root); //清空树
	tree.preorder(tree.root);//空树不打印
	return 0;
}

输出：
3 2 1 4 5 6
min: 1
max: 6
isFind: true
3 1 4 5 6