123 skip list 确定性跳跃表的实现

/Files/rocketfan/Deterministic_Skip_Lists.pdf

/Files/rocketfan/determinsticList_readme.pdf

确定性跳跃表，可以实现o(log(n))级别的插入删除和查找，复杂度与二叉搜索树相同，但是实现起来简单许多

这里给出一个实现，不允许重复的key。关于确定性跳跃表的定义及详细介绍，可参展数据结构与算法分析 c语言描述 中文第二版的p357.

//123 skip list 的实现文件

  1 /** 
  2  *  \file determin_skip_list.h
  3  *  \author pku_goldenlock
  4  *  \date  2009-8-7
  5  */
  6 
  7 #ifndef _DETERMIN_SKIP_LIST_H
  8 #define _DETERMIN_SKIP_LIST_H
  9 
 10 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
 11     TypeName(const TypeName&); \
 12     void operator=(const TypeName&)
 13 
 14 #include <iostream>
 15// #include "skip_list.h"
 16 namespace skip_list {
 17 
 18 /**
 19  * class SkipNode. 
 20  * the node type for DeterminSkipList to operate.
 21  */
 22 template <typename ElemType>
 23 class SkipNode {
 24     public:
 25         template <typename T>  friend class DeterminSkipList;
 26         SkipNode();
 27         SkipNode(const ElemType &key_input, SkipNode *right_input = NULL, 
 28                  SkipNode *down_input = NULL);
 29     private:
 30         DISALLOW_COPY_AND_ASSIGN(SkipNode); /** Do not all copy and assign*/
 31         ElemType key;       /**< The key is what we use for comparing during Search,Insert,Remove.*/
 32         SkipNode *right;    /**< Point to the right skip node ont the same level*/
 33         SkipNode *down;     /**< Point to the lower level skip node where we will go down from current node */
 34 };
 35 
 36 template <typename ElemType>
 37 SkipNode<ElemType>::SkipNode() : right(NULL), down(NULL) {}
 38 
 39 template <typename ElemType>
 40 SkipNode<ElemType>::SkipNode(const ElemType& key_input, SkipNode *right_input, 
 41                              SkipNode *down_input)
 42     : key(key_input), right(right_input), down(down_input) {}
 43 
 44 /* *
 45  * DeterminSkipList
 46  * An implementaion of skip list using 1-2-3 skip list
 47  */
 48 template <typename ElemType>
 49 class DeterminSkipList {
 50     public:
 51         /** Client should determin Max and Max + 1 value*/
 52         DeterminSkipList(const ElemType &max,const ElemType &max_1);
 53         ~DeterminSkipList();
 54         /** Clear the whoe skip list free all allocated resouces on heap*/
 55         void Clear();
 56         bool Search(const ElemType &value) const; 
 57         /**
 58          * If the list already has one node whose key == value
 59          * return false and do not do insert otherwise insert a new node with
 60          * its key == value and return true
 61          */
 62         bool Insert(const ElemType &value);
 63         /**
 64          * If the list already has one node whose key == value
 65          * remove it and return true otherwise return false
 66          */
 67         bool Remove(const ElemType &value);
 68         /** For debug*/
 69         /** Show the internal structure of the skip list*/
 70         void Print() const; 
 71         /** Return false if current structure of the skip list is wrong*/
 72         bool IsValid() const;
 73         
 74     private:
 75         /** For simplicty here do not allow copy and assign*/
 76         DISALLOW_COPY_AND_ASSIGN(DeterminSkipList);
 77         void Init();
 78         void ClearHelp(SkipNode<ElemType> *current);
 79         /**
 80          * Helper function for Search
 81          * If could not find one node with key value == item return bottom
 82          * otherwise return postion of node containing the key
 83          * */
 84         SkipNode<ElemType> * SearchHelp(const ElemType &value) const; 
 85         /** Helper function for Remove, find all the nodes with key == value and modify it to other_value*/
 86         void FindAndModifyRemoveHelp(const ElemType &value, const ElemType &other_value);
 87         /** lower the head if possible during Remove help to keep skip list structure consistent*/
 88         void LowerHeadRemoveHelp();
 89    
 90     private:
 91         //actual data skip list store
 92         SkipNode<ElemType> *head;   /**< where we start*/
 93         SkipNode<ElemType> *bottom; /**< mark if we have down to the lowerest level*/
 94         SkipNode<ElemType> *tail;   /**< mark the end of each level*/
 95 
 96         const ElemType Max;         /**< Max > any client input key value*/
 97         const ElemType Max_1;       /**< Max_1 > Max*/
 98 };
 99 
 template <typename ElemType>
 DeterminSkipList<ElemType>::DeterminSkipList(const ElemType &max, const ElemType &max_1)
     : head(NULL), bottom(NULL), tail(NULL), Max(max), Max_1(max_1)
 {
     Init();
 }
 
 template <typename ElemType>
 DeterminSkipList<ElemType>::~DeterminSkipList()
 {
     if (head) {
         Clear();
     }
 }
 
 template <typename ElemType>
 void DeterminSkipList<ElemType>::Init()
 {
     //init head bottom and tail see paper p372 figure 6
     bottom = new SkipNode<ElemType>;
     bottom->right = bottom->down = bottom;
    
     tail = new SkipNode<ElemType>(Max_1);
     tail->right = tail;
 
     head = new SkipNode<ElemType>(Max, tail, bottom);
 }
 
 template <typename ElemType>
 void DeterminSkipList<ElemType>::Clear()
 {
     ClearHelp(head->down);
     delete head;
     delete bottom;
     delete tail;
     head = NULL;
     bottom = NULL;
     tail = NULL;
 }
 
 template <typename ElemType>
 void DeterminSkipList<ElemType>::ClearHelp(SkipNode<ElemType> *current)
 {
     SkipNode<ElemType> *temp;
     if (current == bottom)
         return;
     ClearHelp(current->down);
     while (current != tail) {
         temp = current;
         current = current->right;
         delete temp;
     }
 }
 
 template <typename ElemType>
 inline bool DeterminSkipList<ElemType>::Search(const ElemType &value) const
 {
     return ((SearchHelp(value) == bottom) ? false : true ); 
 }
 
 template <typename ElemType>
 SkipNode<ElemType> * DeterminSkipList<ElemType>::
         SearchHelp(const ElemType &value) const
 {
     SkipNode<ElemType> *current;
 
     current = head;
     while (current != bottom) {
         while (value > current->key)
             current = current->right;
         if (current->down == bottom)
             return ((value == current->key) ? current : bottom);
         current = current->down;
     }
     return NULL;
 }
 
 /** 
  * Insert a key value to the skip list.
  * if that the key value has already existed. 
  * return false and will not insert.  
  * else insert and return true.
  */
 template <typename ElemType>
 bool DeterminSkipList<ElemType>::Insert(const ElemType &value)
 {
     SkipNode<ElemType> *current, *new_node;
     
     current = head;
     bottom->key = value;
     bool can_insert = true;
     while (current != bottom) {
         while (value > current->key) 
             current = current->right;
         //if exists one elem whose key == value return false do not need insert
         if ((current->down == bottom) && (value == current->key)) {
             can_insert = false; //can not insert but should check if need to adjust head before return
             break;
         }
         //if gap size is 3 or at bottom level and must insert 
         //then promote the middle element
         if ((current->down == bottom)
              || (current->key > current->down->right->right->key)) {
             new_node = new SkipNode<ElemType>;
             new_node->right = current->right; 
             new_node->down = current->down->right->right;
             current->right = new_node;
             new_node->key = current->key;
             current->key = current->down->right->key;
         }
         current = current->down;
     }
     //if need to raise the height of the skip list,raise it
     if (head->right != tail) {
         new_node = new SkipNode<ElemType>;
         new_node->down = head;
         new_node->right = tail;
         new_node->key = Max;
         head = new_node;
     }
 
     return can_insert;
 }
 template <typename ElemType>
 void DeterminSkipList<ElemType>::FindAndModifyRemoveHelp(const ElemType &value, const ElemType &other_value)
 {
     SkipNode<ElemType> *current;
 
     current = head;
     while (current != bottom) {
         while (value > current->key)
             current = current->right;
         if (value == current->key)
             current->key = other_value;
         current = current->down;
     }
 
 }
 template <typename ElemType>
 void DeterminSkipList<ElemType>::LowerHeadRemoveHelp()
 {
     SkipNode<ElemType> *temp;
     if (head->down->right == tail) {
         temp = head->down;
         head->down = temp->down;
         delete temp;
     }
 }
 template <typename ElemType>
 bool DeterminSkipList<ElemType>::Remove(const ElemType &value)
 {
     //empty list can not remove
     if (head->down == bottom)
         return false;
     //current node, previous node of current, start mark the begining of each level when the node goes down
     //if previous finally equal to start means have not advanced toward right on this level
     //next save the start position of the next level for current node
     SkipNode<ElemType> *current, *previous, *temp, *next;
 
     current = head->down;
     int visit_num = 0;
     bool can_remove = true; 
     for(;;) {  //loop and will return when curent->down == bottom
         previous = NULL;
         while (value > current->key) {   //try advance toward right as far as possible
             previous = current;
             current = current->right;
         }
         //visit num will mark if a node is a height 1 node 
         if (value == current->key)   
             visit_num++;
 
         //if on level 1 try to remove if possible and return
         if (current->down == bottom) {
             if (visit_num == 0) {       //can not find do not  need to remove
                 LowerHeadRemoveHelp(); ///might need to lower the head
                 can_remove = false;
                 return false;
             }
             else { //need to remove 
                 if(visit_num == 1) {  //if node height == 1 just remove it
                     //delete need to consider down fild of the upper level
                     //so swap current and current->right
                     temp = current->right; //to be deleted
                     current->key = current->right->key;
                     current->right = temp->right;
                     delete temp;
                     LowerHeadRemoveHelp(); ///might need to lower the head
                 } else {    
                     //if current node height > 1, swap the key with neighbour than delete the neighbour
                     //here swap with left neigbour,notice we must have advaced right on 
                     //this level otherwise it must be a height 1 node.
                     //we will find all the node with key value current->key and modify it 
                     //to previous->key
                     LowerHeadRemoveHelp(); //need to make sure the sturcture correct first
                     FindAndModifyRemoveHelp(current->key, previous->key); 
                     previous->right = current->right; 
                     delete current;
                 }
                 return true;
             }
         } 
         //on other levels ,not level 1
         //save the postion to go down on the lower level
         next = current->down;  //the next level will be unchaged when dealing the current level
         //current->key == current->down->right->key means the gap we want to down 
         //is of size only 1
         if (current->key == current->down->right->key) {
             //the first gap case, consider current gap and the next
             if (previous == NULL) {  //have not advanced on this level
                 //if the next gap has 2 or more one level lower element 
                 //one element need to lower down,the other one need to raise one level, 
                 //just swap do not need to delte space
                 if (current->right->key > current->right->down->right->key) {
                     current->key = current->right->down->key;
                     current->right->down = current->right->down->right;
                 } else {
                     //one element need to lower down,need to delete space
                     temp = current->right;
                     current->key = temp->key;
                     current->right = temp->right;
                     delete temp; 
                 }
             } else {    //not the first so consider the privious gap and the current
                 if (previous->key > previous->down->right->key) { 
                     temp = previous->down->right;
                     if (temp->right->key != previous->key)
                         temp = temp->right;
                     previous->key = temp->key;
                     current->down = temp->right;
                 } else {                       
                     previous->key = current->key;
                     previous->right = current->right;
                     delete current;
                 }
             }
         } 
         current = next; //go to the next level (one level lower)
     }
 }
 
 template <typename ElemType>
 bool DeterminSkipList<ElemType>::IsValid() const
 {
     SkipNode<ElemType> *current, *temp, *temp2;
     int gap_size;
 
     current = head;
     while (current->down != bottom) {
         temp = current;
         while (temp != tail) {
             temp2 = temp->down;
             gap_size = 0;
             while(temp2->key != temp->key) {
                 gap_size++;
                 temp2 = temp2->right;
             }
             if (gap_size < 1 || gap_size > 3)
                 return false;
             temp = temp->right;
         }
         current = current->down;
     }
     return true;
 }
 
 
 template <typename ElemType>
 void DeterminSkipList<ElemType>::Print() const 
 {
     using namespace std;
     SkipNode<ElemType> *current, *temp;
 
     current = head;
     while (current != bottom) {
         temp = current;
         while (temp != NULL) {
             if (temp != tail) {
                 cout << temp->key << "(" 
                      << temp->down->key << ") ";
                 temp = temp -> right;
             } else {
                 cout << temp->key << "[" 
                      << "tail" << "] ";
                 temp = NULL;
             }
         }
         cout << endl;
         current = current->down;
     }
     cout << endl;
 }
 
 
 } //end fo namespace skip_list
 
 #endif //end of _DETERMIN_SKIP_LIST_H

