源码系列：二叉排序树

binary_search_tree.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

namespace algo
{
    template<typename T>
    class BinarySearchTree
    {
    private:
        struct _Node
        {
            T value;
            _Node *left;
            _Node *right;
        };

    public:
        BinarySearchTree() : _root(NULL){}

        ~BinarySearchTree()
        {
            _RecursiveReleaseNode(_root);
        }

        bool Create(vector<T> &vec)
        {
            for(vector<T>::iterator iter = vec.begin();iter != vec.end();iter++)
            {
                if(!Insert(*iter))
                {
                    return false;
                }
            }
            return true;
        }

        bool Insert(T data)
        {
            _Node *node = new _Node();
            if(node == NULL)
            {
                cout << "空间不足！分配失败！\n" << endl;
                return false;
            }
            node->value = data;
            node->left = NULL;
            node->right = NULL;

            _Node *current_node = _root;
            _Node *parent_node = current_node;
            int flag = 0;

            if(current_node == NULL)
            {
                _root = node;
            }
            else
            {
                while(current_node)
                {
                    if(data < current_node->value)
                    {
                        parent_node = current_node;
                        current_node = current_node->left;
                        flag = 0;
                    }
                    else
                    {
                        parent_node = current_node;
                        current_node = current_node->right;
                        flag = 1;
                    }
                }

                if(flag == 0)
                {
                    parent_node->left = node;
                }
                else
                {
                    parent_node->right = node;
                }
            }

            return true;
        }

        bool Search(T data)
        {
            if(!_root)
            {
                return false;
            }

            _Node *current_node = _root;
            while(current_node)
            {
                if(data == current_node->value)
                {
                    cout << "找到" << data << endl;
                    break;
                }else if(data < current_node->value)
                {
                    current_node = current_node->left;
                }else
                {
                    current_node = current_node->right;
                }
            }
            if(current_node == NULL)
                return false;
            return true;
        }

        bool Delete(T data)
        {
            return _Delete(_root,data);
        }

        void Display()
        {
            _Display(_root);
        }

    private:
        bool _Delete(_Node *&node,T data)
        {
            if(!_root)
                return false;

            if(data == node->value)
            {
                if(node->left == NULL && node->right == NULL)
                {
                    delete node;
                    node = NULL;
                }
                else if(node->left != NULL && node->right == NULL)
                {
                    _Node *temp = node->left;
                    delete node;
                    node = temp;
                }
                else if(node->left == NULL && node->right != NULL)
                {
                    _Node *temp = node->right;
                    delete node;
                    node = temp;
                }
                else
                {
                    _Node *current_node = node->left;
                    _Node *parent_node = NULL;
                    while(current_node->right != NULL)
                    {
                        parent_node = current_node;
                        current_node = current_node->right;
                    }

                    node->value = current_node->value;
                    if(parent_node)
                    {
                        parent_node->right = current_node->left;
                    }
                    else
                    {
                        node->left = current_node->left;
                    }
                    delete current_node;
                }
                return true;
            }
            else if(data < node->value)
                return _Delete(node->left,data);
            else
                return _Delete(node->right,data);
        }

        void _Display(_Node *node)
        {
            if(node)
            {
                _Display(node->left);
                cout << node->value << "\t";
                _Display(node->right);
            }
        }

        void _RecursiveReleaseNode(_Node* node)
        {
            if(node)
            {
                _RecursiveReleaseNode(node->left);
                _RecursiveReleaseNode(node->right);
                delete node;
            }
        }
        _Node *_root;
    };
}

测试程序：

#include <iostream>
#include "binary_search_tree.cpp"

using namespace std;

int main()
{
    algo::BinarySearchTree<int> bst;
    int data[8] = {13,15,6,20,14,5,7,18};
    vector<int> vec(data,data+sizeof(data)/sizeof(int));
    bst.Create(vec);
    bst.Display();

    cout << endl;
    bst.Delete(20);
    bst.Display();

    cout << endl;
    bst.Delete(15);
    bst.Display();

    cout << endl;
    bst.Delete(13);
    bst.Display();
    return 0;
}

测试所用BST:

测试结果：