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');
});
});