数据结构之跳表实现

最新推荐文章于 2024-04-25 13:02:45 发布
最新推荐文章于 2024-04-25 13:02:45 发布
阅读量392 收藏
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 跳表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49561445/article/details/116144671
版权

增加了向前指针的链表叫作跳表。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。-----来自百度百科

它的效率和红黑树以及 AVL 树不相上下，但实现起来比前面两个要简单得多、
跳表具有非常优秀的查找、插入、删除性能，并且是天然的动态数据结构。

其查询、插入、删除的时间复杂度均为O(logn)

跳表的引入
在这里插入图片描述
跳表的查找

跳表的查找需要从头开始查找；如果key小于或等于当层后面节点的key,则继续向后查找；如果key更大，则层数减1即向下查找，继续比较。最终一定会到第一层

在这里插入图片描述

/*
    * @param: [value]
    * @return: DataStructure.SkipList.SkipList.Node<V>
    * @author: Jerssy
    * @dateTime: 2021/4/9 16:56
    * @description:  查找value
    */
    private Node<V> searchNode(V value){
        Node<V> headNode=head;
        while (headNode!=null){

            
            while (headNode.next != null&&headNode.next.value.compareTo(value)<0)

                headNode = headNode.next;


            if (headNode.down==null){

                return headNode.next;
            }

            headNode=headNode.down;

        }

        return null;
    }

跳表的插入

跳表的插入首先需要确定插入的层级，层级一般使用随机函数来确定

 // 随机函数
    private int randomLevel(){
        int k = 1;

        while(random.nextInt()%2 == 0){
                k ++;
        }

        return Math.min(k, MAX_LEVEL);

    }

比如计算随机函数的值为2则1层和2层都需要插入该值，这里我们需要使用集合list保存每层插入的位置-- 从顶层开始，逐层找到每层需要插入的位置并保存位置，再插入；当然如果随机的层级数大于了当前跳表的层级数则需要更新层级数
在这里插入图片描述

 /*
     * @param: [value]
     * @return: void
     * @author: Jerssy
     * @dateTime: 2021/4/9 16:56
     * @description:插入value
     */
    private  void  insertNode( V value){

        Node<V> tempNode=head;
        List<Node<V>> insertedLeveList=new ArrayList<>();
        while (tempNode!=null){

            //将每个层级需要插入的位置保存到集合中
            if (tempNode.next==null||tempNode.next.value.compareTo(value)>0){
                insertedLeveList.add( tempNode);
                tempNode=tempNode.down;

            }
            else  {
                tempNode=tempNode.next;

            }
        }

        int level =  randomLevel();
       // 如果随机的层级数，大于head节点的层级数
        if (level > this.level) {
            Node<V> temp = null;
            Node<V> prev = head;
            // 索引的层级数
            while (this.level++ != level) {
                temp = new Node<>(null);
                temp.level=this.level;
                insertedLeveList.add(0, temp);
                temp.down = prev;
                prev = temp;
            }
            head = temp;
            //更新层级
            this.level = level;
        }

        Node<V> downNode=null; Node<V> vNode ;Node<V> newNode;
        for (int i = this.level-1;i>=this.level-level;i--) {//level的每一层都需要插入newNode
              newNode=new Node<>(value);
              vNode =insertedLeveList.get(i);
              newNode.next=vNode.next;
              newNode.level=vNode.level;
              vNode.next = newNode;
              newNode.down=downNode;
              downNode=newNode;
        }

    }

跳表的删除

删除则更简单，从跳表头部开始查询删除的位置，如果比删除值小则继续向后查找，反之向下查找删除的位置，如果找到则将当前指针断裂，当前位置的前一个指针连接后面一个即可
继续向下层寻找。因为每个层级的都需要删除
注意：
因为单链表中的删除操作需要拿到要删除结点的前驱结点，然后通过
指针操作完成删除。所以在查找要删除的结点的时候，一定要获取前驱结点。当然，如果我们用的是双向链表，就不需要考虑这个问题了。
在这里插入图片描述

 /*
     * @param: [value]
     * @return: void
     * @author: Jerssy
     * @dateTime: 2021/4/9 16:55
     * @description: 删除value
     */
    private  void  deleteNode(V value){

       if (value == null) {
           return;
       }

       Node<V> headNode=head;
       while (headNode != null) {

           //因为此跳表基于单链表，则需要找到删除的前驱进行指针的连接，如果是双链表的则直接定位到删除节点
           if (headNode.next!=null&&headNode.next.value.compareTo(value)==0){

              headNode.next=headNode.next.next;
              headNode=headNode.down;//继续向下层寻找--每个层级的都需要删除

          }
          else if (headNode.next!=null&&headNode.next.value.compareTo(value)<0) headNode=headNode.next;

          else  headNode=headNode.down;

       }

    }

