偷偷摘套内射激情视频,久久精品99国产国产精,中文字幕无线乱码人妻,中文在线中文a,性爽19p

跳表(SkipList)設(shè)計與實現(xiàn)(Java)

作者：bigsai
開發(fā) 前端
跳表是面試常問的一種數(shù)據(jù)結(jié)構(gòu)，它在很多中間件和語言中得到應(yīng)用，我們熟知的就有Redis跳表。并且在面試的很多場景可能會問到，偶爾還會讓你手寫試一試(跳表可能會讓手寫，紅黑樹是不可能的).

[[360331]]

 前言

跳表是面試常問的一種數(shù)據(jù)結(jié)構(gòu)，它在很多中間件和語言中得到應(yīng)用，我們熟知的就有Redis跳表。并且在面試的很多場景可能會問到，偶爾還會讓你手寫試一試(跳表可能會讓手寫，紅黑樹是不可能的)，這不，給大伙復(fù)原一個場景：

但你別慌，遇到蘑菇頭這種面試官也別怕，因為你看到這篇文章了(得意)，不用像熊貓那樣窘迫。

對于一個數(shù)據(jù)結(jié)構(gòu)或算法，人群數(shù)量從聽過名稱、了解基本原理、清楚執(zhí)行流程、能夠手寫 呈抖降的趨勢。因為很多數(shù)據(jù)結(jié)構(gòu)與算法其核心原理可能簡單，但清楚其執(zhí)行流程就需要動腦子去思考想明白，但是如果能夠把它寫出來，那就要自己一步步去設(shè)計和實現(xiàn)?？赡芤ê芫貌拍苷嬲龑懗鰜?，并且還可能要查閱大量的資料。

而本文在前面進(jìn)行介紹跳表，后面部分詳細(xì)介紹跳表的設(shè)計和實現(xiàn)，搞懂跳表，這一篇真的就夠了。

快速了解跳表

跳躍表(簡稱跳表)由美國計算機科學(xué)家William Pugh發(fā)明于1989年。他在論文《Skip lists: a probabilistic alternative to balanced trees》中詳細(xì)介紹了跳表的數(shù)據(jù)結(jié)構(gòu)和插入刪除等操作。

  • 跳表(SkipList，全稱跳躍表)是用于有序元素序列快速搜索查找的一個數(shù)據(jù)結(jié)構(gòu)，跳表是一個隨機化的數(shù)據(jù)結(jié)構(gòu)，實質(zhì)就是一種可以進(jìn)行二分查找的有序鏈表。跳表在原有的有序鏈表上面增加了多級索引，通過索引來實現(xiàn)快速查找。跳表不僅能提高搜索性能，同時也可以提高插入和刪除操作的性能。它在性能上和紅黑樹，AVL樹不相上下，但是跳表的原理非常簡單，實現(xiàn)也比紅黑樹簡單很多。

在這里你可以看到一些關(guān)鍵詞：鏈表(有序鏈表)、索引、二分查找。想必你的腦海中已經(jīng)有了一個初略的印象，不過你可能還是不清楚這個"會跳的鏈表"有多diao，甚至還可能會產(chǎn)生一點疑慮：跟隨機化有什么關(guān)系?你在下文中很快就能得到答案!

回顧鏈表，我們知道鏈表和順序表(數(shù)組)通常都是相愛相殺，成對出現(xiàn)，各有優(yōu)劣。而鏈表的優(yōu)勢就是更高效的插入、刪除。痛點就是查詢很慢很慢!每次查詢都是一種O(n)復(fù)雜度的操作，鏈表估計自己都?xì)獾南肟蘖恕?/p>

這是一個帶頭結(jié)點的鏈表(頭結(jié)點相當(dāng)于一個固定的入口，不存儲有意義的值)，每次查找都需要一個個枚舉，相當(dāng)?shù)穆?，我們能不能稍微?yōu)化一下，讓它稍微跳一跳呢?答案是可以的，我們知道很多算法和數(shù)據(jù)結(jié)構(gòu)以空間換時間，我們在上面加一層索引，讓部分節(jié)點在上層能夠直接定位到，這樣鏈表的查詢時間近乎減少一半，鏈表自己雖然沒有開心起來，但收起了它想哭的臉。

