跳表的java实现，转载自网络，仅供自己学习使用

文档结构：

1、代码结构

2、代码实现

1、代码结构

节点类：

String key 键值 对跳跃表的操作都是根据键值进行的

Int value  实际值

Node  up,down,left,right; 每个节点都有四个方向

String tou;

String wei; 每层链表的头和尾节点

跳跃表类：

Head 头节点

Tail 尾结点

H 层数

Size 元素个数

Random 随机数，用来确定需不需要增加层数 即：掷硬币

findF () 按从小到大的顺序找到应该插入的位置 插入排序法

Add () 添加节点函数，在最底层插入结点后，进行掷硬币来确定是否需要曾增加层数，直到掷硬币不能增加层数为止，增加层数的同事需要把增加之后的节点进行连接。

Find() 根据跳跃表进行查找并打印路线。查找从最上层开始然后找到被查找节点的前个节点小于被查找节点，然后被查找节点的后一个节点大于其被查找节点，则从被查找节点的前一个节点向下走down，然后继续向右查找，直到找到为止。

2、代码实现

1. package 跳跃表;
2. import java.util.*;
3. public class SkipList {
4. public Node head;   //头节点
5. public Node tail;   //尾结点
6. public int h;   //层数
7. public int size;    //元素个数
8. public Random rand; //每次的随机数用来确定需不需要增加层数
9. public SkipList(){
10. Node p1 = new Node(Node.tou,0);
11. Node p2 = new Node(Node.wei, 0);
12. head=p1;
13. tail=p2;
14. head.setRight(tail);
15. tail.setLeft(head);
16. h=0;
17. size=0;
18. rand = new Random();
19. }
20. public boolean isEmpty(){
21. if(size==0){
22. return true;
23. }
24. return false;
25. }
26. //找到需要插入位置的前一个节点
27. public Node findF(String k){
28. Node temp;
29. temp=head;
30. while(true){
31. while(temp.getRight().key!=Node.wei&&temp.getRight().key.compareTo(k)<=0){
32. /*
33. * 当链表最底层不为空的时候，从当前层向尾部方向开始查找，直到查找temp.getRight的下一个值大于 当前k的值为止，此时temp小于或等于当前k的值
34. *  要插入的位置即为temp之后的位置了
35. */
36. temp=temp.getRight();
37. }
38. if(temp.getDown()!=null){
39. temp=temp.getDown();
40. }else{
41. break;
42. }
43. }
44. return temp;    //找到节点并返回
45. }
46. public int add(String k, int v){
47. Node temp, temp1;
48. temp=findF(k);
49. int i;  //当前层数
50. if(k.equals(temp.getKey())){
51. System.out.println("对象属性完全相同无法添加！");
52. int a=temp.value;
53. temp.value=v;
54. return  a;
55. }
56. temp1=new Node(k,v);
57. temp1.setLeft(temp);
58. temp1.setRight(temp.getRight());
59. temp.getRight().setLeft(temp1);
60. temp.setRight(temp1);
61. i=0;
62. while(rand.nextDouble()<0.5){    //进行随机，是否需要 在上层添加
63. if(i>=h){    //若当前层数超出了高度，则需要另建一层
64. Node p1 ,p2 ;
65. h=h+1;
66. p1=new Node(Node.tou,0);
67. p2=new Node(Node.wei,0);
68. p1.setRight(p2);
69. p1.setDown(head);
70. p2.setLeft(p1);
71. p2.setDown(tail);
72. head.setUp(p1);
73. tail.setUp(p2);
74. head=p1;
75. tail=p2;
76. }
77. while(temp.getUp() == null){
78. temp=temp.getLeft();
79. }
80. temp=temp.getUp();
81. Node node=new Node(k,v);
82. node.setLeft(temp);
83. node.setRight(temp.getRight());
84. node.setDown(temp1);
85. temp.getRight().setLeft(node);
86. temp.setRight(node);
87. temp1.setUp(node);
88. temp1=node;
89. i=i+1;
90. }
91. size=size+1;
92. return  0;
93. }
94. //节点查找
95. public Node find(String k){
96. Node temp=head;
97. Node node;
98. node=temp;
99. System.out.println("查找路线"); //用于测试
100. while(temp!=null){
101. while(node.getRight().key!=Node.wei&&node.getRight().getKey().compareTo(k)<=0){//&&node.getRight().getValue()!=v
102. node=node.getRight();
103. System.out.print("--->"+node.getKey());
104. }
105. if(node.getDown()!=null){
106. node=node.getDown();
107. System.out.print("--->"+node.getKey());
108. }else{
109. if(node.key.equals(k)){//&&node.getRight().value==v
110. //node.setValue(111111111); //修改
111. System.out.println("--->"+node.getKey());
112. System.out.print("--->"+node.getValue());
113. return node;
114. }
115. return null;
116. }
117. }
118. return null;
119. }
120. //节点删除
121. public void delNode(String k){  //调用查找函数，删除最底层的某个节点，并把其节点的左右相连，和链表操作一样，只是其上方若有则都需要调整
122. Node temp=find(k);
123. while(temp!=null){
124. temp.getLeft().setRight(temp.getRight());
125. temp.getRight().setLeft(temp.getLeft());
126. temp=temp.getUp();
127. }
128. }
129. public void print(){
130. Node node;
131. Node node1=head;
132. while(node1!=null){
133. int k=0;
134. node=node1;
135. while(node!=null){
136. System.out.print(node.getKey()+"\t");
137. k++;
138. node=node.getRight();
139. }
140. System.out.print("\t");
141. System.out.print("("+k+")");
142. //System.out.print(node.getKey());
143. System.out.println();
144. //node=node1.getDown();
145. node1=node1.getDown();
146. }
147. }
148. }
149. class Node{
150. public String key;
151. public int value;
152. public Node up, down,left , right;
153. public static String tou=new String("--头--");
154. public static String wei=new String("--尾--");
155. public Node(String k, int v){
156. this.key=k;
157. this.value=v;
158. up=down=left=right=null;
159. }
160. public void setUp(Node up){
161. this.up=up;
162. }
163. public Node getUp(){
164. return up;
165. }
166. public void setDown(Node down){
167. this.down=down;
168. }
169. public Node getDown(){
170. return down;
171. }
172. public void setLeft(Node left){
173. this.left=left;
174. }
175. public Node getLeft(){
176. return left;
177. }
178. public void setRight(Node right){
179. this.right=right;
180. }
181. public Node getRight(){
182. return right;
183. }
184. public void setKey(String k){
185. this.key=k;
186. }
187. public String getKey(){
188. return key;
189. }
190. public void setValue(int v){
191. this.value=v;
192. }
193. public int getValue(){
194. return value;
195. }
196. }
197. package 跳跃表;
198. public class Test {
199. public static void main(String[] args){
200. SkipList s = new SkipList();
201. //      s.add("AAA", 122);
202. int i=0;
203. for(;i<30;i++){  //随机数字进行测试
204. s.add(String.valueOf(i), i);
205. }
206. s.print();
207. System.out.println("\n\n----------\n\n\n");
208. if(s.find("22")!=null){ //查找
209. System.out.println("\nOK");
210. }else{//找不到
211. System.out.println("\nfalse");
212. }
213. s.delNode("0"); //删除
214. s.print();
215. }
216. }