跳表模拟
跳表本身就是轻量级的数据结构，直接使用单链表进行模拟，当前也可以使用数组来模拟这里不再实现

package DataStructure.SkipList;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @author: Jerssy
 * @create: 2021-04-08 19:55
 * @version: V1.0
 * @slogan: 业精于勤, 荒于嬉;行成于思,毁于随。
 * @description: 跳表实现
 */
public class SkipList<V extends Comparable<V>> {

    private  Node<V> head=new Node<>(null);

    public int level;

    public  static  final int MAX_LEVEL=16;

    ThreadLocalRandom random = ThreadLocalRandom.current();

   public SkipList(int level){
       this.level = level;
       initList();
   }

   public SkipList(){
       this(MAX_LEVEL);
   }

   /*
    * @param: []
    * @return: void
    * @author: Jerssy
    * @dateTime: 2021/4/9 16:56
    * @description: 初始化
    */
   private void initList() {
       int i = level;
       Node<V> temp = null;
       Node<V> prev = null;
       //从底部节点开始创建链表每个层级的头节点
       while (i-- != 0) {
           temp = new Node<>(null);
           temp.level= level-i;
           temp.down = prev;
           prev = temp;
       }
       head = temp;//最上层头节点
   }

   /*
    * @param: [value]
    * @return: DataStructure.SkipList.SkipList.Node<V>
    * @author: Jerssy
    * @dateTime: 2021/4/9 16:56
    * @description:  查找value
    */
    private Node<V> searchNode(V value){
        Node<V> headNode=head;
        while (headNode!=null){


            while (headNode.next != null&&headNode.next.value.compareTo(value)<0)

                headNode = headNode.next;


            if (headNode.down==null){

                return headNode.next;
            }

            headNode=headNode.down;

        }

        return null;
    }

    // 随机函数
    private int randomLevel(){
        int k = 1;

        while(random.nextInt()%2 == 0){
                k ++;
        }

        return Math.min(k, MAX_LEVEL);

    }


    /*
     * @param: [value]
     * @return: void
     * @author: Jerssy
     * @dateTime: 2021/4/9 16:56
     * @description:插入value
     */
    private  void  insertNode( V value){

        Node<V> tempNode=head;
        List<Node<V>> insertedLeveList=new ArrayList<>();
        while (tempNode!=null){

            //将每个层级需要插入的位置保存到集合中
            if (tempNode.next==null||tempNode.next.value.compareTo(value)>0){
                insertedLeveList.add( tempNode);
                tempNode=tempNode.down;

            }
            else  {
                tempNode=tempNode.next;

            }
        }

        int level =  randomLevel();
       // 如果随机的层级数，大于head节点的层级数
        if (level > this.level) {
            Node<V> temp = null;
            Node<V> prev = head;
            // 索引的层级数
            while (this.level++ != level) {
                temp = new Node<>(null);
                temp.level=this.level;
                insertedLeveList.add(0, temp);
                temp.down = prev;
                prev = temp;
            }
            head = temp;
            //更新层级
            this.level = level;
        }

        Node<V> downNode=null; Node<V> vNode ;Node<V> newNode;
        for (int i = this.level-1;i>=this.level-level;i--) {//level的每一层都需要插入newNode
              newNode=new Node<>(value);
              vNode =insertedLeveList.get(i);
              newNode.next=vNode.next;
              newNode.level=vNode.level;
              vNode.next = newNode;
              newNode.down=downNode;
              downNode=newNode;
        }

    }