這樣，在查詢某個節(jié)點的時候，首先會從上一層快速定位節(jié)點所在的一個范圍，如果找到具體范圍向下然后查找代價很小，當(dāng)然在表的結(jié)構(gòu)設(shè)計上會增加一個向下的索引(指針)用來查找確定底層節(jié)點。平均查找速度平均為O(n/2)。但是當(dāng)節(jié)點數(shù)量很大的時候，它依舊很慢很慢。我們都知道二分查找是每次都能折半的去壓縮查找范圍，要是有序鏈表也能這么跳起來那就太完美了。沒錯跳表就能讓鏈表擁有近乎的接近二分查找的效率的一種數(shù)據(jù)結(jié)構(gòu)，其原理依然是給上面加若干層索引，優(yōu)化查找速度。

 

通過上圖你可以看到，通過這樣的一個數(shù)據(jù)結(jié)構(gòu)對有序鏈表進(jìn)行查找都能近乎二分的性能。就是在上面維護那么多層的索引，首先在最高級索引上查找最后一個小于當(dāng)前查找元素的位置，然后再跳到次高級索引繼續(xù)查找，直到跳到最底層為止，這時候以及十分接近要查找的元素的位置了(如果查找元素存在的話)。由于根據(jù)索引可以一次跳過多個元素，所以跳查找的查找速度也就變快了。

對于理想的跳表，每向上一層索引節(jié)點數(shù)量都是下一層的1/2.那么如果n個節(jié)點增加的節(jié)點數(shù)量(1/2+1/4+…)的結(jié)構(gòu)真的存在嗎?大概率不存在的，因為作為一個鏈表，少不了增刪該查的一些操作。而刪除和插入可能會改變整個結(jié)構(gòu)，所以上面的這些都是理想的結(jié)構(gòu)，在插入的時候是否添加上層索引是個概率問題(1>

跳表的增刪改查

上面稍微了解了跳表是個啥，那么在這里就給大家談?wù)勌淼脑鰟h改查過程。在實現(xiàn)本跳表的過程為了便于操作，我們將跳表的頭結(jié)點(head)的key設(shè)為int的最小值(一定滿足左小右大方便比較)。

對于每個節(jié)點的設(shè)置，設(shè)置成SkipNode類，為了防止初學(xué)者將next向下還是向右搞混，直接設(shè)置right，down兩個指針。

  1. class SkipNode<T> 
  2. { 
  3.     int key; 
  4.     T value; 
  5.     SkipNode right,down;//右下個方向的指針 
  6.     public SkipNode (int key,T value) { 
  7.         this.key=key; 
  8.         this.value=value; 
  9.     } 
  10. } 

 跳表的結(jié)構(gòu)和初始化也很重要，其主要參數(shù)和初始化方法為：

  1. public class SkipList <T> { 
  2.  
  3.     SkipNode headNode;//頭節(jié)點，入口 
  4.     int highLevel;//當(dāng)前跳表索引層數(shù) 
  5.     Random random;// 用于投擲硬幣 
  6.     final int MAX_LEVEL = 32;//最大的層 
  7.  
  8.     SkipList(){ 
  9.         random=new Random(); 
  10.         headNode=new SkipNode(Integer.MIN_VALUE,null); 
  11.         highLevel=0; 
  12.     } 
  13.     //其他方法 
  14. } 

 查詢操作

很多時候鏈表也可能這樣相連僅僅是某個元素或者key作為有序的標(biāo)準(zhǔn)。所以有可能鏈表內(nèi)部存在一些value。不過修改和查詢其實都是一個操作，找到關(guān)鍵數(shù)字(key)。并且查找的流程也很簡單，設(shè)置一個臨時節(jié)點team=head。當(dāng)team不為null其流程大致如下：

(1) 從team節(jié)點出發(fā)，如果當(dāng)前節(jié)點的key與查詢的key相等，那么返回當(dāng)前節(jié)點(如果是修改操作那么一直向下進(jìn)行修改值即可)。

(2) 如果key不相等，且右側(cè)為null，那么證明只能向下(結(jié)果可能出現(xiàn)在下右方向)，此時team=team.down

(3) 如果key不相等，且右側(cè)不為null，且右側(cè)節(jié)點key小于待查詢的key。那么說明同級還可向右，此時team=team.right

