数据结构之跳表

最新推荐文章于 2024-06-26 10:51:56 发布
最新推荐文章于 2024-06-26 10:51:56 发布
阅读量548 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 C++ 跳表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tutuxs/article/details/52833576
版权

字典

字典有一些形如

字典类

字典的节点
// 链表节点定义
template <typename K, typename E>
struct pairNode
{
    pair<const K, E> element;
    pairNode<K, E>* next;

    pairNode() {}
    pairNode(const pair<const K, E>& element) : element(element)
    {

    }
    pairNode(const pair<const K, E>& element, pairNode<K, E>* next)
        : element(element)
    {
        this->next = next;
    }
};
字典类

这里主要实现上述的操作

template <typename K, typename E>
class sortedChain
{
public:
    sortedChain();
    ~sortedChain();

    bool emtpy() const
    {
        return dSize == 0;
    }

    int size() const
    {
        return dSize;
    }

    pair<const K, E>* find(const K&) const;     // 查找操作, 如果找到返回指针，否则返回NULL
    void erase(const K&);
    void insert(const pair<const K, E>&);
    void output(ostream& out) const;
private:
    pairNode<K, E>* firstNode; 
    int dSize;
};
字典类的实现
find()

只需要一次遍历，判断currentNode->element.first 和 theKey 是否相等

insert()

插入的时候首先通过查找操作来确定字典中是否存在相同关键字的数对，如果有，则更新（因为是一对一的字典）

template <typename K, typename E>
void sortedChain<K, E>::insert(const pair<const K, E>& thePair)
{
    pairNode<K, E>* p = firstNode, *tmp = NULL;
    // 遍历链表
    while(p != NULL && p->element.first < thePair.first)
    {
        tmp = p;
        p = p->next;
    }
    // 如果存在相同的key值，更新
    if(p != NULL && p->element.first == thePair.first)
    {
        p->element.second = thePair.second;
        return;
    }
    // 插入
    pairNode<K, E>* newNode = new pairNode<K,E>(thePair, p);
    if(tmp == NULL)
        firstNode = newNode;
    else
        tmp->next = newNode;
    dSize++;
}
erase()
template <typename K, typename E>
void sortedChain<K, E>::erase(const K& theKey)
{
    pairNode<K, E>* p = firstNode, *tmp = NULL;

    while(p != NULL && p->element.first < theKey)
    {
        tmp = p;
        p = p->next;
    }

    if(p != NULL && p->element.first == theKey)
    {
        if(tmp == NULL)     // 这种情况的出现是因为while循环没有执行，之所以不执行是因为, 要没删除的theKey是第一个
            firstNode = p->next;
        else
            tmp->next = p->next;
        // 删除p（thekey所在位置）
        delete p;
        --dSize;
    }
}

跳表

构建思路

当我们在进行链表查找，删除，添加的时候，要进行n次的比较，如果链表的中间有一个指针，那么我们的这些操作次数可以减少一半。

定义

增加额外的向前指针的链表叫做跳表，因此它会比普通的链表复杂一点。跳表结构的头结点需要足够的指针域，以满足最大链表级数的构建需要，而尾节点不需要指针域。

如下图的结构我们叫做跳表，在该结构中有一组等级链表，0级链表包括所有数对，1级链表每2个节点取一个，2级链表每4个取一个，当然隔几个取一个指针不是固定的。

跳表

跳表类

节点

与字典节点结构有点不同，next指针变为指针数组，即指针域

template <typename K, typename E>
struct skipNode
{
    typedef pair<const K, E> pairType;

    pairType element;
    skipNode<K, E>** next;      // 指针数组

    skipNode(const pairType& thePair, int size) : element(thePair)
    {
        next = new skipNode<K, E>*[size];
    }
};

跳表类

template <typename K, typename E>
class SkipList
{
public:
    SkipList(K largeKey, int maxPairs, float prob);
    ~SkipList();

