随心情更新的学习笔记——JS代码之链表底层算法实现2

最新推荐文章于 2025-05-26 17:16:53 发布

原创最新推荐文章于 2025-05-26 17:16:53 发布 · 158 阅读

0 ·

CC 4.0 BY-SA版权

这是有上期，没下期，学习看心情，更新看随机的老王的学习笔记，好好看，没有下期了……

上一期说了部分的链表方法的底层算法实现，这期来说说将节点向前/后移动n个节点的方法。

鉴于老师还没有评讲，我是用我自己的方法实现的，可能会相当冗余、繁杂，等明天评讲过后，会放上老师的代码。

        //使当前节点向前移动n 个节点
        this.advance=function(currElement,n){
            //将原来的节点保存一份
            let oldNode = this.find(currElement);
            //将要移动的原来的节点
            let newNode = this.find(currElement);
            //将要移动的那个位置的前一个节点
            let newNodePre;
            //将要移动的那个位置的后一个节点
            let newNodeAft;
            //原节点的前一个节点
            let oldNodeBef;
            for (var i=0;i<= n;i++){
                newNode = this.findPrevious(newNode.element);
            }
            newNodePre = newNode;
            newNodeAft = newNodePre.next;
            oldNodeBef = this.findPrevious(currElement);
            oldNodeBef.next = oldNode.next;
            newNodePre.next = oldNode;
            oldNode.next = newNodeAft;
        }


        //使当前节点向后移动n 个节点
        this.back=function(currElement,n){
            //将原来的节点保存一份
            let oldNode = this.find(currElement);
            //将要移动的原来的节点
            let newNode = this.find(currElement);
            //将要移动的那个位置的前一个节点
            let newNodePre;
            //将要移动的那个位置的后一个节点
            let newNodeAft;
            //原节点的前一个节点
            let oldNodeBef;
            for (var i=0;i<= n;i++){
                newNode = newNode.next;
            }
            newNodePre = newNode;
            newNodeAft = newNodePre.next;
            oldNodeBef = this.findPrevious(currElement);
            oldNodeBef.next = oldNode.next;
            newNodePre.next = oldNode;
            oldNode.next = newNodeAft;
        }

光看这个代码很可能会被我定义的多个变量搞晕，主要是我自己的思路也不是很清楚，但是看图的话可能会好理解一点：

首先我们先找到这个currElement，保存为newNode，因为这个节点一定要变动，我们另存为一个oldNode

循环，要向前/后移动多少位，就循环多少次

以前移为例，每次循环就把当前节点的前驱赋值给当前节点，如图所示：

然后将1和3连接起来，1的后驱为3

将移动后的位置的地后驱和节点相连就完成了

****************************************************放上老师的代码***********************************************************

        //使当前节点向前移动n 个节点
        this.advance=function(currElement,n){

            var currentNode = this.find(currElement);
            var buffer = this.findPrevious(currElement);
            var preNode = buffer;
            while (preNode.element!='head'&&n>0){
                preNode = this.findPrevious(preNode.element);
                n--;
            }

            buffer.next = currentNode.next;
            currentNode.next = preNode.next;
            preNode.next = currentNode;
        }


        //使当前节点向后移动n 个节点
        this.back=function(currElement,n){
            //获得当前的节点
            var currentNode = this.find(currElement);
            //假设当前的节点是最后的节点
            var LastNode = currentNode;
            //在n大于0的情况下，下一个节点为空的时候停下来
            while (LastNode.next!=null&&n>0){
                LastNode = LastNode.next;
                n--;
            }
            //currentNode节点和nextNode相等，说明currentNode本身就是最后一个节点
            if(currentNode==LastNode){
                return;
            }
            //当前节点的前一个节点和当前节点的后一个节点连接在一起
            var currentPre = this.findPrevious(currElement);

            currentPre.next= currentNode.next;
            //把当前节点连接在LastNode节点后面
            currentNode.next = LastNode.next;
            LastNode.next = currentNode;
        }