(4)(否則的情況)如果key不相等，且右側(cè)不為null，且右側(cè)節(jié)點key大于待查詢的key 。那么說明如果有結(jié)果的話就在這個索引和下個索引之間，此時team=team.down。

最終將按照這個步驟返回正確的節(jié)點或者null(說明沒查到)。

例如上圖查詢12節(jié)點，首先第一步從head出發(fā)發(fā)現(xiàn)右側(cè)不為空，且7<12,向右;第二步右側(cè)為null向下;第三步節(jié)點7的右側(cè)10<12繼續(xù)向右;第四步10右側(cè)為null向下;第五步右側(cè)12小于等于向右。第六步起始發(fā)現(xiàn)相等返回節(jié)點結(jié)束。

而這塊的代碼也非常容易：

  1. public SkipNode search(int key) { 
  2.     SkipNode team=headNode; 
  3.     while (team!=null) { 
  4.         if(team.key==key) 
  5.         { 
  6.             return  team; 
  7.         } 
  8.         else if(team.right==null)//右側(cè)沒有了，只能下降 
  9.         { 
  10.             team=team.down; 
  11.         } 
  12.         else if(team.right.key>key)//需要下降去尋找 
  13.         { 
  14.             team=team.down; 
  15.         } 
  16.         else //右側(cè)比較小向右 
  17.         { 
  18.             team=team.right; 
  19.         } 
  20.     } 
  21.     return null; 
  22. } 

 刪除操作

刪除操作比起查詢稍微復(fù)雜一丟丟，但是比插入簡單。刪除需要改變鏈表結(jié)構(gòu)所以需要處理好節(jié)點之間的聯(lián)系。對于刪除操作你需要謹(jǐn)記以下幾點：

(1)刪除當(dāng)前節(jié)點和這個節(jié)點的前后節(jié)點都有關(guān)系

(2)刪除當(dāng)前層節(jié)點之后，下一層該key的節(jié)點也要刪除，一直刪除到最底層

根據(jù)這兩點分析一下：如果找到當(dāng)前節(jié)點了，它的前面一個節(jié)點怎么查找呢?這個總不能再遍歷一遍吧!有的使用四個方向的指針(上下左右)用來找到左側(cè)節(jié)點。是可以的，但是這里可以特殊處理一下 ，不直接判斷和操作節(jié)點，先找到待刪除節(jié)點的左側(cè)節(jié)點。通過這個節(jié)點即可完成刪除，然后這個節(jié)點直接向下去找下一層待刪除的左側(cè)節(jié)點。設(shè)置一個臨時節(jié)點team=head，當(dāng)team不為null具體循環(huán)流程為：

(1)如果team右側(cè)為null，那么team=team.down(之所以敢直接這么判斷是因為左側(cè)有頭結(jié)點在左側(cè)，不用擔(dān)心特殊情況)

(2)如果team右側(cè)不 為null，并且右側(cè)的key等于待刪除的key，那么先刪除節(jié)點，再team向下team=team.down為了刪除下層節(jié)點。

(3)如果team右側(cè)不 為null，并且右側(cè)key小于待刪除的key，那么team向右team=team.right。

(4)如果team右側(cè)不 為null，并且右側(cè)key大于待刪除的key，那么team向下team=team.down，在下層繼續(xù)查找刪除節(jié)點。

例如上圖刪除10節(jié)點，首先team=head從team出發(fā)，7<10向右(team=team.right后面省略);第二步右側(cè)為null只能向下;第三部右側(cè)為10在當(dāng)前層刪除10節(jié)點然后向下繼續(xù)查找下一層10節(jié)點;第四步8<10向右;第五步右側(cè)為10刪除該節(jié)點并且team向下。team為null說明刪除完畢退出循環(huán)。

