版权声明:码字不易,转载请注明出处: https://blog.csdn.net/qq_24309981/article/details/88681602
1 理论
1、一种特殊化了的二叉树
- 左不大于,右不小于;
- 常见的二叉搜索树操作:查询、最小值、最大值、前驱、后继、插入、删除;
- 大部分二叉搜索树操作的最坏运行时间与树的高度成正比;
2、随机构建二叉搜索树(Randomly Built Binary Search Tree)
- 随机构建二叉搜索树:随机插入关键字(对比按关键字排列顺序插入)到一棵初始的空树中而生成的树;
- 一棵有 个不同关键字的随机构建二叉搜素树的期望高度为 ;
2 代码
代码中构建的二叉搜索树长下面这个样子:
#include <iostream>
using namespace std;
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode* parent;
TreeNode(int x) : val(x), left(NULL), right(NULL), parent(NULL) {}
};
class BST {
private:
TreeNode* root;
public:
BST(TreeNode* root){
this->root = root;
}
~BST() {
}
TreeNode* getRoot() const {
return root;
}
//node既可为一节点,也可为一棵树(但必须是二叉搜索树)
void insert(TreeNode* node) {
TreeNode* x = root;
TreeNode* y = NULL;
while (x)
{
y = x;
x = node->val < root->val ? x->left : x->right;
}
node->parent = y;
y ? (node->val < y->val ? y->left = node : y->right = node) : root = node;
}
void del(TreeNode* node) {
if (!node->left)
transplant(node, node->right);
else if (!node->right)
transplant(node, node->left);
else
{
TreeNode* y = minimum(node->right);
if (y != node->right)
{
transplant(y, y->right);
y->right = node->right;
node->right->parent = y;
}
transplant(node, y);
y->left = node->left;
node->left->parent = y;
}
}
private:
void transplant(TreeNode* delN, TreeNode* repN) {
if (repN)
repN->parent = delN->parent;
if (!delN->parent)
root = repN;
else
delN == delN->parent->left ? delN->parent->left = repN : delN->parent->right = repN;
}
public:
static TreeNode* searchRecursion(TreeNode* node, int key) {
if (!node || node->val == key) return node;
return key < node->val ? searchRecursion(node->left, key) : searchRecursion(node->right, key);
}
static TreeNode* searchIteration(TreeNode* node, int key) {
while (node && node->val != key)
node = key < node->val ? node->left : node->right;
return node;
}
static TreeNode* minimum(TreeNode* node) {
if (node)
{
while (node->left)
node = node->left;
}
return node;
}
static TreeNode* maximum(TreeNode* node) {
if (node)
{
while (node->right)
node = node->right;
}
return node;
}
static TreeNode* successor(TreeNode* node) {
if (node->right)
return minimum(node->right);
TreeNode* y = node->parent;
while (y && node == y->right)
{
node = y;
y = y->parent;
}
return y;
}
static TreeNode* predecessor(TreeNode* node) {
if (node->left)
return maximum(node->left);
TreeNode* y = node->parent;
while (y && node == y->left)
{
node = y;
y = y->parent;
}
return y;
}
};
int main()
{
TreeNode* node1 = new TreeNode(15);
TreeNode* node2 = new TreeNode(6);
TreeNode* node3 = new TreeNode(18);
TreeNode* node4 = new TreeNode(3);
TreeNode* node5 = new TreeNode(7);
TreeNode* node6 = new TreeNode(17);
TreeNode* node7 = new TreeNode(20);
TreeNode* node8 = new TreeNode(2);
TreeNode* node9 = new TreeNode(4);
TreeNode* node10 = new TreeNode(13);
TreeNode* node11 = new TreeNode(9);
node1->left = node2;
node2->parent = node1;
node1->right = node3;
node3->parent = node1;
node2->left = node4;
node4->parent = node2;
node2->right = node5;
node5->parent = node2;
node3->left = node6;
node6->parent = node3;
node3->right = node7;
node7->parent = node3;
node4->left = node8;
node8->parent = node4;
node4->right = node9;
node9->parent = node4;
node5->right = node10;
node10->parent = node5;
node10->left = node11;
node11->parent = node10;
//TreeNode* res = searchRecursion(node1, 17);
TreeNode* res = BST::searchIteration(node1, 17);
if (res)
{
cout << res->val << endl;
}
res = BST::minimum(node1);
if (res)
{
cout << res->val << endl;
}
res = BST::maximum(node1);
if (res)
{
cout << res->val << endl;
}
res = BST::successor(node11);
if (res)
{
cout << res->val << endl;
}
res = BST::predecessor(node11);
if (res)
{
cout << res->val << endl;
}
BST bst(node1);
TreeNode* testNode = new TreeNode(21);
bst.insert(testNode);
res = BST::maximum(node1);
if (res)
{
cout << res->val << endl;
}
bst.del(node1);
res = BST::searchIteration(bst.getRoot(), node1->val);
if (res)
{
cout << res->val << endl;
}
else
{
cout << "根节点已被删除" << endl;
}
system("pause");
return 0;
}
//输出
17
2
20
13
7
21
根节点已被删除