    /*
     * @param: [value]
     * @return: void
     * @author: Jerssy
     * @dateTime: 2021/4/9 16:55
     * @description: 删除value
     */
    private  void  deleteNode(V value){

       if (value == null) {
           return;
       }

       Node<V> headNode=head;
       while (headNode != null) {

           //因为此跳表基于单链表，则需要找到删除的前一个进行指针的连接，如果是双链表的则直接定位到删除节点
           if (headNode.next!=null&&headNode.next.value.compareTo(value)==0){

              headNode.next=headNode.next.next;
              headNode=headNode.down;//继续向下层寻找--每个层级的都需要删除

          }
          else if (headNode.next!=null&&headNode.next.value.compareTo(value)<0) headNode=headNode.next;

          else  headNode=headNode.down;

       }

    }


    // 显示 表中的结点
    public void printNode(){
        Node<V> p = head;

        while (p.down!=null){
            p=p.down;
        }

        while(p.next!= null){
            p = p.next;
            System.out.println("打印第一层数据："+p+ " ");
        }

    }


    static class  Node<V extends Comparable<V>>{

         V value;
         Node<V> next;
         Node<V> down;
         int level;
         public  Node(V value){

             this.value = value;

         }

        @Override
        public String toString() {
            return "Node{" +
                    "value=" + value +
                    ", level=" + level +
                    '}';
        }
    }


    public static void main(String[] args) {
        SkipList<Integer> skipList=new SkipList<>(4);
        skipList.insertNode(2);
        skipList.insertNode(4);
        skipList.insertNode(7);
        skipList.insertNode(1);
        skipList.insertNode(0);
        skipList.insertNode(12);
        skipList.insertNode(3);
        skipList.insertNode(5);
        skipList.printNode();
        System.out.println("************删除5**********");
        skipList.deleteNode(5);
        skipList.printNode();
        System.out.println("************查找2**********");
        System.out.println(skipList.searchNode(2));
    }
}

在这里插入图片描述

