跳跃表代码完整实现

跳跃表实现

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <memory>
using namespace std;

const int MaxLevel = 10;

int RandomLevel()
{
    int k = 1;
    while (rand() % 2)
    {
        k++;
    }
    k = (k <= MaxLevel) ? k : MaxLevel;
    return k;
}

class SkipNode
{
public:
    SkipNode()
    {
        key = 0;
        value = 0;
        for (int i = 0; i < MaxLevel; ++i)
        {
            forward[i] = nullptr;
        }
    }
    virtual ~SkipNode()
    {
        cout << value << endl;
    }

    int key;
    int value;
    shared_ptr<SkipNode> forward[MaxLevel];
};

class SkipList
{
public:
    SkipList()
    {
        level = 0;
    }
    virtual ~SkipList()
    {
        cout << "~Skiplist" << endl;
    }
    shared_ptr<SkipNode> CreateNode(int key, int value);
    bool InsertNode(int key, int value);
    bool DeleteNode(int key);
    int SearchNode(int key);

    void PrintNode();

private:
    int level;
    shared_ptr<SkipNode> header;
};

shared_ptr<SkipNode> SkipList::CreateNode(int key, int value)
{
    shared_ptr<SkipNode> node(new SkipNode);
    if (node == nullptr)
    {
        return nullptr;
    }
    node->key = key;
    node->value = value;
    return node;
}

bool SkipList::InsertNode(int key, int value)
{
    if (header == nullptr)
    {
        header = CreateNode(key, value);
        return true;
    }
    shared_ptr<SkipNode> update[MaxLevel];
    shared_ptr<SkipNode> p, q;
    p = header;
    int k = level;
    for (int i = k - 1; i >= 0; i--)
    {
        while ((q = p->forward[i]) && (q->key < key))
        {
            p = q;
        }
        update[i] = p;
    }
    if (q && q->key == key)
    {
        return false;
    }
    k = RandomLevel();
    if (k > level)
    {
        for (int i = level; i < k; ++i)
        {
            update[i] = header;
        }
        level = k;
    }
    q = CreateNode(key, value);
    if (q == nullptr)
    {
        return false;
    }
    for (int i = 0; i < k; i++)
    {
        q->forward[i] = update[i]->forward[i];
        update[i]->forward[i] = q;
    }
    return true;
}
bool SkipList::DeleteNode(int key)
{
    shared_ptr<SkipNode> update[MaxLevel];
    shared_ptr<SkipNode> p, q;
    p = header;
    int k = level;
    for (int i = k - 1; i >= 0; --i)
    {
        while ((q = p->forward[i]) && (q->key < key))
        {
            p = q;
        }
        update[i] = p;
    }
    if (q && q->key == key)
    {
        for (int i = 0; i < level; ++i)
        {
            q = update[i]->forward[i];
            if (q && q->key == key)
            {
                update[i]->forward[i] = q->forward[i];
            }
        }
        q = nullptr;
        for (int i = level - 1; i >= 0; --i)
        {
            if (header->forward[i] == nullptr)
            {
                level -= 1;
            }
        }
        return true;
    }
    return false;
}
int SkipList::SearchNode(int key)
{
    shared_ptr<SkipNode> p, q;
    p = header;
    int k = level;
    for (int i = k - 1; i >= 0; --i)
    {
        while ((q = p->forward[i]) && (q->key <= key))
        {
            if (q->key == key)
            {
                return q->value;
            }
            p = q;
        }
    }
    return -1;
}

void SkipList::PrintNode()
{
    shared_ptr<SkipNode> p, q;
    int k = level;
    for (int i = k - 1; i >= 0; --i)
    {
        p = header;
        while ((q = p->forward[i]) && q)
        {
            cout << p->key << "=" << p->value << " ";
            p = q;
        }
        cout << endl;
    }
    cout << endl;
}

int main(int argc, char const *argv[])
{
    shared_ptr<SkipList> skipList(new SkipList);
    srand((unsigned int)time(0));
    for (int i = 0; i < 20; i++)
    {
        skipList->InsertNode(i, rand() % 100);
    }
    skipList->PrintNode();
    skipList->DeleteNode(5);
    skipList->PrintNode();

    skipList = nullptr;
    return 0;
}