http://blog.csdn.net/myhaspl
private func findnode(val:Int)->Bool{//http://blog.csdn.net/myhaspl
//查找结点http://blog.csdn.net/myhaspl
if let mysltop = slinktop{
var mynode:skipLinkNode=mysltop
while true{
while true{
if let nextnd = mynode.nextnode {
let nodeval = nextnd.ndval
if nodeval < val{
mynode=nextnd
continue
}
if nodeval == val{
return true
}
}
break
}
if mynode.downnode == nil{
return false
}
else{
mynode = mynode.downnode!
}
}
}
else{
return false
}
}
....
....
....
private func deletenode(val:Int){
if let mysltop=slinktop{
var mynode:skipLinkNode=mysltop
while true{
while true{
if let nextnd = mynode.nextnode {
let nodeval = nextnd.ndval
if nodeval < val{
mynode=nextnd
continue
}
if nodeval == val{
//delete node from the level
mynode.nextnode=nextnd.nextnode
}
}
break
}
if mynode.downnode == nil{
//最底层http://blog.csdn.net/myhaspl
break
}
else{
mynode = mynode.downnode!
}
}
}
}
private func insertnode(val:Int){
//插入结点
let insertlv=getinsertlv()
let currtop=currlist(insertlv)
var mynode:skipLinkNode = currtop
var isfind:Bool=false
var searchnodes=[(skipLinkNode,skipLinkNode)]()
while true{
while let ntnode=mynode.nextnode{
if ntnode.ndval < val {
mynode = ntnode
}
else if ntnode.ndval == val {
isfind=true
searchnodes.append((ntnode,ntnode.nextnode!))
break
}
else{
searchnodes.append((mynode,ntnode))
break
}
}
if let dnnode=mynode.downnode {
mynode=dnnode
}
else{
break
}
}
var newnd:skipLinkNode?
var upnd:skipLinkNode?
var dnnd:skipLinkNode?
var prend:skipLinkNode
var ntnd:skipLinkNode
if !isfind {
for nodes in searchnodes{
(prend,ntnd)=nodes
upnd=newnd
newnd=createnode(prend,nextnd:ntnd,nodetype: ntype.node,val:val)
if upnd != nil{
upnd!.downnode=newnd
}
else{
dnnd = newnd!
}
}
if insertlv>slinklevel
{
addnewlevel(val,dnnode: dnnd!)
}
}
else{
let nodelist=searchnodes.last
(prend,ntnd)=nodelist!
newnd=createnode(prend,val:val)
}
}
private func slinkstatus()->String{
var mystatus:String=""
var nownode:skipLinkNode
var i=slinklevel
while i>=0{
nownode=slist[i]
mystatus+="||top=>"
while true{
if let ntnode=nownode.nextnode {
if ntnode.ndtype != ntype.end {
mystatus+=String(ntnode.ndval)+"--"
}
else{
mystatus+="==>end||"
}
nownode=ntnode
}
else{
break
}
}
mystatus += "\n"
i-=1
}
return mystatus
}
本博客所有内容是原创，如果转载请注明来源
http://blog.csdn.net/myhaspl/
跳跃链表是一种随机化数据结构，基于并联的链表，其效率可比拟于二叉查找树(对于大多数操作需要O(logn)平均时间)，并且对并发算法友好。
跳跃列表是按层建造的。底层是一个普通的有序链表。每个更高层都充当下面列表的"快速跑道"，这里在层
i中的元素按某个固定的概率
p出现在层
i+1 中。平均起来，每个元素都在 1/(1-
p) 个列表中出现，而最高层的元素(通常是在跳跃列表前端的一个特殊的头元素)在 O(log1/
pn) 个列表中出现。
1 - - - - - - 4 - - - 6
1 - - - 3 - 4 - - - 6 - - - - - - 9
1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10
要查找一个目标元素，起步于头元素和顶层列表，并沿着每个链表搜索，直到到达小于或的等于目标的最后一个元素。通过跟踪起自目标直到到达在更高列表中出现的元素的反向查找路径，在每个链表中预期的步数显而易见是 1/
p。所以查找的总体代价是 O(log1/
pn / p)，当
p是常数时是 O(log
n)。通过选择不同
p值，就可以在查找代价和存储代价之间作出权衡。
这里元素不多，体现不出优势，如果元素足够多，这种索引结构就能体现出优势来了。