########################################放上全部代码#########################################

function Node(element) {
        this.element = element;
        this.next = null;
    }

    function LList() {
        this.head = new Node("head");
        this.insert=function (data) {
            //this.head.next = new Node(data);
            //创建新的节点
            var buffer = new Node(data);
            //获得最后的节点
            var last = this.findLast();
            //把最后节点的next指向新节点
            last.next = buffer;
        }
        //找到最后节点
        this.findLast=function () {
            var buffer = this.head;
            while(buffer.next!=null){
                buffer = buffer.next;
            }
            return buffer;
        }
        //遍历
        this.forEach=function (call) {
            var buffer = this.head;
            while(buffer!=null){
                call(buffer);
                buffer = buffer.next;
            }
        }
        //找到某个节点
        this.find=function (data) {
            var buffer = this.head;
            while(buffer!=null){
                if(buffer.element==data){
                    return buffer;
                }
                buffer = buffer.next;
            }
            return buffer;
        }
        //找到某个节点的前一个节点
        this.findPrevious=function (data) {
            var buffer = this.head;
            var node=null;
            while(buffer!=null&&buffer.next!=null){
                if(buffer.next.element==data){
                    node = buffer
                    return node;
                }
                buffer = buffer.next;
            }
            return node;
        }
        //删除节点
        this.remove=function (data) {
            let nextNode = this.find(data).next;
            let preNode = this.findPrevious(data);

            preNode.next = nextNode;
        }
        //在某个节点之后插入节点
        this.insertAfter=function (element,after) {
            //创建当前的节点
            let node = new Node(element);
            //获得after节点
            let afterNode = this.find(after);
            //afterNode的后面节点和当前节点
            node.next = afterNode.next;
            afterNode.next = node;
        }
        //在某个节点之前插入节点
        this.insertBefore=function (element,before) {
            //创建当前的节点
            let node = new Node(element);
            //获得before节点的前一个节点
            let preNode = this.findPrevious(before);
            //把before节点连到新节点的后面
            node.next = preNode.next;
            //把preNode节点和新节点连在一起
            preNode.next = node;
        }
        //使当前节点向前移动n 个节点
        this.advance=function(currElement,n){

            var currentNode = this.find(currElement);
            var buffer = this.findPrevious(currElement);
            var preNode = buffer;
            while (preNode.element!='head'&&n>0){
                preNode = this.findPrevious(preNode.element);
                n--;
            }

            buffer.next = currentNode.next;
            currentNode.next = preNode.next;
            preNode.next = currentNode;
        }
        //使当前节点向后移动n 个节点
        this.back=function(currElement,n){
            //获得当前的节点
            var currentNode = this.find(currElement);
            //假设当前的节点是最后的节点
            var LastNode = currentNode;
            //在n大于0的情况下，下一个节点为空的时候停下来
            while (LastNode.next!=null&&n>0){
                LastNode = LastNode.next;
                n--;
            }
            //currentNode节点和nextNode相等，说明currentNode本身就是最后一个节点
            if(currentNode==LastNode){
                return;
            }
            //当前节点的前一个节点和当前节点的后一个节点连接在一起
            var currentPre = this.findPrevious(currElement);

            currentPre.next= currentNode.next;
            //把当前节点连接在LastNode节点后面
            currentNode.next = LastNode.next;
            LastNode.next = currentNode;
        }

    }


    let lList = new LList();
    lList.insert("你");
    lList.insert("有");
    lList.insert("病");
    lList.insert("啊");
    lList.insert("1");
    lList.insert("2");
    lList.insert("3");
    lList.insert("4");
    lList.insert("5");


    //lList.remove("病");
    //lList.insertBefore("aaa","有");
    //console.log(lList.remove("病"));

    //lList.advance("4",2);
    lList.back("2",2);

    lList.forEach(function (node) {
        console.log(node.element);
    })