    // find, 如果找到返回指针，没有返回NULL
    pair<const K, E>* find(const K& theKey) const;
    // level，级的分配
    int level() const;
    // search，搜索
    skipNode<K,E>* search(const K& theKey) const;
    // insert， 插入操作
    void insert(const pair<const K, E>& thePair);
    // erase，删除操作
    void erase(const K& theKey);

private:
    float cutOff;               // 用来确定层数
    int levels;                 // 当前最大的非空链对
    int dSize;                  // 字典的数对个数
    int maxLevel;               // 允许的最大链表层数
    K tailKey;                  // 最大关键字
    skipNode<K, E>* headerNode; // 头结点指针
    skipNode<K, E>* tailNode;   // 尾节点指针
    skipNode<K, E>** last;      // last[i] 表示i层的最后节点
};
删除

在删除节点后需要重新更新级数

查找

例如，如果我们要查找关键字为30的节点，find从最高级链表开始查找，知道0级链表。在每一级链表中采用逼近的方法，直到0级链表，图解如下：
跳表查找

部分代码

template <typename K, typename E>
pair<const K, E>* SkipList<K,E>::find(const K& theKey) const
{
    // 返回匹配的数对的指针
    // 如果关键字大于最大关键字，返回NULL
    if(theKey >= tailKey)
        return NULL;

    // 位置beforeNode是关键字为theKey的节点之最右边的位置
    skipNode<K,E>* beforeNode = headerNode;
    for(int i = levels; i >= 0; i--)
        while(beforeNode->next[i]->element.first < theKey)
            beforeNode = beforeNode->next[i];

    if(beforeNode->next[0]->element.first == theKey)
        return &beforeNode->next[0]->element;

    return NULL;
}
完整代码
/* 跳表实现 */

#ifndef _SKIPLIST_H_
#define _SKIPLIST_H_

#include <iostream>
#include <cstdlib>  // RAND_MAX
#include <cmath>    // ceil()
#include <new>
using namespace std;

template <typename K, typename E>
struct skipNode
{
    typedef pair<const K, E> pairType;

    pairType element;
    skipNode<K, E>** next;

    skipNode() {}

    skipNode(const pairType& thePair, int size) : element(thePair)
    {
        next = new skipNode<K, E>* [size];
    }
};

template <typename K, typename E>
class SkipList
{
public:
    SkipList() {}
    SkipList(K largeKey, int maxPairs, float prob);
    ~SkipList();

    // find, 如果找到返回指针，没有返回NULL
    pair<const K, E>* find(const K& theKey) const;
    // level，级的分配
    int level() const;
    // search，搜索
    skipNode<K,E>* search(const K& theKey) const;
    // insert， 插入操作
    void insert(const pair<const K, E>& thePair);
    // erase，删除操作
    void erase(const K& theKey);

private:
    float cutOff;               // 用来确定层数
    int levels;                 // 当前最大的非空链对
    int dSize;                  // 字典的数对个数
    int maxLevel;               // 允许的最大链表层数
    K tailKey;                  // 最大关键字
    skipNode<K, E>* headerNode; // 头结点指针
    skipNode<K, E>* tailNode;   // 尾节点指针
    skipNode<K, E>** last;      // last[i] 表示i层的最后节点
};


template <typename K, typename E>
SkipList<K, E>::SkipList(K largeKey, int maxPairs, float prob)
{
    // 构造函数，关键字小于largeKey且数对个数size最多为maxPairs, 0 < prob < 1;
    cutOff = prob * RAND_MAX;
    maxLevel = (int)ceil(logf((float)maxPairs) / logf(1 / prob)) - 1;   // 向上取整
    levels = 0;
    dSize = 0;
    tailKey = largeKey;

    // 生产头结点，尾节点和数组last
    pair<K,E> tailPair;
    tailPair.first = tailKey;
    headerNode = new skipNode<K, E> (tailPair, maxLevel + 1);
    tailNode = new skipNode<K, E> (tailPair, 0);
    last = new skipNode<K, E>*[maxLevel + 1];

    for(int i = 0; i <= maxLevel; i++)
        headerNode->next[i] = tailNode;
}

template <typename K, typename E>
SkipList<K,E>::~SkipList()
{
    // Empty
}

