二分搜索树实现

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/wanzew/article/details/82919277

class BST {
private:
	struct Node {
		int key;
		string value;
		Node* left;
		Node* right;

		Node(int key, string value) {
			this->key = key;
			this->value = value;
			this->left = NULL;
			this->right = NULL;
		}

		Node(Node& node) {
			this->key = node.key;
			this->value = node.value;
			this->left = node.left;
			this->right = node.right;
		}

	};

	Node* root;
	int count;
		
	Node* insertNode(Node* node, int f_key, string f_value) {
		if (node == NULL) {
			count++;
			return new Node(f_key, f_value);
		}

		if (node->key == f_key)
			node->value = f_value;
		else if (f_key < node->key) {
			node->left = insertNode(node->left, f_key, f_value);
		}
		else
			node->right = insertNode(node->right, f_key, f_value);

		return node;
	}

	bool findNode(Node* node, int f_key) {
		if (node == NULL) return false;

		if (node->key == f_key) 
			return true;
		else if (f_key < node->key)
			return findNode(node->left, f_key);
		else
			return findNode(node->right, f_key);

	}

	void printInOrder(Node* node) {
		if (node == NULL) return;

		printInOrder(node->left);
		cout << node->key << ": " << node->value << endl;
		printInOrder(node->right);
	}

	Node* minNode(Node* node) {
		if (node->left == NULL)
			return node;
		else
			return minNode(node->left);
	}

	Node* maxNode(Node* node) {
		if (node->right == NULL)
			return node;
		else
			return maxNode(node->right);
	}

	Node* deleteMinNode(Node* node) {
		if (node->left == NULL) {
			Node* nodeR = node->right;
			delete node;
			count--;
			return nodeR;
		}
		else
			node->left = deleteMinNode(node->left);

		return node;
	}

	Node* deleteMaxNode(Node* node) {
		if (node->right == NULL) {
			Node* nodeL = node->left;
			delete node;
			count--;
			return nodeL;
		}
		else
			node->right = deleteMaxNode(node->right);

		return node;
	}

	bool contain(Node* node, int f_key) {
		assert(count > 0);
		if (node == NULL) return false;
			
		if (f_key == node->key)
			return true;
		else if (f_key < node->key)
			return contain(node->left, f_key);
		else
			return contain(node->right, f_key);

	}

	Node* deleteNode(Node* node, int f_key) {
		if (node->key == f_key) {
			if (node->left == NULL && node->right == NULL) {
				delete node;
				count--;
				node = NULL;
				return node;
			}
			else if (node->left && node->right == NULL) {
				Node* nodeL = node->left;
				count--;
				delete node;
				return nodeL;
			}
			else if (node->left == NULL && node->right) {
				Node* nodeR = node->right;
				count--;
				delete node;
				return nodeR;
			}
			else {
				Node *newNode = new Node(maxNode(node->left)->key, maxNode(node->left)->value);
				node->left = deleteMaxNode(node->left);
				newNode->left = node->left;
				newNode->right = node->right;
				return newNode;
			}
		}
		else if (f_key < node->key)
			node->left = deleteNode(node->left, f_key);
		else
			node->right = deleteNode(node->right, f_key);

		return node;
	}

public:
	BST() {
		root = NULL;
		count = 0;
	}
	~BST() {
		while (count > 0) {
			deleteMinNode();
			count--;
		}
	}

	bool isEmpty() {
		return 0 == count;
	}
	int size() {
		return count;
	}

	void insertNode(int f_key, string f_value) {
		root = insertNode(root, f_key, f_value);
	}

	void findNode(int f_key) {
		assert(count > 0);
		if(findNode(root, f_key))
			cout << "find key " << f_key <<endl;
		else
			cout << "can not find key " << f_key << endl;
	}

	void printBST() {
		assert(count > 0);
		printInOrder(root);
	}

	Node* minNode() {
		assert(count > 0);
		return minNode(root);
	}

	Node* maxNode() {
		assert(count > 0);
		return maxNode(root);
	}

	void deleteMinNode() {
		assert(count > 0);
		if (count == 1) {
			delete root;
			root = NULL;
			count = 0;
		}
		else if (count > 1)
			root = deleteMinNode(root);
	}

	void deleteMaxNode() {
		assert(count > 0);
		if (count == 1) {
			delete root;
			count--;
			root = NULL;
		}
		else
			root = deleteMaxNode(root);
	}

	void deleteNode(int f_key) {
		assert(contain(root, f_key));
		root = deleteNode(root, f_key);
	}
};

测试：

BST bst;

bst.insertNode(10, "h");
bst.insertNode(5, "d");
bst.insertNode(3, "b");
bst.insertNode(7, "f");
bst.insertNode(2, "a");
bst.insertNode(4, "c");
bst.insertNode(6, "e");
bst.insertNode(8, "g");
bst.insertNode(15, "l");
bst.insertNode(13, "j");
bst.insertNode(12, "i");
bst.insertNode(14, "k");
bst.insertNode(17, "n");
bst.insertNode(16, "m");
bst.insertNode(18, "o");

cout << "bst.size: " << bst.size() << endl;
bst.printBST();
bst.findNode(11);
cout << "minNode: " << bst.minNode()->key << endl;
cout << "maxNode: " << bst.maxNode()->key << endl;

bst.deleteNode(7);
bst.printBST();