树（三）：二叉排序树（BST） C++实现

树系列文章：
树（一）：二叉树(BiTree) 创建+销毁+前中后层遍历（递归+非递归）C++

树（二）：线索二叉树(ThreadBiTree) 线索化及其非递归遍历C++

树（三）：二叉排序树（BST） C++实现

树（四）：平衡二叉树(AVL) C++实现

树（五）：哈夫曼树(HuffmanTree) 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插入节点

leetcode701地址

/**
 * 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删除节点

leetcode450地址

题解思路：
找到该节点，有四种情况：
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;
        }
    }
};