template <typename K, typename E>
pair<const K, E>* SkipList<K,E>::find(const K& theKey) const
{
    // 返回匹配的数对的指针
    // 如果关键字大于最大关键字，返回NULL
    if(theKey >= tailKey)
        return NULL;

    // 位置beforeNode是关键字为theKey的节点之最右边的位置
    skipNode<K,E>* beforeNode = headerNode;
    for(int i = levels; i >= 0; i--)
        while(beforeNode->next[i]->element.first < theKey)
            beforeNode = beforeNode->next[i];

    if(beforeNode->next[0]->element.first == theKey)
        return &beforeNode->next[0]->element;

    return NULL;
}

template <typename K, typename E>
int SkipList<K,E>::level() const
{
    // 返回一个表示链表级的随机数，这个数不大于maxLevel
    int lev = 0;
    while(rand() <= cutOff)
        lev++;
    return (lev <= maxLevel) ? lev : maxLevel;
}

template <typename K, typename E>
skipNode<K, E>* SkipList<K, E>::search(const K& theKey) const
{
    // 返回beforeNode时关键字
    skipNode<K, E>* beforeNode = headerNode;
    for(int i = levels; i >= 0; i--)
    {
        while(beforeNode->next[i]->element.first < theKey)
            beforeNode = beforeNode->next[i];
        last[i] = beforeNode;
    }
    return beforeNode->next[0];
}

template <typename K, typename E>
void SkipList<K,E>::insert(const pair<const K, E>& thePair)
{
    if(thePair.first >= tailKey)
    {
        cout << "Key = " << thePair.first << " must be < " << tailKey;
        return;
    }

    // 查看关键字是否已经存在
    skipNode<K, E>* theNode = search(thePair.first);
    if(theNode->element.first == thePair.first)
    {
        theNode->element.second = thePair.second;
        return;
    }

    // 若不存在, 确定所在链级数
    int theLevel = level();
    if(theLevel > levels)
    {
        theLevel = ++levels;
        last[theLevel] = headerNode;
    }
    // 再借点theNode 之后插入新节点
    skipNode<K, E>* newNode = new skipNode<K, E>(thePair, theLevel + 1);
    for(int i = 0; i < theLevel; i++)
    {
        // 插入i级链表
        newNode->next[i] = last[i]->next[i];
        last[i]->next[i] = newNode;
    }

    dSize++;    
    return;
}

template <typename K, typename E>
void SkipList<K,E>::erase(const K& theKey)
{
    if(theKey >= tailKey)
        return;

    //查看是否有匹配的数对
    skipNode<K,E>* theNode = search(theKey);
    if(theNode->element.first != theKey)
        return;

    for(int i = 0; i <= levels && last[i]->next[i] == theNode; i++)
        last[i]->next[i] = theNode->next[i];

    while(levels > 0 && headerNode->next[levels] == tailNode)
        levels--;

    delete theNode;
    dSize--;
}