//123 skip list 的测试文件

 1 #include <iostream>
 2 #include <string>
 3 #include <fstream>
 4 
 5 #include "determin_skip_list.h"
 6 
 7 using namespace std;
 8 using namespace skip_list;
 9 
 /**
  * TestSkipList is the kernal test fuction of Insert,Search and Remove of a
  * determinstic skip list.
  * @param skip_list is the user created empty skip list for test
  * @param in is the ifstream relating to the opened file
  * @param out is the ofstream relating to the file to write result
  */
 template <typename T>
 void TestSkipList(DeterminSkipList<T> &skip_list, ifstream &in, ofstream &out) 
 {
     string op;
     string value;
     ///loop to get input and to corresponding operation on skip_list
     ///and write the result to the out put file
     while(in >> op >> value) {
         if (op == "INS") {
             if (skip_list.Insert(value))
                 out << op << " " << value << endl;
             else
                 out << "DUP" << " " << value << endl;
         } else if (op == "FIND") {
             if (skip_list.Search(value))
                 out << op << " " << value << endl;
             else
                 out << "NONE" << " " << value << endl;
         } else if (op == "REM") {
             if (skip_list.Remove(value))
                 out << op << " " << value << endl;
             else
                 out << "NONE" << " " << value << endl;
         }
         if (!skip_list.IsValid())
             cout << "not valid for " << op << " " << value << endl; 
     }
 }
 
 int main(int argc, char *argv[])
 {
     if (argc != 3) {
         cout << "Usage is : " 
              << "test_determin_skip_list <input_file> <output_file>" 
              << endl;
         return -1;
     }
     ///argv[1] the name of the file to open
     ///argv[2] the name of the file to wirte
     ifstream in(argv[1]);
     if (!in) {
         cout << "Could not find the file named "
              << argv[1] << " to open!"<< endl;
         return -1;
     }
     ofstream out(argv[2]);
     ///create a empty skip list key type is string,
     ///assumming for any input key value
     ///key value < Max < Max_1
     char a[2];
     a[0] = char(254); a[1] = '\0';
     const string Max(a);
     a[0] = char(255);
     const string Max_1(a);
     DeterminSkipList<string> skip_list(Max, Max_1); 
 
     try {
         TestSkipList(skip_list, in, out); ///The main test process
     } catch(std::bad_alloc&) { ///will exit if can not allocate more space
         cout << "no more available memory" << endl;
         in.close();
         out.close();
         return -1;
     }
 
     in.close();
     out.close();
     return 0;
 }