BST各类代码的c++实现

BST的结构体定义：

#include<iostream>
#include<unordered_map>
using namespace std;
typedef struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
}TreeNode;

BST的创建：

//BST的创建
TreeNode* Init() {
	int k;
	cin >> k;
	TreeNode* head = new TreeNode;
	head->val = k;
	TreeNode* cur = head;
	while (cin >> k) {
		if (k < cur->val) {
			cur->left = new TreeNode;
			cur->left->val = k;
			cur = cur->left;
			continue;
		}
		else {
			cur->right = new TreeNode;
			cur->right->val = k;
			cur = cur->right;
			continue;
		}
	}
	return head;
}

BST的插入：

//BST的插入
void Insert(TreeNode* head,int k) {
	if (head == nullptr) {
		return;
	}
	while (1) {
		if (head->val == k) {
			return;
		}
		if (head == nullptr) {
			head = new TreeNode;
			head->val = k;
			return;
		}
		else if (head->val < k) {
			head = head->right;
		}
		else {
			head = head->left;
		}
	}
}

BST的查找：

//BST的查找
TreeNode* Find(TreeNode* head,int k) {
	if (head == nullptr) {
		return nullptr;
	}
	while (head != nullptr) {
		if (head->val > k) {
			head = head->left;
		}
		else if (head->val < k) {
			head = head->right;
		}
		else {
			break;
		}
	}
	return head;
}

BST的删除（这里用的是中序直接后继来替换）：

//得到BST中的每个结点的父
void process(TreeNode* head,unordered_map<TreeNode*, TreeNode*>& map) {
	if (head == nullptr) {
		return;
	}
	if (head->left != nullptr) {
		map[head->left] = head;
	}
	if (head->right != nullptr) {
		map[head->right] = head;
	}
	process(head->left,map);
	process(head->right, map);
}
//中序遍历中寻找后继
TreeNode* FindBack(TreeNode* node,unordered_map<TreeNode*,TreeNode*>&map) {
	if (node->right != nullptr) {
		TreeNode* res = node->right;
		while (res->left != nullptr) {
			res = res->left;
		}
		return res;
	}
	TreeNode* parent = map[node];
	while (parent != nullptr && parent->left != node) {
		node = parent;
		parent = map[node];
	}
	return parent;
}
//BST的删除
bool DeleteByKey(TreeNode* head, int k) {
	unordered_map<TreeNode*, TreeNode*> fartherMap;
	fartherMap[head] = nullptr;
	TreeNode* goal = Find(head, k);
	if (goal == nullptr) {
		return false;
	}
	process(head, fartherMap);
	TreeNode* child = nullptr;
	TreeNode* parent = nullptr;
	if (goal->left != nullptr && goal->right != nullptr) {
		TreeNode* node = FindBack(goal, fartherMap);
		goal->val = node->val;
		goal = node;
	}
	if (goal->left != nullptr) {
		child = goal->left;
	}
	if (goal->right != nullptr) {
		child = goal->right;
	}
	parent = fartherMap[goal];
	if (parent->left == goal) {
		parent->left = child;
	}
	if (parent->right == goal) {
		parent->right = goal;
	}
	delete goal;
	return true;
}

BST中寻找小于k的最大值是多少：

//查找小于k的最大的值是多少
int FindtheMostbig(TreeNode* head, int k) {
	if (head == nullptr) {
		abort();
	}
	int res;
	while (head != nullptr) {
		if (head->val < k) {
			res = head->val;
			head = head->right;
		}
		else {
			head = head->left;
		}
	}
	return res;
}