#endif // !_SKIPLIST_H_
Xefvan
关注
专栏目录
go语言-数据结构之跳表
weixin_42657872的博客
07-26 421
跳表go语言初步实现
数据结构-跳表
qq_29899535的博客
12-06 4802
一、跳表的基本概念 1、跳表的定义 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到。 2、跳表的详解 .
数据结构——跳表Skip List
最新发布
qq_50604294的博客
06-26 991
1.定义跳表（Skip List）：是一种概率性数据结构，由William Pugh在1990年提出，主要用于在有序的元素集合上进行快速的搜索、插入和删除操作。跳表的效率与平衡树相当，但实现起来更简单，它通过维护多层链表来提高查找效率。2. 实现原理在原有的有序链表上面增加了多级索引，通过索引进行二分查找从而实现高效率查找，其每种操作(搜索、插入、删除)的平均复杂性均为O(logn)。3.特点特点描述结构多层链表，每层是下层的子集。查找效率。
【数据结构】跳表
Sprjdfn的学习笔记
05-21 1042
写在前面的话 跳表实际上是一种非常好使的数据结构，但由于用的人比较少，所以在OI竞赛中并不常用，但其效率是很高的。想要深入研究的同学可以研究： 《让算法的效率“跳起来”！ 》—— 魏冉 《线段跳表——跳表的一个拓展》——李骥扬 这两位大神的论文 跳表的定义 跳表的每一层都是一个链表 每一条链表的两端必须是−∞-\infty和+∞+\infty 每条链的元素必须包含于序数较低的
面试中的高级数据结构之跳表
Great_Eagle的博客
01-13 571
微信公众号：算法面试题            扫码开启算法之旅 总结： 跳表具有如下性质： (1) 由很多层结构组成 (2) 每一层都是一个有序的链表 (3) 最底层(第0层)的链表包含所有元素 (4) 如果一个元素出现在第i层中，则它在第0到第i-1层也都会出现  (5) 跳表是一种随机化的数据结构（通过掷硬币的过程可以看出）点评：跳表是一种应用广泛的数据结构，著名的Redis与Leve...
数据结构之——跳表说明及实现
记录一些有用的东西
07-28 406
调表的简要说明即实现
数据结构与算法(c++)——跳跃表(skip list)
u014282109的博客
04-11 378
https://www.cnblogs.com/learnhow/p/6749648.html今天要介绍一个这样的数据结构：&gt;&gt;完整代码单向链接有序保存支持添加、删除和检索操作链表的元素查询接近线性时间——跳跃表 Skip List一、普通链表对于普通链接来说，越靠前的节点检索的时间花费越低，反之则越高。而且，即使我们引入复杂算法，其检索的时间花费依然为O(n)。为了解决长链表结构的检...
跳跃表（Skip List）
深未来技术
03-11 237
跳跃表（Skip List）是1987年才诞生的一种崭新的数据结构，它在进行查找、插入、删除等操作时的期望时间复杂度均为O(logn),有着近乎替代平衡树的本领。而且最重要的一点，就是它的编程复杂度较同类的AVL树，红黑树等要低得多，这使得其无论是在理解还是在推广性上，都有着十分明显的优势。     首先，我们来看一下跳跃表的结构    跳跃表由多条链构成（S0，S1，S2 ……，Sh），...
数据结构 - 跳表
「 虚幻私塾」
04-13 774
Python微信订餐小程序课程视频 https://blog.csdn.net/m0_56069948/article/details/122285951 Python实战量化交易理财系统 https://blog.csdn.net/m0_56069948/article/details/122285941 简介 有序的数组可以使用二分查找的方法快速检索一个数据，但是链表没有办法使用二分查找。 对于一个单向链表来说，即使链表中存储的是有序的数据，但如果想要从中查找某个数据时，也只能从头到尾遍历链表，其时间复
数据结构——跳表
blexsantos的博客
01-30 241
  王争数据结构17——笔记 1、为了使以链表存储的数据仍然能够使用二分查找，将链表进行改造形成跳表。 2、跳表是一个动态数据结构，支持快速的插入、删除、查找，具有替代红黑树的能力。 3、跳表就是链表增加多级索引的结构。通常跳表的时间复杂度为O（3logn）,即O(logn)。查找的时间复杂度和二分查找相同。 4、跳表是典型的空间换时间。原始链表大小为n,每隔两个节点抽1个，总结点数目为...
数据结构之：跳表
www_tlj的专栏
02-25 2626
跳表（Skip List）是一种概率性数据结构，它通过在普通有序链表的基础上增加多级索引层来实现快速的查找、插入和删除操作。跳表的效率可以与平衡树相媲美，其操作的时间复杂度也是O(log n)，但跳表的结构更简单，更易于实现。
数据结构——跳跃表
aaaaaaaWoLan的博客
05-24 1267
跳跃表介绍 跳跃表（skiplist）是一种随机化的数据结构，是一种可以与平衡树媲美的层次化链表结构——查找、删除、添加等操作都可以在对数期望时间下完成，以下是一个典型的跳跃表例子： 到底有多随机，我们看了原理就知道了。 跳跃表原理 这里借助(1条消息) 跳跃表的原理和实现（Java）_CoderLucas的博客-CSDN博客_跳跃表原理和实现 中的图来讲解。 查找 假设当前我们要查找 39，我们要先从 head (第一层的第一个元素)开始查找： 39 > 负无穷，继续往后查找 39 >
redis数据结构跳表
07-27
跳表（Skip List）是一种有序数据结构，它允许快速地查找、插入和删除元素。在 Redis 中，跳表常用于实现有序集合（Sorted Set）数据类型。 跳表的基本思想是通过在底层链表的基础上增加多层索引，从而提高查找效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值