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

//

//  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,

// the typename "Comparable" is int

#include<iostream>

using namespace std;

#include<math.h>

class DSL

{

public:

    

    DSL()

    {

       bottom=newSkipNode(INT_MAX);

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

       tail=newSkipNode(INT_MAX);

        tail->right=tail;

       header=newSkipNode(INT_MAX,tail,bottom);

    }

    

   constDSL &operator=(constDSL &rhs)

    {

       if(this!=&rhs)

        {

           makeEmpty();

           deletebottom;deleteheader;deletetail;

            

           bottom=newSkipNode(INT_MAX);

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

           tail=newSkipNode(INT_MAX);

           tail->right=tail;

            

           header=clone(rhs.header);

        }

       return *this;

    }

    

    DSL(constDSL &rhs)

    {

       if(this!=&rhs)

        {

           bottom=newSkipNode(INT_MAX);

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

           tail=newSkipNode(INT_MAX);

           tail->right=tail;

           header=clone(rhs.header);

        }

    }

    

    ~DSL()

    {

       makeEmpty();

       deleteheader;

       deletetail;

       deletebottom;

    }

    

    // 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(constint &x)const

    {

       SkipNode *current=header;

       bottom->element=x;

       for(;;)

        {

           if( x<current->element)

                current=current->down;

           elseif( current->element<x)

                current=current->right;

           else

               return current!=bottom;

        }

    }

    

   void insert(constint &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=newSkipNode(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=newSkipNode(INFINITY,tail,header);

        

    }

    

   bool isEmpty()const

    {

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

    }

    

   constint & findMin()const

    {

       if(isEmpty())

           cout<<"Empty DSL"<<endl;

       else

        {

           SkipNode *current=header;

           while( current->down!=bottom)

                current=current->down;

            

           return current->element;

        }

    }

    

   constint & 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;

    }

    

   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;

            

        }

    }

    

   constint Header()const

    {

        returnheader->element;

    }

    

private:

   struct SkipNode

    {

       int element;

       SkipNode *right;

       SkipNode *down;

        

        SkipNode(constint & 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)const

    {

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

           returnbottom;

       elseif( t->right==t)

           returntail;

       elsereturnnewSkipNode(t->element,clone(t->right),clone(t->down));

        

            

    }

    

};

int main()

{

    

   DSL L1;

    

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

        L1.insert(rand()%100);

    

   DSL L=L1;

    

   cout<<"Print"<<endl;

    L.Print();

    

    cout<<"TotalPrint"<<endl;

    L.TotalPrint();

    

   cout<<"Header"<<endl;

    cout<<L.Header()<<endl;

    

   int x;

   while(cin>>x)

    {

       cout<<L.contains(x)<<endl;

    }

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

    

   DSL L2;

    L2.findMin();

    

    return 0;

}