刪除操作實現(xiàn)的代碼如下：

  1. public void delete(int key)//刪除不需要考慮層數(shù) 
  2. { 
  3.     SkipNode team=headNode; 
  4.     while (team!=null) { 
  5.         if (team.right == null) {//右側(cè)沒有了，說明這一層找到，沒有只能下降 
  6.             team=team.down; 
  7.         } 
  8.         else if(team.right.key==key)//找到節(jié)點，右側(cè)即為待刪除節(jié)點 
  9.         { 
  10.             team.right=team.right.right;//刪除右側(cè)節(jié)點 
  11.             team=team.down;//向下繼續(xù)查找刪除 
  12.         } 
  13.         else if(team.right.key>key)//右側(cè)已經(jīng)不可能了，向下 
  14.         { 
  15.             team=team.down; 
  16.         } 
  17.         else { //節(jié)點還在右側(cè) 
  18.             team=team.right; 
  19.         } 
  20.     } 
  21. } 

 

插入操作

插入操作在實現(xiàn)起來是最麻煩的，需要的考慮的東西最多?；仡櫜樵?，不需要動索引;回顧刪除，每層索引如果有刪除就是了。但是插入不一樣了，插入需要考慮是否插入索引，插入幾層等問題。由于需要插入刪除所以我們肯定無法維護一個完全理想的索引結(jié)構(gòu)，因為它耗費的代價太高。但我們使用隨機化的方法去判斷是否向上層插入索引。即產(chǎn)生一個[0-1]的隨機數(shù)如果小于0.5就向上插入索引，插入完畢后再次使用隨機數(shù)判斷是否向上插入索引。運氣好這個值可能是多層索引，運氣不好只插入最底層(這是100%插入的)。但是索引也不能不限制高度，我們一般會設(shè)置索引最高值如果大于這個值就不往上繼續(xù)添加索引了。

我們一步步剖析該怎么做，其流程為

(1)首先通過上面查找的方式，找到待插入的左節(jié)點。插入的話最底層肯定是需要插入的，所以通過鏈表插入節(jié)點(需要考慮是否為末尾節(jié)點)

(2)插入完這一層，需要考慮上一層是否插入，首先判斷當(dāng)前索引層級，如果大于最大值那么就停止(比如已經(jīng)到最高索引層了)。否則設(shè)置一個隨機數(shù)1/2的概率向上插入一層索引(因為理想狀態(tài)下的就是每2個向上建一個索引節(jié)點)。

(3)繼續(xù)(2)的操作，直到概率退出或者索引層數(shù)大于最大索引層。

在具體向上插入的時候，實質(zhì)上還有非常重要的細(xì)節(jié)需要考慮。首先如何找到上層的待插入節(jié)點 ?

這個各個實現(xiàn)方法可能不同，如果有左、上指向的指針那么可以向左向上找到上層需要插入的節(jié)點，但是如果只有右指向和下指向的我們也可以巧妙的借助查詢過程中記錄下降的節(jié)點。因為曾經(jīng)下降的節(jié)點倒序就是需要插入的節(jié)點，最底層也不例外(因為沒有匹配值會下降為null結(jié)束循環(huán))。在這里我使用棧這個數(shù)據(jù)結(jié)構(gòu)進(jìn)行存儲，當(dāng)然使用List也可以。下圖就是給了一個插入示意圖。

其次如果該層是目前的最高層索引，需要繼續(xù)向上建立索引應(yīng)該怎么辦?

首先跳表最初肯定是沒索引的，然后慢慢添加節(jié)點才有一層、二層索引，但是如果這個節(jié)點添加的索引突破當(dāng)前最高層，該怎么辦呢?

這時候需要注意了，跳表的head需要改變了，新建一個ListNode節(jié)點作為新的head，將它的down指向老head，將這個head節(jié)點加入棧中(也就是這個節(jié)點作為下次后面要插入的節(jié)點)，就比如上面的9節(jié)點如果運氣夠好再往上建立一層節(jié)點，會是這樣的。

插入上層的時候注意所有節(jié)點要新建(拷貝)，除了right的指向down的指向也不能忘記，down指向上一個節(jié)點可以用一個臨時節(jié)點作為前驅(qū)節(jié)點。如果層數(shù)突破當(dāng)前最高層，頭head節(jié)點(入口)需要改變。

