Data Structures (Weiss) Chapter 12: Deterministic Skip Lists (跳跃链表，Comparable)

//

//  main.cpp

//  Data Structure TRY1

//

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

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

//

// Data Structures C++ Weiss: P.535 Deterministic Skip Lists

// do not use the variable INFINITY;

// CORRECT

#include<iostream>

using namespace std;

#include<math.h>

template<typename Comparable>

class DSL

{

public:

    

    DSL( const Comparable & inf)

    {

        

        bottom=new SkipNode(inf);

        bottom->right=bottom->down=bottom;

        tail=new SkipNode(inf);

        tail->right=tail;

        header=new SkipNode(inf, tail, bottom);

    }

    

    const DSL & operator=( const DSL &rhs)

    {

        if( this!=&rhs)

        {

            makeEmpty();

            delete bottom; delete header; delete tail;

            

            Comparable temp=rhs.header->element; // header->element==INFINITY

            bottom= new SkipNode(temp);

            bottom->right=bottom->down=bottom;

            tail=new SkipNode(temp);

            tail->right=tail;

            

            header=clone(rhs.header);

        }

        return *this;

    }

  

    DSL( const DSL &rhs)

    {

        if( this!=&rhs)

        {

            Comparable temp=rhs.header->element; // header->element==INFINITY

            bottom=new SkipNode(temp);

            bottom->right=bottom->down=bottom;

            tail=new SkipNode(temp);

            tail->right=tail;

            

            header=clone(rhs.header);

        }

    }

    

    

    

    ~DSL()

    {

        makeEmpty();

        delete header;

        delete tail;

        delete bottom;

    }

    

    // delete from top to bottom

    void makeEmpty()

    {

        SkipNode *current=header;

        

        while( current->down!=bottom)

        {

            current=current->down;

            

            SkipNode *p=current->right;

            

            while( p!=tail)

            {

                SkipNode *temp=p;

                p=p->right;

                delete temp;

            }

            

            p=current;

            current=current->down;

            

            delete p;

            

        }

        

    }

    

    bool contains( const Comparable &x) const

    {

        SkipNode *current=header;

        bottom->element=x;

        for(;;)

        {

            if( x<current->element)

                current=current->down;

            else if( current->element<x)

                current=current->right;

            else

                return current!=bottom;

        }

    }

    

    void insert( const Comparable &x)

    {

        SkipNode *current=header;

        

        bottom->element=x;

        while( current!=bottom)

        {

            while( current->element<x)

                current=current->right;

            

            //If gap size is 3 or at bottom level and

            //must insert, then promote middle element

            

            if( current->down->right->right->element < current->element)

            {

                current->right=new SkipNode(current->element, current->right, current->down->right->right);

                current->element=current->down->right->element;

            }

            else

                current=current->down;

        }

        

        //Raise height of DSL if necessary

        if( header->right!=tail)

            header=new SkipNode( tail->element, tail, header); // tail->element==INFINITY

        

    }

    

    bool isEmpty() const

    {

        return header->right==tail && header->down==bottom;

    }

    

    const Comparable & findMin() const

    {

        if( isEmpty())

            cout<<"Empty DSL"<<endl;

        else

        {

            SkipNode *current=header;

            while( current->down!=bottom)

                current=current->down;

            

            return current->element;

        }

    }

    

    const Comparable & findMax() const

    {

        if( isEmpty())

            cout<<"Empty DSL"<<endl;

        else

        {

            SkipNode *current=header;

            

            while( current->down!=bottom)

            {

                while( current->right->right!=tail)

                    current=current->right;

                

                current=current->down;

            }

            

            while( current->right->right!=tail)

                current=current->right;

            

            return current->element;

            

        }

    }

    

    // Print the list according to increasing order

    void Print() const

    {

        SkipNode *current=header;

        while( current->down!=bottom)

            current=current->down;

        

        while( current->right->right!=tail)

        {

            cout<<current->element<<" ";

            current=current->right;

        }

        cout<<current->element<<endl;

    }

    

    // print all levels

    void TotalPrint() const

    {

        SkipNode *current=header->down;

        while( current!=bottom)

        {

            SkipNode *p=current;

            while( p->right->right!=tail)

            {

                cout<<p->element<<" ";

                p=p->right;

            }

            cout<<p->element<<endl;

            

            current=current->down;

            

        }

    }

    

private:

    struct SkipNode

    {

        Comparable element;

        SkipNode *right;

        SkipNode *down;

        

        SkipNode( const Comparable & theElement, SkipNode *rt=NULL, SkipNode *dt=NULL)

        :element(theElement),right(rt),down(dt){}

        

    };

    

    SkipNode *header;  // the list

    SkipNode *tail;

    SkipNode *bottom;

    

    SkipNode *clone( SkipNode *t)

    {

        if( t->right==t && t->down==t) // t==bottom

            return bottom;

        else if( t->right==t) // t==tail

            return tail;

        else return new SkipNode(t->element, clone(t->right), clone(t->down));

    }

    

};

int main()

{

    

    DSL<int> L1(3000000);

    

    DSL<int> L=L1;

    

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

        L.insert(rand()%113);

    

    L.Print();

    L.TotalPrint();

    

    cout<<L.findMin()<<" "<<L.findMax()<<endl;

    

    

    

    return 0;

}