程序员的暴击
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
跳跃表(skiplist)详解及代码实现(C/C++)
Day_DreamX的博客
10-12 1663
跳跃表(skiplist)详解及代码实现(C/C++) 概念介绍 跳跃表，其实是一种可以跳跃着进行查询的链表，其的本质仍然是链表，因此要想掌握跳跃表首先需要较好的理解链表这个基础的数据结构。 以下是一个跳跃表的例子，图源博主DanielWang_ 从功能角度来看，跳跃表就像在链表之上架起了查询的“高速公路”，可以在普通链表上快速的查找到所要的元素。在查找元素时，跳表能够提供O(logn)O(logn)O(logn)的时间复杂度。 从结构角度来看，跳跃表就像一个不完整的十字链表，如果比较熟悉十字链表那么跳跃
数据结构之：跳表
www_tlj的专栏
02-25 2468
跳表（Skip List）是一种概率性数据结构，它通过在普通有序链表的基础上增加多级索引层来实现快速的查找、插入和删除操作。跳表的效率可以与平衡树相媲美，其操作的时间复杂度也是O(log n)，但跳表的结构更简单，更易于实现。
跳表详解以及Java实现
qq_44957574的博客
04-25 1039
redis zset原理——跳表数据结构详解，使用Java代码实现。
跳表C语言实现详解
hurryddd
12-25 3571
目录 一、跳表（skip list）简介 1、时间复杂度分析 2、跳表索引动态更新 二、跳表数据存储模型 三、跳表操作 1、初始化 2、插入 3、删除 4、修改 5、查询 5、销毁 参考链接 一、跳表（skip list）简介 跳表使用空间换时间的设计思路，通过构建多级索引来提高查询的效率，实现了基于链表的“二分查找”。跳表是一种动态数据结构，支持快速的插入、删除、查找...
数据结构-跳表
qq_29899535的博客
12-06 4685
一、跳表的基本概念 1、跳表的定义 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到。 2、跳表的详解 .
数据结构之跳表
03-18
数据结构之跳表的完整代码
C++数据结构实现之SkipList.zip
06-04
跳表（Skip List）是一种随机化的数据结构，它在查找、插入和删除操作上的平均时间复杂度为O(log n)，并且实现相对简单。在C++中实现跳表可以帮助我们理解和应用这种高效的数据结构。跳表通常用于数据库索引、缓存...
山东大学数据结构与算法课程设计实验跳表实现与分析（有详细注释）
最新发布
07-08
山东大学数据结构与算法课程设计实验1跳表实现与分析。 实现源代码（本实验的全部源程序代码，程序风格清晰易理解，有充分的注释） 1.实验内容 （1）构造并实现跳表ADT，跳表ADT 中应包括初始化、查找、插入、删除...
structure 跳表 vs 红黑树.zip
05-12
structure 跳表 vs 红黑树，对比了两种数据结构的优劣 跳表（Skip List）是一种基于并行链表的数据结构，类似于平衡树，用于在有序的序列中快速查找一个元素。它通过在链表上方增加多级索引，以实现快速查找的目的。...
数据结构与算法.zip
01-01
在"dfadfasdkj"这个文件中，虽然文件名看起来像是随机字符串，但通常在数据结构和算法的学习资料中，可能会包含各种数据结构的实现代码、练习题、测试用例或者教学笔记。如果能访问到这个文件，你将有机会深入学习和...
数据结构与算法-跳表详解
欢迎朋友，我是一名十多年开发经验的新手，希望多多指教。
06-06 1048
我们知道如果一个数组是有序的，查询的时候可以使用二分法进行查询，时间复杂度可以降到 O(logn) ，但如果链表是有序的，我们仍然是从前往后一个个查找，这样显然很慢，这个时候我们可以使用跳表（Skip list），跳表就是多层链表，每一层链表都是有序的，最下面一层是原始链表，包含所有数据，从下往上节点个数逐渐减少。
数据结构---跳表
qq_68695298的博客
08-08 775
跳表的原理和模拟实现
Skip List（跳跃表）原理详解与实现
qiudesuo的专栏
10-25 813
Skip List（跳跃表）原理详解与实现   本文内容框架： §1 Skip List 介绍 §2 Skip List 定义以及构造步骤   §3 Skip List 完整实现 §4 Skip List 概率分析 §5 小结       §1 S...
C++(数据结构与算法):29---跳表的实现（链表形式）
董哥的黑板报
12-12 877
一、跳表介绍 见文章：https://blog.csdn.net/qq_41453285/article/details/103448493 二、跳表的表示 在一个用有序链表描述的n个数对的字典中进行查找，至少需要n次关键字比较 如果在链表的中部节点加一个指针，则比较次数可以减少到n/2+1。这时，为了查找一个数对，首先与中间的数对比较： 如果查找的数对关键字比较小，则仅在链表的左半部分继...
Redis-跳跃表（skip List）
养歌的博客
12-13 8354
什么是跳跃表（skip list） 跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构， 跳跃表（skiplist）是一个用于有序元素序列快速搜索的随机化的数据结构，由美国计算机科学家William Pugh发明于1989年，论文《Skip lists: a probabilistic alternative to balanced trees》中提出。 它的效率和红黑树以及 AVL 树不相上下，但实现起来比较容易。是一种可以于平衡树媲美的层次化链表结构——查找、删除、添加等操作都可以在对数期望时间下
【数据结构】跳表
The porters of knowledge
02-22 869
跳表
【数据结构与算法】跳表
joy.728的博客
02-04 1797
skiplist 本质上也是一种查找结构，用于解决算法中的查找问题，跟平衡搜索树和哈希表的价值是一样的，可以作为 key 或者 key / value 的查找模型。本篇博客主要讲解了什么是跳表，如何保证跳表的效率，跳表的实现以及跳表跟平衡搜索树和哈希表的对比等。
redis数据结构跳表
07-27
跳表（Skip List）是一种有序数据结构，它允许快速地查找、插入和删除元素。在 Redis 中，跳表常用于实现有序集合（Sorted Set）数据类型。 跳表的基本思想是通过在底层链表的基础上增加多层索引，从而提高查找效率。每一层索引都是底层索引的子集，且越高层的索引节点数越少。这样，通过索引层级的跳跃，可以快速定位到目标元素的位置。 在 Redis 中，有序集合的每个成员都关联着一个分值（score），根据分值的大小决定成员的排列顺序。跳表通过分值来构建索引，从而实现高效的有序集合操作。 跳表在 Redis 中的具体实现细节可以参考 Redis 源码。Redis 使用跳表作为有序集合数据结构的底层实现，并提供了一系列命令用于对有序集合进行操作，如 ZADD、ZREM、ZRANK、ZSCORE 等。 总结一下，Redis 中的跳表数据结构是一种高效的有序集合实现方式，它通过增加多层索引来提高查找效率，适用于需要快速查找和有序遍历的场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值