数据结构与算法之链表

Posted 2022-01-11 simpul

链表

JS中数组被实现成了对象，对比其他语言的数组效率很低。因此可以考虑使用链表来替代。除了对数据的随机访问，链表几乎可以用在任何使用以为数组的情况中。如果需要随机访问，数组仍然是更好的选择。

单向链表

链表是由一组节点组成的集合。 每个节点都使用一个对象的引用指向它的后继。 指向另一
个节点的引用叫做链。

遍历链表， 就是跟着链接， 从链表的首元素一直走到尾元素，下面最前面的节点叫做头节点，在最后面的尾元素指向一个null节点。

//  节点类
function Node(element)
    this.element = element;
    this.next = null;


//  LinkedList类，建立一个新的链表
function LList()
    this.head = new Node("head");

LList.prototype = 
    constructor: LList,
    find(element)
        var node = this.head;
        while(node.element != element)
            if(node.next)
                node = node.next;
            else
                return null;
            
        
        return node;
    ,
    insert(newElement, item)  //在item后面插入新元素
        var current = this.find(item);
        var newNode = new Node(newElement);
        newNode.next = current.next;
        current.next = newNode;
    ,
    remove(item)
        var preNode = this.findPrevious(item);
        if(preNode.next !== null)
            preNode.next = preNode.next.next;     
        
    ,
    display()  //不显示头节点
        var current = this.head;
        while(current.next !== null)
            console.log(current.next.element);
            current = current.next;
        
    ,
    findPrevious(item)  //用来查找该值节点的前一个节点
        var current = this.head;
        while(current.next.element !== item)
            if(current.next !== null)
                current = current.next;
            else
                return null;
            
        
        return current;
    

双向链表

//  节点类
function Node(element)
    this.element = element;
    this.next = null;
    this.previous = null;


//  LinkedList类，建立一个新的链表
function LList()
    this.head = new Node("head");

LList.prototype = 
    constructor: LList,
    find(element)
        var node = this.head;
        while(node.element != element)
            if(node.next)
                node = node.next;
            else
                return null;
            
        
        return node;
    ,
    insert(newElement, item)  //在item后面插入新元素
        var current = this.find(item);
        var newNode = new Node(newElement);
        newNode.next = current.next;
        newNode.previous = current;
        current.next = newNode;
    ,
    remove(item)  //双向链表删除节点效率更高了，因为不需要再查找前驱节点了
        var removeNode = this.find(item);
        if(removeNode)
            removeNode.previous.next = removeNode.next;
            removeNode.next.previous = removeNode.previous;
            removeNode.next = null;
            removeNode.previous = null;
        
    ,
    display()  //不显示头节点
        var current = this.head;
        while(current.next !== null)
            console.log(current.next.element);
            current = current.next;
        
    ,
    findLast()  //查找链表的最后一项
        var current = this.head;
        while(current.next !== null)
            current = current.next;
        
        return current;
    ,
    dispReverse()
        var current = this.findLast();
        while(current.previous !== null)
            console.log(current.element);
            current = current.previous;
        
    ,

循环链表

循环链表和单向链表相似， 节点类型都是一样的。 唯一的区别是， 在创建循环链表时， 让其头节点的 next 属性指向它本身，这样插入节点都会使得链表的尾节点都指向头节点，形成一个循环链表。

如果你希望可以从后向前遍历链表， 但是又不想付出额外代价来创建一个双向链表， 那么就需要使用循环链表。 从循环链表的尾节点向后移动， 就等于从后向前遍历链表。

避免无限循环，需要对方法进行修改：

//  节点类
function Node(element)
    this.element = element;
    this.next = null;


//  LinkedList类，建立一个新的链表
function LList()
    this.head = new Node("head");
    this.head.next = this.head;

LList.prototype = 
    constructor: LList,
    find(element)
        var node = this.head;
        while(node.element != element)
            if(node.next === this.head)
                return null;
            
            node = node.next;
        
        return node;
    ,
    insert(newElement, item)  //在item后面插入新元素
        var current = this.find(item);
        var newNode = new Node(newElement);
        newNode.next = current.next;
        current.next = newNode;
    ,
    remove(item)
        var preNode = this.findPrevious(item);
        preNode.next = preNode.next.next;     
    ,
    display()  //不显示头节点
        var current = this.head;
        while(current.next !== this.head)
            console.log(current.next.element);
            current = current.next;
        
    ,
    findPrevious(item)  //用来查找该值节点的前一个节点
        var current = this.head;
        while(current.next.element !== item)
            if(current.next === this.head)
                return null;
            
            current = current.next;
        
        return current;