JavaScript数据结构与算法(七) 双向链表的实现

TypeScript方式实现源码

// 双向链表和普通链表的区别在于， 在链表中，
// 一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的：一个链向下一个元素，
// 另一个链向前一个元素，如下图所示：
// 
// Node类里有prev属性（一个新指针） ，在DoublyLinkedList类里也有用来保存对列表最后一
// 项的引用的tail属性。 

// 双向链表提供了两种迭代列表的方法：从头到尾，或者反过来。我们也可以访问一个特定节
// 点的下一个或前一个元素。在单向链表中，如果迭代列表时错过了要找的元素，就需要回到列表
// 起点，重新开始迭代。这是双向链表的一个优点。
// 代码角度
// 　　每个节点设置两个指针,关联相邻的前后节点.提供逆向遍历,链表篇提到,链表是针对大量删除与添加场景下使用的.因此双向链表是针对普通链表的功能为基础,强化了遍历的功能
// 抽象
// 　　想了很久找不到现实中的场景,还是拿火车来理解吧.早期火车就像普通链表,具有重组车厢的功能.而随着科技的进步,双向列车出来了,优势便是不用再每次脱离车头,开到转盘进行掉头
//　　 然后再行驶.双向链表便是双向列车,它弱化了车头的概念,前后皆可是车头.
// 总结
//　　 单向链表优势在于可执行大量删除、增加操作并不用像数组那样需要重新排序.劣势则是每次便利必须从头开始,无端增加许多系统开销.假如有这种场景,知道某个节点,我需要找到
//　　 该节点的爷爷,再找他爷爷的儿子,再找他儿子的孙子.我们大脑瞬间可以计算出,这不就是要找当前节点的儿子吗？的确！我们就是要程序能够这样做,但是单向链表就是一根筋,不具备
//　　 这样的智商,这时双向链表优势则非常明显

 class Node {
     element;
     next;
     prev; // 新增的
     constructor(element) {
         this.element = element;
         this.next = null;
         this.prev = null;
     }
 }

 /**
  * 双向链表
  * @name DoublyLinkedList
  */
 class DoublyLinkedList {
     private length = ;
     head = null;
     tail = null; // 新增的

     /**
      * 向列表尾部添加一个新的项
      * @param element
      */
     public append(element) {
         let node = new Node(element), current;

         if (this.head === null) {
             this.head = node;
         } else {
             current = this.head;

             // 循环列表，知道找到最后一项
             while (current.next) {
                 current = current.next;
             }

             // 找到最后一项，将其next赋为node，建立链接
             current.next = node;
         }
         this.length++; // 更新列表长度
     }
     /**
      * 向列表的特定位置插入一个新的项
      * @param position
      * @param element
      */
     public insert(position, element) {
         // 检查越界值
         if (position >=  && position <= this.length) {
             let node = new Node(element),
                 current = this.head,
                 previous,
                 index = ;

             if (position === ) { // 在第一个位置添加
                 if (!this.head) { // 新增的
                     this.head = node;
                     this.tail = node;
                 } else {
                     node.next = current;
                     current.prev = node; // 新增的
                     this.head = node;
                 }
             } else if (position === this.length) { // 最后一项 新增的
                 current = this.tail;
                 current.next = node;
                 node.prev = current;
                 this.tail = node;
             } else {
                 while (index++ < position) {
                     previous = current;
                     current = current.next;
                 }
                 node.next = current;
                 previous.next = node;

                 current.prev = node; // 新增的
                 node.prev = previous; // 新增的
             }
             this.length++; // 更新列表长度
             return true;
         } else {
             return false;
         }
     }
     /**
      * 从列表的特定位置移除一项
      * @param position
      */
     public removeAt(position) {
         // 检查越界值
         if (position > - && position < this.length) {
             let current = this.head,
                 previous,
                 index = ;

             // 移除第一项
             if (position === ) {
                 this.head = current.next;

                 // 如果只有一项，更新tail // 新增的
                 if (this.length === ) {
                     this.tail = null;
                 } else {
                     this.head.prev = null;
                 }
             }
             else if (position === this.length - ) { // 新增的
                 current = this.tail;
                 this.tail = current.prev;
                 this.tail.next = null;
             }
             else {
                 while (index++ < position) {
                     previous = current;
                     current = current.next;
                 }
                 // 将previous与current的下一项链接起来：跳过current，从而移除它
                 previous.next = current.next;
                 current.next.prev = previous; // 新增的
             }
             this.length--;
             return current.element;
         } else {
             return null;
         }
     }
     /**
      * 从列表中移除一项
      * @param element
      */
     public remove(element) {
         let index = this.indexOf(element);
         return this.removeAt(index);
     }
     /**
      * ：返回元素在列表中的索引。如果列表中没有该元素则返回-1
      * @param element
      */
     public indexOf(element) {
         let current = this.head,
             index = -;

         while (current) {
             if (element === current.element) {
                 return index;
             }
             index++;
             current = current.next;
         }
         return -;
     }
     /**
      * 如果链表中不包含任何元素， 返回true， 如果链表长度大于0则返回false
      */
     public isEmpty() {
         return this.length === ;
     }
     /**
      * 返回链表包含的元素个数。与数组的length属性类似
      */
     public size() {
         return this.length;
     }
     /**
      * 由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值
      */
     public toString() {
         let current = this.head,
             string = '';

         while (current) {
             string += current.element;
             current = current.next;
         }
         return string;
     }
     public getHead() {
         return this.head;
     }
     public print() {
         console.log(this.toString());
     }
 }

 