這部分更多的細(xì)節(jié)在代碼中注釋解釋了，詳細(xì)代碼為：

  1. public void add(SkipNode node) 
  2. { 
  3.  
  4.     int key=node.key; 
  5.     SkipNode findNode=search(key); 
  6.     if(findNode!=null)//如果存在這個key的節(jié)點 
  7.     { 
  8.         findNode.value=node.value; 
  9.         return; 
  10.     } 
  11.     Stack<SkipNode>stack=new Stack<SkipNode>();//存儲向下的節(jié)點，這些節(jié)點可能在右側(cè)插入節(jié)點 
  12.     SkipNode team=headNode;//查找待插入的節(jié)點   找到最底層的哪個節(jié)點。 
  13.     while (team!=null) {//進(jìn)行查找操作  
  14.         if(team.right==null)//右側(cè)沒有了，只能下降 
  15.         { 
  16.             stack.add(team);//將曾經(jīng)向下的節(jié)點記錄一下 
  17.             team=team.down; 
  18.         } 
  19.         else if(team.right.key>key)//需要下降去尋找 
  20.         { 
  21.             stack.add(team);//將曾經(jīng)向下的節(jié)點記錄一下 
  22.             team=team.down; 
  23.         } 
  24.         else //向右 
  25.         { 
  26.             team=team.right; 
  27.         } 
  28.     } 
  29.     int level=1;//當(dāng)前層數(shù)，從第一層添加(第一層必須添加，先添加再判斷) 
  30.     SkipNode downNode=null;//保持前驅(qū)節(jié)點(即down的指向，初始為null) 
  31.     while (!stack.isEmpty()) { 
  32.         //在該層插入node 
  33.         team=stack.pop();//拋出待插入的左側(cè)節(jié)點 
  34.         SkipNode nodeTeam=new SkipNode(node.key, node.value);//節(jié)點需要重新創(chuàng)建 
  35.         nodeTeam.down=downNode;//處理豎方向 
  36.         downNode=nodeTeam;//標(biāo)記新的節(jié)點下次使用 
  37.         if(team.right==null) {//右側(cè)為null 說明插入在末尾 
  38.             team.right=nodeTeam; 
  39.         } 
  40.         //水平方向處理 
  41.         else {//右側(cè)還有節(jié)點，插入在兩者之間 
  42.             nodeTeam.right=team.right; 
  43.             team.right=nodeTeam; 
  44.         } 
  45.         //考慮是否需要向上 
  46.         if(level>MAX_LEVEL)//已經(jīng)到達(dá)最高級的節(jié)點啦 
  47.             break; 
  48.         double num=random.nextDouble();//[0-1]隨機數(shù) 
  49.         if(num>0.5)//運氣不好結(jié)束 
  50.             break; 
  51.         level++; 
  52.         if(level>highLevel)//比當(dāng)前最大高度要高但是依然在允許范圍內(nèi) 需要改變head節(jié)點 
  53.         { 
  54.             highLevel=level; 
  55.             //需要創(chuàng)建一個新的節(jié)點 
  56.             SkipNode highHeadNode=new SkipNode(Integer.MIN_VALUE, null); 
  57.             highHeadNode.down=headNode; 
  58.             headNode=highHeadNode;//改變head 
  59.             stack.add(headNode);//下次拋出head 
  60.         } 
  61.     } 
  62. } 

 總結(jié)

對于上面，跳表完整分析就結(jié)束啦，當(dāng)然，你可能看到不同品種跳表的實現(xiàn)，還有的用數(shù)組方式表示上下層的關(guān)系這樣也可以，但本文只定義right和down兩個方向的鏈表更純正化的講解跳表。

對于跳表以及跳表的同類競爭產(chǎn)品：紅黑樹，為啥Redis的有序集合(zset) 使用跳表呢?因為跳表除了查找插入維護和紅黑樹有著差不多的效率，它是個鏈表，能確定范圍區(qū)間，而區(qū)間問題在樹上可能就沒那么方便查詢啦。而JDK中跳躍表ConcurrentSkipListSet和ConcurrentSkipListMap。 有興趣的也可以查閱一下源碼。

