Data Structures (Weiss) Chapter 12: Treaps

//

//  main.cpp

//  Data Structure TRY1

//

//  Created by zr9558 on 6/7/13.

//  Copyright (c) 2013 zr9558. All rights reserved.

//

// Data Structures C++ Weiss: P.548 Treap

// any node's priority must be at least as large as its parent's.

#include<iostream>

using namespace std;

#include<vector>

#include<math.h>

template<typename Comparable>

class Treap

{

public:

    Treap()

    {

        nullNode = new TreapNode;

        nullNode->left=nullNode->right=nullNode;

        nullNode->priority=INT_MAX;

        root=nullNode;

    }

    

    Treap(const Treap &rhs)

    {

        nullNode = new TreapNode;

        nullNode->left=nullNode->right=nullNode;

        nullNode->priority=INT_MAX;

        root=nullNode;

        

        root=clone(rhs.root);

    }

    

    const Treap & operator=( const Treap &rhs)

    {

        if( this!=&rhs)

        {

            makeEmpty();

            nullNode = new TreapNode;

            nullNode->left=nullNode->right=nullNode;

            nullNode->priority=INT_MAX;

            root=nullNode;

            root=clone(rhs.root);

        }

        return *this;

    }

    

    ~Treap() { makeEmpty(); }

    void makeEmpty() { makeEmpty(root); delete nullNode;}

    

    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);}

    

    void print() { Print(root);}

    

private:

    struct TreapNode

    {

        Comparable element;

        TreapNode *left;

        TreapNode *right;

        int priority;

        

        TreapNode():left(NULL),right(NULL),priority(INT_MAX){}

        TreapNode( const Comparable &e, TreapNode *lt, TreapNode *rt, int pr)

        : element(e), left(lt), right(rt), priority(pr)

        {}

    };

    

    TreapNode *root;

    TreapNode *nullNode;

    

    void rotateWithLeftChild( TreapNode * &k2)

    {

        TreapNode *k1=k2->left;

        k2->left=k1->right;

        k1->right=k2;

        

        k2=k1;

    }

    

    void rotateWithRightChild( TreapNode * &k2)

    {

        TreapNode *k1=k2->right;

        k2->right=k1->left;

        k1->left=k2;

        

        k2=k1;

    }

    

    

    void insert( const Comparable &x, TreapNode* & t)

    {

        if( t==nullNode)

            t=new TreapNode( x, nullNode, nullNode, rand());

        else if( x<t->element)

        {

            insert(x,t->left);

            if( t->left->priority < t->priority)

                rotateWithLeftChild(t);

            

        }

        else if( x>t->element)

        {

            insert(x,t->right);

            if( t->right->priority<t->priority)

                rotateWithRightChild(t);

            

        }

        

        //else duplicate; do nothing

    }

    

    void remove( const Comparable &x, TreapNode* & t)

    {

        if( t!=nullNode)

        {

            if(x<t->element)

                remove(x,t->left);

            else if( x>t->element)

                remove(x,t->right);

            else

            {

                // Match found

                if( t->left->priority <t->right->priority)

                    rotateWithLeftChild(t);

                else

                    rotateWithRightChild(t);

                

                if( t!=nullNode) //continue on down

                    remove(x,t);

                else

                {

                    delete t->left;

                    t->left=nullNode; // At a leaf

                }

            }

        }

    }

    

    void makeEmpty( TreapNode *&t)

    {

        if( t!=nullNode)

        {

            makeEmpty(t->left);

            makeEmpty(t->right);

            delete t;

        }

        t=nullNode;

    }

    

    bool contains( const Comparable &x, TreapNode * t) const

    {

        if( t==nullNode) return false;

        else if( x<t->element) return contains(x,t->left);

        else if( x>t->element) return contains(x,t->right);

        else return true;

    }

    

    void Print( TreapNode * &t) const

    {

        if( t!=nullNode)

        {

            Print(t->left);

            cout<<t->element<<" "<<t->priority<<endl;

            Print(t->right);

        }

    }

    

    TreapNode * clone( TreapNode *t) const

    {

        if( t==t->left) return nullNode; //key point, can not use t==nullNode, Since cannot test against nullNode;

        else return new TreapNode(t->element, clone(t->left), clone(t->right), t->priority);

    }

};

int main()

{

    Treap<int> T1;

    for( int i=0; i<10; ++i)

        T1.insert(rand()%113);

    

    Treap<int> T=T1;

    

    T.print();

    

    int x;

    while( cin>>x)

    {

        if( T.contains(x))

        {

            T.remove(x);

            T.print();

        }

        else cout<<"not contain"<<endl;

    }

    

    

    

    return 0;

}