一个简易的元素不重复的二叉搜索树链表的实现

不知道为什么， 之前好几篇博客都被一些不出名的小网站抄了。 其实我写这些博客的目的是练手， 但是当知道被人抄了而自己却毫不知情， 还是有些蛋疼的。

代码如下：

struct TreeNode;
typedef shared_ptr<TreeNode> PTreeNode;

struct TreeNode
{
    int32_t              key        = 0;
    PTreeNode            leftChild   = nullptr;
    PTreeNode            rightChild  = nullptr;

    // 此处若设为 shared_ptr, 则会导致循环引用.
    weak_ptr<TreeNode>   parent;

    PTreeNode& MoveToNextNode (const int32_t& value)
    {
        return key < value ? rightChild : leftChild;
    }
};

class BinarySearchTree
{
private:
    PTreeNode   root;

    PTreeNode MakeNewNode (const int32_t& value)
    {
        auto newNode = make_shared<TreeNode> ();
        newNode->key = value;
        return newNode;
    }
    enum Direction { left, right };
    PTreeNode GetEdgeNode (PTreeNode node, const Direction&);
    // Return the node which the key is lowest but greater than parm node.
    PTreeNode Successor   (PTreeNode);
    bool IsLeftChild      (const PTreeNode& node)
    {
        return node->parent.lock ()->leftChild == node;
    }
    void TransferParent   (const PTreeNode&, const PTreeNode&);
public:
    PTreeNode MaxNode (PTreeNode node = nullptr)
    {
        if (node == nullptr) {
            node = root;
        }
        return GetEdgeNode (node, right);
    }
    PTreeNode MinNode (PTreeNode node = nullptr)
    {
        if (node == nullptr) {
            node = root;
        }
        return GetEdgeNode (node, left);
    }
    PTreeNode Search (const int32_t&);
    void      Insert (const int32_t&);
    void      Delete (const int32_t&);
};

void      BinarySearchTree::TransferParent  (const PTreeNode& parent, const PTreeNode& child)
{
    if (child != nullptr) {
        child->parent = parent->parent;
    }

    // The target node is root.
    if (parent->parent.expired ()) {
        root = child;
    }
    else {
        if (IsLeftChild (parent)) {
            parent->parent.lock ()->leftChild = child;
        }
        else {
            parent->parent.lock ()->rightChild = child;
        }
    }
}
PTreeNode BinarySearchTree::GetEdgeNode     (PTreeNode node, const Direction& dir)
{
    auto result = node;
    auto NextNode = [&] ()
    {
        if (dir == left) {
            return result->leftChild;
        }
        else {
            return result->rightChild;
        }
    };

    while (NextNode () != nullptr) {
        result = NextNode ();
    }
    return result;
}
PTreeNode BinarySearchTree::Successor       (PTreeNode node)
{
    // If the node has right subtree, return the min of the right subtree.
    if (node->rightChild != nullptr) {
        return MinNode (node->rightChild);
    }

    // Otherwise the node has the greatest key in it's subtree.
    auto currentParent = node->parent.lock ();

    // Search upward, until get a node 
    // which the left child is the head of the subtree that the node stay in.
    while (currentParent != nullptr && node == currentParent->rightChild) {
        node = currentParent;
        currentParent = currentParent->parent.lock ();
    }

    // And return that node.
    return currentParent;
}
PTreeNode BinarySearchTree::Search          (const int32_t& value)
{
    auto current = root;
    while (current != nullptr && current->key != value) {
        current = current->MoveToNextNode (value);
    }
    return current;
}
void      BinarySearchTree::Insert          (const int32_t& value)
{
    auto result = Search (value);
    if (result != nullptr) {
        cerr << "The" << value << "already exist!
";
        return;
    }

    if (root == nullptr) {
        root = MakeNewNode (value);
    }
    else {
        auto current = root;
        while (true) {
            auto& p =
                current->MoveToNextNode (value);
            if (p == nullptr) {
                p = MakeNewNode (value);
                p->parent = current;
                break;
            }
            current = p;
        }
    }
}
void      BinarySearchTree::Delete          (const int32_t& value)
{
    auto node = Search (value);
    if (node == nullptr) {
        cerr << "There is no such value!
";
        return;
    }

    // Don't have any child.
    if (node->leftChild == nullptr && node->rightChild == nullptr) {
        auto parent = (node->parent).lock ();
        if (IsLeftChild (node)) {
            parent->leftChild = nullptr;
        }
        else {
            parent->rightChild = nullptr;
        }
    }

    // Have double child.
    else if (node->leftChild != nullptr && node->rightChild != nullptr) {
        // Find successor
        auto successor = Successor (node);

        // Delete successor from it's subtree.
        TransferParent (successor, successor->rightChild);

        // Replace the node.
        node->key = successor->key;
    }

    // Have single child.
    else {
        if (node->leftChild != nullptr) {
            TransferParent (node, node->leftChild);
        }
        else {
            TransferParent (node, node->rightChild);
        }
    }
}