對于學(xué)習(xí)，完整的代碼是非常重要的，這里我把完整代碼貼出來，需要的自取。

  1. import java.util.Random; 
  2. import java.util.Stack; 
  3. class SkipNode<T> 
  4. { 
  5.     int key; 
  6.     T value; 
  7.     SkipNode right,down;//左右上下四個方向的指針 
  8.     public SkipNode (int key,T value) { 
  9.         this.key=key; 
  10.         this.value=value; 
  11.     } 
  12.  
  13. } 
  14. public class SkipList <T> { 
  15.  
  16.     SkipNode headNode;//頭節(jié)點，入口 
  17.     int highLevel;//層數(shù) 
  18.     Random random;// 用于投擲硬幣 
  19.     final int MAX_LEVEL = 32;//最大的層 
  20.     SkipList(){ 
  21.         random=new Random(); 
  22.         headNode=new SkipNode(Integer.MIN_VALUE,null); 
  23.         highLevel=0; 
  24.     } 
  25.     public SkipNode search(int key) { 
  26.         SkipNode team=headNode; 
  27.         while (team!=null) { 
  28.             if(team.key==key) 
  29.             { 
  30.                 return  team; 
  31.             } 
  32.             else if(team.right==null)//右側(cè)沒有了，只能下降 
  33.             { 
  34.                 team=team.down; 
  35.             } 
  36.             else if(team.right.key>key)//需要下降去尋找 
  37.             { 
  38.                 team=team.down; 
  39.             } 
  40.             else //右側(cè)比較小向右 
  41.             { 
  42.                 team=team.right; 
  43.             } 
  44.         } 
  45.         return null; 
  46.     } 
  47.  
  48.     public void delete(int key)//刪除不需要考慮層數(shù) 
  49.     { 
  50.         SkipNode team=headNode; 
  51.         while (team!=null) { 
  52.             if (team.right == null) {//右側(cè)沒有了，說明這一層找到，沒有只能下降 
  53.                 team=team.down; 
  54.             } 
  55.             else if(team.right.key==key)//找到節(jié)點，右側(cè)即為待刪除節(jié)點 
  56.             { 
  57.                 team.right=team.right.right;//刪除右側(cè)節(jié)點 
  58.                 team=team.down;//向下繼續(xù)查找刪除 
  59.             } 
  60.             else if(team.right.key>key)//右側(cè)已經(jīng)不可能了，向下 
  61.             { 
  62.                 team=team.down; 
  63.             } 
  64.             else { //節(jié)點還在右側(cè) 
  65.                 team=team.right; 
  66.             } 
  67.         } 
  68.     } 
  69.     public void add(SkipNode node) 
  70.     { 
  71.  
  72.         int key=node.key; 
  73.         SkipNode findNode=search(key); 
  74.         if(findNode!=null)//如果存在這個key的節(jié)點 
  75.         { 
  76.             findNode.value=node.value; 
  77.             return; 
  78.         } 
  79.  
  80.         Stack<SkipNode>stack=new Stack<SkipNode>();//存儲向下的節(jié)點，這些節(jié)點可能在右側(cè)插入節(jié)點 
  81.         SkipNode team=headNode;//查找待插入的節(jié)點   找到最底層的哪個節(jié)點。 
  82.         while (team!=null) {//進(jìn)行查找操作 
  83.             if(team.right==null)//右側(cè)沒有了，只能下降 
  84.             { 
  85.                 stack.add(team);//將曾經(jīng)向下的節(jié)點記錄一下 
  86.                 team=team.down; 
  87.             } 
  88.             else if(team.right.key>key)//需要下降去尋找 
  89.             { 
  90.                 stack.add(team);//將曾經(jīng)向下的節(jié)點記錄一下 
  91.                 team=team.down; 
  92.             } 
  93.             else //向右 
  94.             { 
  95.                 team=team.right; 
  96.             } 
  97.         } 
  98.  
  99.         int level=1;//當(dāng)前層數(shù)，從第一層添加(第一層必須添加，先添加再判斷) 
  100.         SkipNode downNode=null;//保持前驅(qū)節(jié)點(即down的指向，初始為null) 
  101.         while (!stack.isEmpty()) { 
  102.             //在該層插入node 
  103.             team=stack.pop();//拋出待插入的左側(cè)節(jié)點 
  104.             SkipNode nodeTeam=new SkipNode(node.key, node.value);//節(jié)點需要重新創(chuàng)建 
  105.             nodeTeam.down=downNode;//處理豎方向 
  106.             downNode=nodeTeam;//標(biāo)記新的節(jié)點下次使用 
  107.             if(team.right==null) {//右側(cè)為null 說明插入在末尾 
  108.                 team.right=nodeTeam; 
  109.             } 
  110.             //水平方向處理 
  111.             else {//右側(cè)還有節(jié)點，插入在兩者之間 
  112.                 nodeTeam.right=team.right; 
  113.                 team.right=nodeTeam; 
  114.             } 
  115.             //考慮是否需要向上 
  116.             if(level>MAX_LEVEL)//已經(jīng)到達(dá)最高級的節(jié)點啦 
  117.                 break; 
  118.             double num=random.nextDouble();//[0-1]隨機數(shù) 
  119.             if(num>0.5)//運氣不好結(jié)束 
  120.                 break; 
  121.             level++; 
  122.             if(level>highLevel)//比當(dāng)前最大高度要高但是依然在允許范圍內(nèi) 需要改變head節(jié)點 
  123.             { 
  124.                 highLevel=level; 
  125.                 //需要創(chuàng)建一個新的節(jié)點 
  126.                 SkipNode highHeadNode=new SkipNode(Integer.MIN_VALUE, null); 
  127.                 highHeadNode.down=headNode; 
  128.                 headNode=highHeadNode;//改變head 
  129.                 stack.add(headNode);//下次拋出head 
  130.             } 
  131.         } 
  132.  
  133.     } 
  134.     public void printList() { 
  135.         SkipNode teamNode=headNode; 
  136.         int index=1; 
  137.         SkipNode last=teamNode; 
  138.         while (last.down!=null){ 
  139.             last=last.down; 
  140.         } 
  141.         while (teamNode!=null) { 
  142.             SkipNode enumNode=teamNode.right; 
  143.             SkipNode enumLast=last.right; 
  144.             System.out.printf("%-8s","head->"); 
  145.             while (enumLast!=null&&enumNode!=null) { 
  146.                 if(enumLast.key==enumNode.key) 
  147.                 { 
  148.                     System.out.printf("%-5s",enumLast.key+"->"); 
  149.                     enumLast=enumLast.right; 
  150.                     enumNode=enumNode.right; 
  151.                 } 
  152.                 else{ 
  153.                     enumLast=enumLast.right; 
  154.                     System.out.printf("%-5s",""); 
  155.                 } 
  156.  
  157.             } 
  158.             teamNode=teamNode.down; 
  159.             index++; 
  160.             System.out.println(); 
  161.         } 
  162.     } 
  163.     public static void main(String[] args) { 
  164.         SkipList<Integer>list=new SkipList<Integer>(); 
  165.         for(int i=1;i<20;i++) 
  166.         { 
  167.             list.add(new SkipNode(i,666)); 
  168.         } 
  169.         list.printList(); 
  170.         list.delete(4); 
  171.         list.delete(8); 
  172.         list.printList(); 
  173.     } 
  174. } 

 進(jìn)行測試一下可以發(fā)現(xiàn)跳表還是挺完美的(自夸一下)。

 

