树系列文章:
树(一):二叉树(BiTree) 创建+销毁+前中后层遍历(递归+非递归)C++
树(二):线索二叉树(ThreadBiTree) 线索化及其非递归遍历C++
前言
二叉排序树(BST)相比于二叉树的特点是 :
1.左子树的元素均比根元素小, 且左子树也是BST;
2.右子树的元素均比根元素大,且右子树也是BST;
3.插入,删除新的元素之后也仍然是二叉排序树
下面以下图作为实例,完成二叉排序树的功能有:
- BST创建
- 插入
- 查找
- 删除
- BST销毁
程序代码
#include <iostream>
#include <vector>
using namespace std;
/*********************************BST(二叉排序树)**************************************/
/*********************************类申明**************************************/
struct TreeNode
{
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int val) : val(val), left(NULL), right(NULL) {}
};
class BSTree
{
TreeNode *_root;
public:
BSTree(const char *);
~BSTree();
void inTraverse(TreeNode *); //中序遍历二叉排序树,结果应由大到小
void insert(TreeNode *&, int val); //插入节点操作
TreeNode *search(TreeNode *, int val); //查询操作,找到则返回节点,否则返回NULL
TreeNode *deleteNode(TreeNode *, int val);
TreeNode *getRoot() const { return _root; }
private:
void destroyBSTree(TreeNode *);
};
/*********************************类成员定义**************************************/
BSTree::BSTree(const char *str)
: _root(NULL)
{
cout << "BSTree()" << endl;
for (int i = 0; str[i] != '\0'; i++)
insert(_root, str[i] - 48);
}
BSTree::~BSTree()
{
if (_root)
{
destroyBSTree(_root);
cout << "~BSTree()" << endl;
}
}
void BSTree::destroyBSTree(TreeNode *root)
{
if (!root)
return;
else
{
destroyBSTree(root->left);
destroyBSTree(root->right);
delete root;
root = NULL;
}
}
void BSTree::inTraverse(TreeNode *TreeNode)
{
if (TreeNode)
{
inTraverse(TreeNode->left);
cout << TreeNode->val;
inTraverse(TreeNode->right);
}
}
void BSTree::insert(TreeNode *&p, int val)
{
if (!p)
p = new TreeNode(val);
else
{
if (val < p->val)
insert(p->left, val);
else if (val > p->val)
insert(p->right, val);
else
return;
}
}
TreeNode *BSTree::search(TreeNode *p, int val)
{
if (!p)
return NULL;
else if (val < p->val)
return search(p->left, val);
else if (val > p->val)
return search(p->right, val);
else
return p;
}
TreeNode *BSTree::deleteNode(TreeNode *root, int key)
{
//找到该节点,没找到返回NULL
if (!root)
return NULL;
else if (key < root->val)
{
root->left = deleteNode(root->left, key);
return root;
}
else if (key > root->val)
{
root->right = deleteNode(root->right, key);
return root;
}
else
{
//叶子节点
if (!root->left && !root->right)
{
delete root;
return NULL;
}
//只有右子树
if (!root->left && root->right)
{
TreeNode *temp = root->right;
delete root;
return temp;
}
//只有左子树
else if (!root->right && root->left)
{
TreeNode *temp = root->left;
delete root;
return temp;
}
else
{
//左右子树均存在
TreeNode *temp = root->right;
while (temp->left)
temp = temp->left;
root->val = temp->val;
root->right = deleteNode(root->right, temp->val);
return root;
}
}
}
/**************************************测试函数****************************************/
void test1()
{
BSTree tree("628143");
tree.inTraverse(tree.getRoot());
cout << endl;
}
void test2()
{
BSTree tree("536247");
tree.deleteNode(tree.getRoot(), 3);
tree.inTraverse(tree.getRoot());
cout << endl;
}
int main()
{
test2();
return 0;
}
Leetcode701:BST插入节点
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* insertIntoBST(TreeNode* root, int val) {
TreeNode* node = new TreeNode(val);
if (!root)
return node;
if (root->val < val)
root->right = insertIntoBST(root->right, val);
else
root->left = insertIntoBST(root->left, val);
return root;
}
};
Leetcode450:BST删除节点
题解思路:
找到该节点,有四种情况:
1.为叶子节点
2.只有右子树
3.只有左子树
4.同时有左子树和右子树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* deleteNode(TreeNode* root, int key) {
if (!root)
return nullptr;
if (root->val == key)
{
TreeNode* t = root, *l = root->left, *r = root->right;
if (!l && !r) //左右子树均不存在
{
delete t;
return nullptr;
}else if (!l || !r)//左右子树有一个不存在
{
TreeNode* ans = l ? l : r;
delete t;
return ans;
}else//左右子树都存在
{
TreeNode* ans = r;
while(r->left)
r = r->left;
r->left = l;
delete t;
return ans;
}
}else if (root->val < key) //key在root右边
{
root->right = deleteNode(root->right, key);
return root;
}else//key在root左边
{
root->left = deleteNode(root->left, key);
return root;
}
}
};