javascript实现数据结构与算法系列：功能完整的线性链表

由于链表在空间的合理利用上和插入，删除时不需要移动等的有点，因此在很多场合下，它是线性表的首选存储结构。然而，它也存在着实现某些基本操作，如求线性表长度时不如顺序存储结构的缺点；另一方面，由于在链表中，结点之间的关系使用指针来表示，则数据元素在线性表中的“位序”的概念已淡化，而被数据元素在线性链表中的“位置”所代替。为此，从实际出发重新定义线性链表及其基本操作

结构图：

 (function(module){
   function List() {
     this.head = null;
     this.tail = null;
   }
   module.exports = List;

   List.mergeList = function (a, b, compare) {
     var ha = a.head;
     var hb = b.head;
     var pa = ha;
     var pb = hb;
     var c = new List();
     var q;
     compare = compare || function (data1, data2) {
       return data1 <= data2;
     };

     while (pa && pb) {
       var data1 = pa.data;
       var data2 = pb.data;

       if (!compare(data1, data2)) {
         // delete head node
         q = a.delFirst();
         // append the node to c linkedList
         c.append(q);
         pa = a.head;
       } else {
         q = b.delFirst();
         c.append(q);
         pb = b.head;
       }
     }

     if (pa) {
       c.append(pa);
     } else {
       c.append(pb);
     }

     return c;
   };

   List.prototype = {
     makeNode: function(data, next){
       return {
         data: data != null ?  data : null,
         next: next || null
       };
     },
     delFirst: function () {
       var head = this.head;
       this.head = this.head.next;
       head.next = null;

       if(this.head === null) this.tail = null;
       return head;
     },
     append: function (node) {
       if (this.head !== null) {
         this.tail.next = node;
         this.tail = this.tail.next;
       } else {
         this.head = node;
         this.tail = node;
       }
     },
     add: function (data) {
       if (this.head === null) {
         this.head = this.makeNode(data);
         this.tail = this.head;
       } else {
         this.tail.next = this.makeNode(data);
         this.tail = this.tail.next;
       }

       this.tail.data = data;
     },
     'delete': function (data) {
       var current = this.head;
       var previous = this.head;
       var elem;

       while (current !== null) {
         if (data === current.data) {
           if (current === this.head) {
             this.head = current.next;
             elem =  current.data;
             break;
           }

           if (current === this.tail) this.tail = previous;

           previous.next = current.next;
           elem =  current.data;
           break;
         }

         previous = current;
         current = current.next;
       }

       if(this.head === null) this.tail = null;

       return elem ? elem : false;
     },
     insertAsFirst: function (data) {
       var temp = this.makeNode(data);
       temp.next = this.head;
       this.head = temp;
     },
     insertAfter: function (target, data) {
       var current = this.head;
       while (current !== null) {
         if (current.data === target) {
           var temp = this.makeNode(data);
           temp.next = current.next;

           if (current === this.tail) this.tail = temp;

           current.next = temp;
           return;
         }

         current = current.next;
       }
     },
     item: function (index) {
       var current = this.head;

       while (current !== null) {
         if (--index === 0) return current;

         current = current.next;
       }

       return null;
     },
     each: function (callback) {
       var current = this.head;

       while (current !== null) {
         callback(current);
         current = current.next;
       }
     },
     orderInsert: function(data, cmp){
       cmp = typeof cmp === 'function' ? cmp : function (a, b){
         if(a > b)
           return 1;
         else if(a === b)
           return 0;
         else
           return -1;
       };
       var previous = this.head;
       var current = this.head;

       if(current === null){
         this.head = this.tail = this.makeNode(data);
         return;
       }

       var me = this;
       while(current){
         var ret = cmp(data, current.data);
         // 如果插入元素大于当前元素，准备下次遍历
         if(ret > 0){
           previous = current;
           current = current.next;

           // 如果等于，直接插入到后面
         } else if(ret === 0){
           return insertBetween(data, previous, current);

           // 如果小于则插入到前节点和当前节点中
           // 因为已经是排序了，所以不需要多余判断了
         } else {
           if(this.head === previous && previous === current){
             return this.insertAsFirst(data);
           } else {
             return insertBetween(data, previous, current);
           }
         }
       }

       // 插入到最后一个结点
       previous.next = this.makeNode(data);
       this.tail = previous.next;

       function insertBetween(data, a, b){
         var temp = me.makeNode(data);
         temp.next = b;
         a.next = temp;
         return true;
       }
     }
   };
   /*
   var list = new List();
   list.add('b');
   list.insertAsFirst('a');
   list.insertAfter('b', 'c');
   console.log(list.item(2));
   console.log(JSON.stringify(list));
   list.each(function (node) {
     if (node.data === 'b') {
       console.log('get b in each');
     }
   });
   list['delete']('c');
   list['delete']('a');
   console.log(list);

   var list2 = new List();
   list2.add('c');
   list2.insertAsFirst('d');
   list2.insertAfter('d', 'b');
   console.log(JSON.stringify(list2));

   var list3 = List.mergeList(list, list2);
   console.log(list3);
   */
   /*
   var list = new List();

   list.orderInsert('e');
   list.orderInsert('b');
   list.orderInsert('c');
   list.orderInsert('a');
   list.orderInsert('d');
   list.orderInsert('f');
   */
 }(this.module || this));

以下是对应的单元测试代码：

 describe('linkedList tests', function(){

   var list = new List();

   it('should find the second item', function(){
     list.add('b');
     expect(list.head.data).toBe('b');
     expect(list.tail.next).toBe(null);

     list.insertAsFirst('a');
     expect(list.head.data).toBe('a');
     expect(list.head.next.data).toBe('b');

     list.insertAfter('b', 'c');
     expect(list.item(2).data).toBe('b');
     expect(list.tail.data).toBe('c');
   });

   it('should remove one item', function(){
     expect(list['delete']('c')).toBe(true);
     list['delete']('a');
     expect(list.head.data).toBe('b');
   });

   var list2 = new List();

   it('should match the json', function(){
     list2.add('c');
     list2.insertAsFirst('d');
     list2.insertAfter('d', 'b');
     expect(JSON.stringify(list2)).toBe('{"head":{"data":"d","next":{"data":"b","next":{"data":"c","next":null}}},"tail":{"data":"c","next":null}}');
   });

   it('should merge the lists', function(){
     var list3 = List.mergeList(list, list2);
     expect(list3.head.data).toBe('d');
     expect(list3.head.next.data).toBe('b');
     expect(list3.head.next.next.data).toBe('c');
     expect(list3.tail.data).toBe('b');
   });
 });