//从链表中移除元素:实现两种remove方法：第一种是从特定位置移除一个元素，第二种是根据元素的值移除元素
this.removeAt = function(position){
//检查越界值
if (position > -1 && position < length){ // {1}
var current=head, // {2}
previous, // {3}
index=0; // {4}
//移除第一项
if(position===0){ // {5}
head=current.next;
} else {
while (index++ < position){ // {6}
previous=current; // {7}
current=current.next; // {8}
}
//将previous与current的下一项链接起来：跳过current，从而移除它
previous.next=current.next; // {9}
}
length--; // {10}
return current.element;
} else {
return null; // {11}
}
};
该方法要得到需要移除的元素的位置，就需要验证这个位置是有效
的（行{1}）。从0（包括0）到列表的长度（size – 1，因为索引是从零开始的）都是有效的位
置。如果不是有效的位置，就返回null（意即没有从列表中移除元素）。
移除第一个元素
因此，如果想移除第一个元素，要做的就是让head指向列表的第二个元素。我们将用
current变量创建一个对列表中第一个元素的引用（行{2}——我们还会用它来迭代列表，但稍
等一下再说）。这样 current变量就是对列表中第一个元素的引用。如果把 head赋为
current.next，就会移除第一个元素。
现在，假设我们要移除列表的最后一项或者中间某一项。为此，需要依靠一个细节来迭代列
表，直到到达目标位置（行{6}——我们会使用一个用于内部控制和递增的index变量）：current
变量总是为对所循环列表的当前元素的引用（行{8}）。我们还需要一个对当前元素的前一个元
素的引用（行{7}）；它被命名为previous（行{3}）
因此，要从列表中移除当前元素，要做的就是将previous.next和current.next链接起
来（行{9}）。这样，当前元素就会被丢弃在计算机内存中，等着被垃圾回收器清除。
对于最后一个元素，当我们在行{6}跳出循环时， current变量将是对列表中最后一个元素
的引用（要移除的元素）。 current.next的值将是null（因为它是最后一个元素）。由于还保留
了对previous元素的引用（当前元素的前一个元素）， previous.next就指向了current。那
么要移除current，要做的就是把previous.next的值改变为current.next
//在任意位置插入一个元素
this.insert = function(position, element){
//检查越界值
if (position >= 0 && position <= length){ //{1}
var node = new Node(element),
current = head,
previous,
index = 0;
if (position === 0){ //在第一个位置添加
node.next = current; //{2}
head = node;
} else {
while (index++ < position){ //{3}
previous = current;
current = current.next;
}
node.next = current; //{4}
previous.next = node; //{5}
}
length++; //更新列表的长度
return true;
} else {
return false; //{6}
}
};
//把LinkedList对象转换成一个字符串
this.toString = function (){
var current = head, //{1}
string = ''; //{2}
while (current) { //{3}
string = current.element; //{4}
current = current.next; //{5}
}
return string; //{6}
}
首先，要循环访问列表中的所有元素，就需要有一个起点，也就是head。我们会把current
变量当作索引（行{1}），控制循环访问列表。我们还需要初始化用于拼接元素值的变量（行{2}）。
接下来就是循环访问列表中的每个元素（行{3}）。我们要用current来检查元素是否存在
（如果列表为空，或是到达列表中最后一个元素的下一位（null）， while循环中的代码就不会执
行）。然后我们就得到了元素的内容，将其拼接到字符串中（行{4}）。最后，继续迭代下一个元
素（行{5}）。最后，返回列表内容的字符串（行{6}）。
//indexOf方法接收一个元素的值，如果在列表中找到它，就返回元素的位置，否则返回-1。
this.indexOf = function(element){
var current = head, //{1}
index = -1;
while (current) { //{2}
if (element === current.element) {
return index; //{3}
}
index++; //{4}
current = current.next; //{5}
}
return -1;
};
我们需要一个变量来帮助我们循环访问列表，这个变量是current，它的初始值
是head（列表的第一个元素——我们还需要一个index变量来计算位置数（行{1}））。然后循环
访问元素（行{2}），检查当前元素是否是我们要找的。如果是，就返回它的位置（行{3}）；如
果不是，就继续计数（行{4}），检查列表中下一个节点（行{5}）。
如果列表为空，或是到达列表的尾部（current = current.next将是null），循环就不
会执行。如果没有找到值，就返回-1
实现了这个方法，我们就可以实现remove等其他的方法
// remove
this.remove = function (element){
var index = this.indexOf(element);
return this.removeAt(index);
}
// isEmpty
this.isEmpty = function (){
return length=0;
}
//size
this.size = function(){
return length;
}
// getHead
this.getHead = function(){
return head;
}
}
// 后面的 通过 var newLinkedList = new LinkedList（ ） 来进行使用
双向链表提供了两种迭代列表的方法：从头到尾，或者反过来。我们也可以访问一个特定节
点的下一个或前一个元素。在单向链表中，如果迭代列表时错过了要找的元素，就需要回到列表
起点，重新开始迭代。这是双向链表的一个优点
//从任意位置移除元素
this.removeAt = function(position){
//检查越界值
if (position > -1 && position < length){
var current=head,
previous,
index = 0;
//移除第一项
if (position === 0){
head = current.next; // {1}
//如果只有一项，更新tail //新增的
if (length === 1){ // {2}
tail = null;
} else {
head.prev = null; // {3}
}
} else if (position === length-1){ //最后一项 //新增的
current = tail; // {4}
tail = current.prev;
tail.next = null;
} else {
while (index++ < position){ // {5}
previous = current;
current = current.next;
}
//将previous与current的下一项链接起来——跳过current
previous.next = current.next; // {6}
current.next.prev = previous; //新增的
}
length--;
return current.element;
} else {
return null;
}
};
}