JavaScript 方式实现源码

 var Node = (function () {
     function Node(element) {
         this.element = element;
         this.next = null;
         this.prev = null;
     }
     return Node;
 }());
 /**
  * 双向链表
  * @name DoublyLinkedList
  */
 var DoublyLinkedList = (function () {
     function DoublyLinkedList() {
         this.length = ;
         this.head = null;
         this.tail = null; // 新增的
     }
     /**
      * 向列表尾部添加一个新的项
      * @param element
      */
     DoublyLinkedList.prototype.append = function (element) {
         var node = new Node(element), current;
         if (this.head === null) {
             this.head = node;
         }
         else {
             current = this.head;
             // 循环列表，知道找到最后一项
             while (current.next) {
                 current = current.next;
             }
             // 找到最后一项，将其next赋为node，建立链接
             current.next = node;
         }
         this.length++; // 更新列表长度
     };
     /**
      * 向列表的特定位置插入一个新的项
      * @param position
      * @param element
      */
     DoublyLinkedList.prototype.insert = function (position, element) {
         // 检查越界值
         if (position >=  && position <= this.length) {
             var node = new Node(element), current = this.head, previous = void , index = ;
             if (position === ) {
                 if (!this.head) {
                     this.head = node;
                     this.tail = node;
                 }
                 else {
                     node.next = current;
                     current.prev = node; // 新增的
                     this.head = node;
                 }
             }
             else if (position === this.length) {
                 current = this.tail;
                 current.next = node;
                 node.prev = current;
                 this.tail = node;
             }
             else {
                 while (index++ < position) {
                     previous = current;
                     current = current.next;
                 }
                 node.next = current;
                 previous.next = node;
                 current.prev = node; // 新增的
                 node.prev = previous; // 新增的
             }
             this.length++; // 更新列表长度
             return true;
         }
         else {
             return false;
         }
     };
     /**
      * 从列表的特定位置移除一项
      * @param position
      */
     DoublyLinkedList.prototype.removeAt = function (position) {
         // 检查越界值
         if (position > - && position < this.length) {
             var current = this.head, previous = void , index = ;
             // 移除第一项
             if (position === ) {
                 this.head = current.next;
                 // 如果只有一项，更新tail // 新增的
                 if (this.length === ) {
                     this.tail = null;
                 }
                 else {
                     this.head.prev = null;
                 }
             }
             else if (position === this.length - ) {
                 current = this.tail;
                 this.tail = current.prev;
                 this.tail.next = null;
             }
             else {
                 while (index++ < position) {
                     previous = current;
                     current = current.next;
                 }
                 // 将previous与current的下一项链接起来：跳过current，从而移除它
                 previous.next = current.next;
                 current.next.prev = previous; // 新增的
             }
             this.length--;
             return current.element;
         }
         else {
             return null;
         }
     };
     /**
      * 从列表中移除一项
      * @param element
      */
     DoublyLinkedList.prototype.remove = function (element) {
         var index = this.indexOf(element);
         return this.removeAt(index);
     };
     /**
      * ：返回元素在列表中的索引。如果列表中没有该元素则返回-1
      * @param element
      */
     DoublyLinkedList.prototype.indexOf = function (element) {
         var current = this.head, index = -;
         while (current) {
             if (element === current.element) {
                 return index;
             }
             index++;
             current = current.next;
         }
         return -;
     };
     /**
      * 如果链表中不包含任何元素， 返回true， 如果链表长度大于0则返回false
      */
     DoublyLinkedList.prototype.isEmpty = function () {
         return this.length === ;
     };
     /**
      * 返回链表包含的元素个数。与数组的length属性类似
      */
     DoublyLinkedList.prototype.size = function () {
         return this.length;
     };
     /**
      * 由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值
      */
     DoublyLinkedList.prototype.toString = function () {
         var current = this.head, string = '';
         while (current) {
             string += current.element;
             current = current.next;
         }
         return string;
     };
     DoublyLinkedList.prototype.getHead = function () {
         return this.head;
     };
     DoublyLinkedList.prototype.print = function () {
         console.log(this.toString());
     };
     return DoublyLinkedList;
 }());