責(zé)任編輯：姜華 來源： bigsai
SkipListJava跳表
相關(guān)推薦

2025-01-06 08:10:00

Redis跳表索引

2024-12-13 16:28:43

2023-09-27 09:39:08

Java優(yōu)化

2010-02-26 13:14:39

Java日志系統(tǒng)

2025-06-23 10:13:00

FutureTask線程開發(fā)

2009-06-14 22:09:24

Java界面布局DSL

2010-03-02 09:38:16

Java熱替換

2022-12-28 08:31:38

平臺設(shè)計應(yīng)用

2022-05-25 11:24:25

CalendarNutUI移動端

2020-10-19 10:01:12

Nodejs線程池設(shè)計

2024-06-27 10:48:48

2023-05-17 00:15:11

TCCXA模式

2020-10-23 08:31:15

Nodejs-Ipc設(shè)計實現(xiàn)

2023-08-10 10:13:35

轉(zhuǎn)轉(zhuǎn)短鏈平臺

2023-05-26 08:24:17

短信渠道模型

2022-09-12 07:17:20

redis命令redissynce

2015-06-30 11:05:11

flexibleWebAPP設(shè)計

2015-11-03 09:28:52

Hybrid技術(shù)設(shè)計實現(xiàn)

2022-09-14 09:37:22

數(shù)據(jù)系統(tǒng)

2012-03-27 11:08:23

Java
點贊
收藏

51CTO技術(shù)棧公眾號