swift算法手记-10

发布时间：2020-12-14 07:18:20 所属栏目：百科来源：网络整理

导读：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 = mynod

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值，就可以在查找代价和存储代价之间作出权衡。

这里元素不多，体现不出优势，如果元素足够多，这种索引结构就能体现出优势来了。

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!