20120919二叉树 数据结构《数据结构与算法分析》

又是一次的毕业季，羡慕嫉妒啊....

二叉查找树类的框架：

template <typename Comparable>
class BinarySearchTree
{
public:
    BinarySearchTree();
    BinarySearchTree(const BinarySearchTree & rhs)
    ~BinarySearchTree();

    const Comparable & findMin() const;
    const Comparable & findMax() const;

    bool contains(const Comparable & x ) const;
    bool isEmpty() const;
    void printTree() const;

    void makeEmpty();
    void insert(const Comparable & x);
    void remove(const Comparable & x);

    const BinarySearchTree & operator = (const BinarySearchTree & rhs);

private:
    struct BinaryNode
    {
        Comparable element;
        BinaryNode *left;
        BinaryNode *right;

        BinaryNode(const  Comparable & theElement,BinaryNode *lt,BinaryNode *rt):element(theElement),left(lt),right(rt){}
    };

    BinaryNode *root;

    void insert (const Comparable & x,BinaryNode * & t) const;
    void remove (const Comparable & x ,BinaryNode * & t) const;
    BinaryNode * findMin(BinaryNode *t) const;
    BinaryNode * findMax(BinaryNode *t) const;
    bool contains( const Comparable & x,BinaryNode * t) const;
    void makeEmpty( BinaryNode * & t);
    void printTree(BinaryNode *t) const;
    BinaryNode * clone(BinaryNode *t) const;
};

contains    insert   remove三种操作递归列表：

bool contains (const Comparable & x) const
{
    return contains(x,root)
}
void insert(const Comparable & x)
{
    insert (x,root);
}
void remove(const Comparable & x)
{
    remove(x,root);
}

二叉查找树的contains操作：

bool contains(const Comparable & x,BinaryNode * t) const
{
    if( t == NUll )
        return false;
    else if ( x < t->element )
        return contains(x,t->left );
    else if (t->element < t)
        return contains(x,t->right);
    else
        return true;
}

使用函数对象 实现 二叉查找树：

template <typename Object,typename Comparator = less<Object>>
class BinarySearchTree
{
    public:
    private:
        BinaryNode * root;
        Comparable isLessThan;

        bool contains( const Object & x,BinaryNode *t ) const
        {
            if(t == NULL)
                return false;
            else if (isLessThan(x,t->element))
                return contains(x,t->left);
            else if (isLessThan(t->element,x))
                return contains(x,t->right);
            else
                return true;
        }
};

findMin方法的递归实现：

BinaryNode * findMin( BinaryNode * t) const
{
    if( t == NULL)
        return NULL;
    if(t->left == NULL)
        return t;
    return findMin(t->left);
}

findMax方法的递归实现：

BinaryNode * findMax(BinaryNode * t) const
{
    if(t != NULL)
        while( t ->right !=NULL)
            t = t->right;
    return t;
}

二叉查找树插入操作：

void insert( const Comparable & x,BinaryNode * & t )
{
    if( t== NULL)
        t = new BinaryNode(x,NULL,NULL);
    else if (x<t->element)
        insert(x,t->left);
    else if (t->element < x)
        insert(x,t->right);
    else
        ;
}

二叉查找树 删除操作:

void remove (const Comparable & x,BinaryNode * & t)
{
    if( t == NULL)
        return;
    if( x <  t->element)
        remove( x,t->left);
    else if ( t->element < x)
        remove(x,t->right);
    else if (t->left != NULL && t->right!=NULL )
    {
        t->element = findMin( t->right)->element;
        remove(t->element , t->right);
    }
    else
    {
        BinaryNode *oldNode = t;
        t = ( t->left !=NULL) ? t->left : t->right;
        delete oldNode;
    }
}

析构函数递归实现makeEmpty

~BinarySearchTree()
{
    makEmpty();
}
void makeEmpty(BinaryNode * & t)
{
    if( t != NULL)
    {
        makeEmpty(t->left);
        makeEmpty(t->right);
        delete t;
    }
    t = NULL;
}

operator= 递归实现clone：

const BinarySearchTree & operator=( const BianrySearchTree & rhs)
{
    if(this != &rhs)
    {
        makeEmpty();
        root = clone(rhs.root);
    }
    return *this;
}

BinaryNode * clone( BinaryNode * t) const
{
    if( t == NULL)
        return NULL;
    return new BinaryNode ( t->element,clone(t->left),clone(t->right));
}