javascript实现链表

//链表和数组都是常用的数据结构,数组是在内存中开辟一段连续的空间（JS不是）。所以知道下标的话，数组找元素很快。但是可以想象，插入删除就很麻烦，后续的元素需要全部挪一挪。
//如果是需要频繁添加删除的数据，可以考虑使用链表。 链表插入和删除数据的时间复杂度都是O(1); 
//插入元素，把他的前一项的后驱指向新节点，新节点的后驱指向前一项原来的后驱即可。
//删除元素，把要删除的节点的前一项的后驱指向删除节点的后驱即可。 失去引用，垃圾回收机制自动回收。



class CreateNode {
    ele: string;
    next: any;
    constructor(ele: string) {
        this.ele = ele;
        this.next = null;
    }
}

class LinkList {
    head: any;
    constructor() {
        this.head = new CreateNode('head');
    }

    find(item: string) {
        let currentNode = this.head;

        if (currentNode == null) {
            return null;
        }
        if (currentNode.ele === item) {
            return currentNode;
        }
        while (currentNode.next) {
            currentNode = currentNode.next;
            if (currentNode.ele === item) {
                return currentNode;
            }
        }

        return null;
    }

    insert(newEle: string, item: string) {
        let newNode = new CreateNode(newEle);

        let currentNode = this.find(item);

        console.log(currentNode);
        newNode.next = currentNode.next;
        currentNode.next = newNode;
    }

    findprev(item: string) {
        let currentNode = this.head;

        while (currentNode.next) {
            if (currentNode.next.ele === item) {
                return currentNode;
            }
            currentNode = currentNode.next;
        }

        return currentNode;
    }

    remove(item: string) {
        let currentNode = this.find(item);

        let prev = this.findprev(currentNode.ele);

        if (prev.next) {
            prev.next = prev.next.next;
        }
    }

    show() {
        let currentNode = this.head;

        while (currentNode.next !== null) {
            console.log(currentNode.next.ele);
            currentNode = currentNode.next;
        }

        console.log('--------------------------分割------------------------------------');
    }
}

let link = new LinkList();

link.insert('two', 'head');
link.insert('san', 'two');
link.insert('sss', 'san');
link.insert('aaa', 'sss');

link.show();

link.remove('san');

link.show();

link.insert('dsdsdsd', 'aaa');

link.show();

 

双向链表就是多了一个前驱，插入时给新结点加前驱。删除时后节点的前驱指向前节点就行了。 

        insert(newEle,item){
            
            let newNode = new Node(newEle);
            
            let currentNode = this.find(item);
            
            let nextNode = currentNode.next;
            
            newNode.next = nextNode;
            newNode.prev = currentNode;
            currentNode.next = newNode;
            nextNode&&(nextNode.prev = newNode);

        }
        
        remove(item){
            
            let currentNode = this.find(item);
            
            let prev = this.findprev(currentNode.ele)
           let nextNode = prev.next.next;
            
            if(prev.next){
                prev.next = nextNode;
                nextNode.prev = prev;
            }
            
        }
        

 

思考，前面讲插入删除时间复杂度是O(1),但是中间明明有find方法和findprev方法，这不是O1.我作为初学者也是一知半解。

目前想到的办法时，操作数据时直接获取节点，而不是拿到节点的ele再去找节点。这就是O1了。