双向链表
什么是双向链表？
既可以从头遍历到尾，又可以从尾遍历到头，一个节点机油向前链接的引用，也有向后链接的引用
双向链表的缺点：
每次在插入或者删除某个节点的时候，需要处理四个引用，而不是两个，相对于单向链表，占用较多的内存空间，但是在使用层度上这些是微不足道的。
双向链表的操作
<1> append(element)：向列表尾部添加一个新的项
<2> insert(position,element)：向列表的特定位置插入一个新的项
<3> get(position)：获取对应位置的元素
<4> indexOf(element)：返回元素在列表中的索引，如果列表中没有该元素则返回-1
<5> update(position,element)：修改某个位置的元素
<6> removeAt(position)：从列表的特定位置移除一项
<7> remove(element)：从列表中移除一项
<8> isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false
<9> size()：返回链表中包含的元素个数，与数组的length属性类似
<10> toString()：由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法。让其只输出元素的值
<11> forwardString()：返回正向遍历的节点字符串形式
<12> backwardString()：返回反向遍历的节点字符串的形式
双向链表方法的实现
1、toString、forwardString、backwardString方法实现
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null }//toString方法 DoublyLinkedList.prototype.toString = function () { return this.backwardString() } //forwardString DoublyLinkedList.prototype.forwardString = function () { //定义变量 var current = this.tail var result = '' //依次向前遍历获取节点 while(current){ result += current.data + ' ' current = current.prev } return result } //backwardString DoublyLinkedList.prototype.backwardString = function () { //定义变量 var current = this.head var result = '' //依次向后遍历获取节点 while(current){ result += current.data + ' ' current = current.next } return result } }
测试：
//测试 var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list.backwardString()) alert(list.forwardString())
2、append方法的实现
//append方法 DoublyLinkedList.prototype.append = function (data) { //创建节点 var newNode = new Node(data) //判断添加的节点是否是第一个节点 if(this.length == 0){ this.head = newNode this.tail = newNode } else { newNode.prev=this.tail this.tail.next=newNode this.tail=newNode } //length加一 this.length += 1 }
测试：
var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list)
3、insert方法的实现
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null } DoublyLinkedList.prototype.insert = function (position, data) { //越界判断 if (position < 0 || position > this.length) return false //创建新的节点 var newNode = new Node(data) //判断链表是否为空 if (this.length == 0) { this.head = newNode this.tail = newNode } else { //第一种情况，判断prev是否为空。也就是原来有一个节点现在需要插入到节点的这个位置 if (position == 0) { this.head.prev = newNode //原来的节点prev指向新节点 newNode.next = this.head //新节点的next指向原来的节点 this.head = newNode //head指向新节点 } else if (position == this.length) { //第二种情况 newNode.prev = this.tail this.tail.next = newNode this.tail = newNode } else { //第三种情况 var current = this.head var index = 0 while (index++ < position) { current = current.next } //修改指针 newNode.next = current newNode.prev = current.prev current.prev.next = newNode current.prev = newNode } } this.length += 1 return true } }
测试：
//测试 var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') list.insert(1,'aaa') list.insert(3,'bbb') list.insert(5,'ccc') alert(list)
4、get方法
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null } DoublyLinkedList.prototype.get = function (position) { //越界判断 if (position < 0 || position >= this.length) return null //定义变量 var index = 0 var current = this.head while (index++ < position) { current = current.next } return current.data } }
测试：
//测试 var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list.get(2))
这种方法查找的效率并不是很高，只能从前往后进行查找，如果此时链表的数据过多，那么就会使效率变低，所以进行判断，如果此时的链表长度除于2的结果大于position，就需要从后往前进行查找
所以此时需要这样写
DoublyLinkedList.prototype.get = function (position) { //越界判断 if (position < 0 || position >= this.length) return null if (this.length / 2 > position ) { //定义变量 var index = 0 var current = this.head while (index++ < position) { current = current.next } return current.data } else{ //定义变量 var index = this.length var current = this.tail while (index-- < position) { current = current.prev } return current.data } }
5、indexOf方法
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null } DoublyLinkedList.prototype.indexOf = function (data) { var current = this.head var index = 0 while (current) { if (current.data == data) { return index } current = current.next index++ } return -1 } }
测试：
//测试 var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list.indexOf('b')) alert(list.indexOf('d'))
6、update方法
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null } DoublyLinkedList.prototype.update = function (position, newData) { //越界判断 if (position < 0 || position >= this.length) return false //定义变量 var curret = this.head var index = 0 while (index++ < position) { current = curret.next } //修改data current.data=newData return true //表示修改成功 } }
测试：
//测试 var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list.update(1,'d')) alert(list)
还有一种思路跟get方法一样，进行判断，是否需要从后往前进行查找修改
DoublyLinkedList.prototype.update = function (position, newData) { //越界判断 if (position < 0 || position >= this.length) return false if (this.length / 2 > position) { //定义变量 var curret = this.head var index = 0 while (index++ < position) { current = curret.next } //修改data current.data=newData return true //表示修改成功 } else { //定义变量 var curret = this.tail var index = this.length while (index-- < position) { current = curret.prev } //修改data current.data=newData return true //表示修改成功 } }
7、removeAt方法
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null } DoublyLinkedList.prototype.removeAt = function (position) { //越界判断 if (position < 0 || position >= this.length) return null var current = this.head //提到前面，便于获取删除的节点的data //第一种情况只有一个节点 if (this.length == 1) { this.head = null this.tail = null } else { //第二种情况，长度不为1，删除第一个节点 if (position == 0) { this.head.next.prev = null this.head = this.head.next } else if (position == this.length - 1) { current = this.tail //current指向尾部 //第三种情况，删除最后的节点 this.tail.prev.next = null this.tail = this.tail.prev } else { //第四种情况，在中间删除 var index = 0 while (index++ < position) { current = current.next } current.prev.next = current.next current.next.prev = current.prev } } //length减一 this.length -= 1 return current.data } }
测试：
//测试 var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list.removeAt(1)) alert(list)
8、remove方法
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null } DoublyLinkedList.prototype.indexOf = function (data) { var current = this.head var index = 0 while (current) { if (current.data == data) { return index } current = current.next index++ } return -1 } DoublyLinkedList.prototype.removeAt = function (position) { //越界判断 if (position < 0 || position >= this.length) return null var current = this.head //提到前面，便于获取删除的节点的data //第一种情况只有一个节点 if (this.length == 1) { this.head = null this.tail = null } else { //第二种情况，长度不为1，删除第一个节点 if (position == 0) { this.head.next.prev = null this.head = this.head.next } else if (position == this.length - 1) { current = this.tail //current指向尾部 //第三种情况，删除最后的节点 this.tail.prev.next = null this.tail = this.tail.prev } else { //第四种情况，在中间删除 var index = 0 while (index++ < position) { current = current.next } current.prev.next = current.next current.next.prev = current.prev } } //length减一 this.length -= 1 return current.data } DoublyLinkedList.prototype.remove = function (data) { //根据data获取索引 var index = this.indexOf(data) //根据index删除对应位置的节点 return this.removeAt(index) } }
测试：
//测试 var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list.remove('b')) alert(list)
9、isEmpty、size方法
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null } DoublyLinkedList.prototype.isEmpty = function () { return this.length == 0 } DoublyLinkedList.prototype.size = function () { return this.length } }
测试：
//测试 var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list.isEmpty()) alert(list.size())
10、获取链表的第一个元素、获取列表的最后一个元素
//封装双向链表 function DoublyLinkedList() { this.head = null this.tail = null this.length = 0 //内部类,节点类 function Node(data) { this.data = data this.prev = null this.next = null } DoublyLinkedList.prototype.getFirst = function () { return this.head.data } DoublyLinkedList.prototype.getLast = function () { return this.tail.data } }
测试：
var list = new DoublyLinkedList() list.append('a') list.append('b') list.append('c') alert(list.getFirst()) alert(list.getLast())
