链表 (双向)
@abp/utils包提供了称为双链表的实用数据结构. 简而言之双向链表是一系列记录(又称节点),这些记录具有上一个节点,下一个节点及其自身值(或数据)的信息.
入门
要创建一个双向链表,你需要做的就是导入和创建它的一个新的实例:
import { LinkedList } from '@abp/utils';
var list = new LinkedList();
MVC:
var list = new abp.utils.common.LinkedList();
构造函数没有任何参数.
用法
如何添加新节点
有几种方法可以在链表中创建新节点,这些方法都可以单独使用,也可以通过 add 和 addMany 方法.
addHead(value)
addHead(value: T): ListNode<T>
将给定值添加到链表的第一个节点:
list.addHead('a');
// "a"
list.addHead('b');
// "b" <-> "a"
list.addHead('c');
// "c" <-> "b" <-> "a"
addManyHead(values)
addManyHead(values: T[]): ListNode<T>[]
将给定的多个值添加到链表的第一个节点:
list.addManyHead(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
list.addManyHead(['x', 'y', 'z']);
// "x" <-> "y" <-> "z" <-> "a" <-> "b" <-> "c"
addTail(value)
addTail(value: T): ListNode<T>
将给定值添加到链表的最后一个节点:
list.addTail('a');
// "a"
list.addTail('b');
// "a" <-> "b"
list.addTail('c');
// "a" <-> "b" <-> "c"
addManyTail(values)
addManyTail(values: T[]): ListNode<T>[]
将给定多个值添加到链表的最后一个节点:
list.addManyTail(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
list.addManyTail(['x', 'y', 'z']);
// "a" <-> "b" <-> "c" <-> "x" <-> "y" <-> "z"
addAfter(value, previousValue [, compareFn])
addAfter(value: T, previousValue: T, compareFn?: ListComparisonFn<T>): ListNode<T>
添加给定值到previousValue节点后:
list.addTail('a');
list.addTail('b');
list.addTail('b');
list.addTail('c');
// "a" <-> "b" <-> "b" <-> "c"
list.addAfter('x', 'b');
// "a" <-> "b" <-> "x" <-> "b" <-> "c"
你可以自定义比较器:
list.addTail({ x: 1 });
list.addTail({ x: 2 });
list.addTail({ x: 3 });
// {"x":1} <-> {"x":2} <-> {"x":3}
list.addAfter(
{ x: 0 },
2,
(value, searchedValue) => value.x === searchedValue
);
// {"x":1} <-> {"x":2} <-> {"x":0} <-> {"x":3}
默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
addManyAfter(values, previousValue [, compareFn])
addManyAfter(values: T[], previousValue: T, compareFn?: ListComparisonFn<T>): ListNode<T>[]
添加给定的多个值到previousValue节点后:
list.addManyTail(['a', 'b', 'b', 'c']);
// "a" <-> "b" <-> "b" <-> "c"
list.addManyAfter(['x', 'y'], 'b');
// "a" <-> "b" <-> "x" <-> "y" <-> "b" <-> "c"
你可以自定义比较器:
list.addManyTail([{ x: 1 },{ x: 2 },{ x: 3 }]);
// {"x":1} <-> {"x":2} <-> {"x":3}
list.addManyAfter(
[{ x: 4 }, { x: 5 }],
2,
(value, searchedValue) => value.x === searchedValue
);
// {"x":1} <-> {"x":2} <-> {"x":4} <-> {"x":5} <-> {"x":3}
默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
addBefore(value, nextValue [, compareFn])
addBefore(value: T, nextValue: T, compareFn?: ListComparisonFn<T>): ListNode<T>
添加给值到previousValue节点前:
list.addTail('a');
list.addTail('b');
list.addTail('b');
list.addTail('c');
// "a" <-> "b" <-> "b" <-> "c"
list.addBefore('x', 'b');
// "a" <-> "x" <-> "b" <-> "b" <-> "c"
你可以自定义比较器:
list.addTail({ x: 1 });
list.addTail({ x: 2 });
list.addTail({ x: 3 });
// {"x":1} <-> {"x":2} <-> {"x":3}
list.addBefore(
{ x: 0 },
2,
(value, searchedValue) => value.x === searchedValue
);
// {"x":1} <-> {"x":0} <-> {"x":2} <-> {"x":3}
默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
addManyBefore(values, nextValue [, compareFn])
addManyBefore(values: T[], nextValue: T, compareFn?: ListComparisonFn<T>): ListNode<T>[]
添加给定的多个值到previousValue节点前:
list.addManyTail(['a', 'b', 'b', 'c']);
// "a" <-> "b" <-> "b" <-> "c"
list.addManyBefore(['x', 'y'], 'b');
// "a" <-> "x" <-> "y" <-> "b" <-> "b" <-> "c"
你可以自定义比较器
list.addManyTail([{ x: 1 },{ x: 2 },{ x: 3 }]);
// {"x":1} <-> {"x":2} <-> {"x":3}
list.addManyBefore(
[{ x: 4 }, { x: 5 }],
2,
(value, searchedValue) => value.x === searchedValue
);
// {"x":1} <-> {"x":4} <-> {"x":5} <-> {"x":2} <-> {"x":3}
默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
addByIndex(value, position)
addByIndex(value: T, position: number): ListNode<T>
在链表的指定位置添加节点:
list.addTail('a');
list.addTail('b');
list.addTail('c');
// "a" <-> "b" <-> "c"
list.addByIndex('x', 2);
// "a" <-> "b" <-> "x" <-> "c"
它也适用于负索引:
list.addTail('a');
list.addTail('b');
list.addTail('c');
// "a" <-> "b" <-> "c"
list.addByIndex('x', -1);
// "a" <-> "b" <-> "x" <-> "c"
addManyByIndex(values, position)
addManyByIndex(values: T[], position: number): ListNode<T>[]
添加多个节点到链表的指定位置:
list.addManyTail(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
list.addManyByIndex(['x', 'y'], 2);
// "a" <-> "b" <-> "x" <-> "y" <-> "c"
它也适用于负索引:
list.addManyTail(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
list.addManyByIndex(['x', 'y'], -1);
// "a" <-> "b" <-> "x" <-> "y" <-> "c"
add(value).head()
add(value: T).head(): ListNode<T>
将添加的节点移动到链表头:
list.add('a').head();
// "a"
list.add('b').head();
// "b" <-> "a"
list.add('c').head();
// "c" <-> "b" <-> "a"
它是
addHead的替代API.
add(value).tail()
add(value: T).tail(): ListNode<T>
将添加的节点移动到链表尾:
list.add('a').tail();
// "a"
list.add('b').tail();
// "a" <-> "b"
list.add('c').tail();
// "a" <-> "b" <-> "c"
它是
addTail的替代API.
add(value).after(previousValue [, compareFn])
add(value: T).after(previousValue: T, compareFn?: ListComparisonFn<T>): ListNode<T>
将添加的节点移动到指定节点后:
list.add('a').tail();
list.add('b').tail();
list.add('b').tail();
list.add('c').tail();
// "a" <-> "b" <-> "b" <-> "c"
list.add('x').after('b');
// "a" <-> "b" <-> "x" <-> "b" <-> "c"
你可以自定义比较器
list.add({ x: 1 }).tail();
list.add({ x: 2 }).tail();
list.add({ x: 3 }).tail();
// {"x":1} <-> {"x":2} <-> {"x":3}
list
.add({ x: 0 })
.after(2, (value, searchedValue) => value.x === searchedValue);
// {"x":1} <-> {"x":2} <-> {"x":0} <-> {"x":3}
它是
addAfter的替代API.默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
add(value).before(nextValue [, compareFn])
add(value: T).before(nextValue: T, compareFn?: ListComparisonFn<T>): ListNode<T>
将添加的节点移动到指定节点前:
list.add('a').tail();
list.add('b').tail();
list.add('b').tail();
list.add('c').tail();
// "a" <-> "b" <-> "b" <-> "c"
list.add('x').before('b');
// "a" <-> "x" <-> "b" <-> "b" <-> "c"
你可以自定义比较器
list.add({ x: 1 }).tail();
list.add({ x: 2 }).tail();
list.add({ x: 3 }).tail();
// {"x":1} <-> {"x":2} <-> {"x":3}
list
.add({ x: 0 })
.before(2, (value, searchedValue) => value.x === searchedValue);
// {"x":1} <-> {"x":0} <-> {"x":2} <-> {"x":3}
它是
addBefore的替代API.默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
add(value).byIndex(position)
add(value: T).byIndex(position: number): ListNode<T>
将添加的节点移动到链表指定位置:
list.add('a').tail();
list.add('b').tail();
list.add('c').tail();
// "a" <-> "b" <-> "c"
list.add('x').byIndex(2);
// "a" <-> "b" <-> "x" <-> "c"
它也适用于负索引:
list.add('a').tail();
list.add('b').tail();
list.add('c').tail();
// "a" <-> "b" <-> "c"
list.add('x').byIndex(-1);
// "a" <-> "b" <-> "x" <-> "c"
它是
addByIndex的替代API.
addMany(values).head()
addMany(values: T[]).head(): ListNode<T>[]
将添加的多个节点移动到链表头:
list.addMany(['a', 'b', 'c']).head();
// "a" <-> "b" <-> "c"
list.addMany(['x', 'y', 'z']).head();
// "x" <-> "y" <-> "z" <-> "a" <-> "b" <-> "c"
它是
addManyHead的替代API.
addMany(values).tail()
addMany(values: T[]).tail(): ListNode<T>[]
将添加的多个节点移动到链表尾:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.addMany(['x', 'y', 'z']).tail();
// "a" <-> "b" <-> "c" <-> "x" <-> "y" <-> "z"
它是
addManyTail的替代API.
addMany(values).after(previousValue [, compareFn])
addMany(values: T[]).after(previousValue: T, compareFn?: ListComparisonFn<T>): ListNode<T>[]
将添加的多个节点移动到指定节点后:
list.addMany(['a', 'b', 'b', 'c']).tail();
// "a" <-> "b" <-> "b" <-> "c"
list.addMany(['x', 'y']).after('b');
// "a" <-> "b" <-> "x" <-> "y" <-> "b" <-> "c"
你可以自定义比较器
list.addMany([{ x: 1 }, { x: 2 }, { x: 3 }]).tail();
// {"x":1} <-> {"x":2} <-> {"x":3}
list
.addMany([{ x: 4 }, { x: 5 }])
.after(2, (value, searchedValue) => value.x === searchedValue);
// {"x":1} <-> {"x":2} <-> {"x":4} <-> {"x":5} <-> {"x":3}
它是
addManyAfter的替代API.默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
addMany(values).before(nextValue [, compareFn])
addMany(values: T[]).before(nextValue: T, compareFn?: ListComparisonFn<T>): ListNode<T>[]
将添加的多个节点移动到指定节点前:
list.addMany(['a', 'b', 'b', 'c']).tail();
// "a" <-> "b" <-> "b" <-> "c"
list.addMany(['x', 'y']).before('b');
// "a" <-> "x" <-> "y" <-> "b" <-> "b" <-> "c"
你可以自定义比较器
list.addMany([{ x: 1 }, { x: 2 }, { x: 3 }]).tail();
// {"x":1} <-> {"x":2} <-> {"x":3}
list
.addMany([{ x: 4 }, { x: 5 }])
.before(2, (value, searchedValue) => value.x === searchedValue);
// {"x":1} <-> {"x":4} <-> {"x":5} <-> {"x":2} <-> {"x":3}
它是
addManyBefore的替代API.默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
addMany(values).byIndex(position)
addMany(values: T[]).byIndex(position: number): ListNode<T>[]
将添加的多个节点移动到链表的指定位置:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.addMany(['x', 'y']).byIndex(2);
// "a" <-> "b" <-> "x" <-> "y" <-> "c"
它也适用于负索引:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.addMany(['x', 'y']).byIndex(-1);
// "a" <-> "b" <-> "x" <-> "y" <-> "c"
它是
addManyByIndex的替代API.
如何删除节点
有几种方法可以在链表中删除节点,这些方法都可以单独使用,也可以通过 drop 方法.
dropHead()
dropHead(): ListNode<T> | undefined
删除链表的第一个节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.dropHead();
// "b" <-> "c"
dropManyHead(count)
dropManyHead(count: number): ListNode<T>[]
删除指定数量的链表的头节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.dropManyHead(2);
// "c"
dropTail()
dropTail(): ListNode<T> | undefined
删除链表的最后一个节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.dropTail();
// "a" <-> "b"
dropManyTail(count)
dropManyTail(count: number): ListNode<T>[]
删除指定数量的链表的尾节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.dropManyTail(2);
// "a"
dropByIndex(position)
dropByIndex(position: number): ListNode<T> | undefined
删除链表中给定位置的节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.dropByIndex(1);
// "a" <-> "c"
它也适用于负索引:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.dropByIndex(-2);
// "a" <-> "c"
dropManyByIndex(count, position)
dropManyByIndex(count: number, position: number): ListNode<T>[]
删除链表中给定位置与数量的多个节点:
list.addMany(['a', 'b', 'c', 'd']).tail();
// "a" <-> "b" <-> "c" <-> "d
list.dropManyByIndex(2, 1);
// "a" <-> "d"
它也适用于负索引:
list.addMany(['a', 'b', 'c', 'd']).tail();
// "a" <-> "b" <-> "c" <-> "d
list.dropManyByIndex(2, -2);
// "a" <-> "d"
dropByValue(value [, compareFn])
dropByValue(value: T, compareFn?: ListComparisonFn<T>): ListNode<T> | undefined
删除链表中含有给定值的第一个节点:
list.addMany(['a', 'x', 'b', 'x', 'c']).tail();
// "a" <-> "x" <-> "b" <-> "x" <-> "c"
list.dropByValue('x');
// "a" <-> "b" <-> "x" <-> "c"
你可以自定义比较器
list.addMany([{ x: 1 }, { x: 0 }, { x: 2 }, { x: 0 }, { x: 3 }]).tail();
// {"x":1} <-> {"x":0} <-> {"x":2} <-> {"x":0} <-> {"x":3}
list.dropByValue(0, (value, searchedValue) => value.x === searchedValue);
// {"x":1} <-> {"x":2} <-> {"x":0} <-> {"x":3}
默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
dropByValueAll(value [, compareFn])
dropByValueAll(value: T, compareFn?: ListComparisonFn<T>): ListNode<T>[]
删除链表中含有给定值的所有节点:
list.addMany(['a', 'x', 'b', 'x', 'c']).tail();
// "a" <-> "x" <-> "b" <-> "x" <-> "c"
list.dropByValueAll('x');
// "a" <-> "b" <-> "c"
你可以自定义比较器
list.addMany([{ x: 1 }, { x: 0 }, { x: 2 }, { x: 0 }, { x: 3 }]).tail();
// {"x":1} <-> {"x":0} <-> {"x":2} <-> {"x":0} <-> {"x":3}
list.dropByValueAll(0, (value, searchedValue) => value.x === searchedValue);
// {"x":1} <-> {"x":2} <-> {"x":3}
默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
drop().head()
drop().head(): ListNode<T> | undefined
删除链表的头节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.drop().head();
// "b" <-> "c"
它是
dropHead的替代API.
drop().tail()
drop().tail(): ListNode<T> | undefined
删除链表的尾节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.drop().tail();
// "a" <-> "b"
它是
dropTail的替代API.
drop().byIndex(position)
drop().byIndex(position: number): ListNode<T> | undefined
删除链表指定位置的节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.drop().byIndex(1);
// "a" <-> "c"
它也适用于负索引:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.drop().byIndex(-2);
// "a" <-> "c"
它是
dropByIndex的替代API.
drop().byValue(value [, compareFn])
drop().byValue(value: T, compareFn?: ListComparisonFn<T>): ListNode<T> | undefined
删除链表中含有给定值的第一个节点:
list.addMany(['a', 'x', 'b', 'x', 'c']).tail();
// "a" <-> "x" <-> "b" <-> "x" <-> "c"
list.drop().byValue('x');
// "a" <-> "b" <-> "x" <-> "c"
你可以自定义比较器
list.addMany([{ x: 1 }, { x: 0 }, { x: 2 }, { x: 0 }, { x: 3 }]).tail();
// {"x":1} <-> {"x":0} <-> {"x":2} <-> {"x":0} <-> {"x":3}
list
.drop()
.byValue(0, (value, searchedValue) => value.x === searchedValue);
// {"x":1} <-> {"x":2} <-> {"x":0} <-> {"x":3}
它是
dropByValue的替代API.默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
drop().byValueAll(value [, compareFn])
drop().byValueAll(value: T, compareFn?: ListComparisonFn<T>): ListNode<T>[]
删除链表中含有给定值的所有节点:
list.addMany(['a', 'x', 'b', 'x', 'c']).tail();
// "a" <-> "x" <-> "b" <-> "x" <-> "c"
list.drop().byValueAll('x');
// "a" <-> "b" <-> "c"
你可以自定义比较器
list.addMany([{ x: 1 }, { x: 0 }, { x: 2 }, { x: 0 }, { x: 3 }]).tail();
// {"x":1} <-> {"x":0} <-> {"x":2} <-> {"x":0} <-> {"x":3}
list
.drop()
.byValueAll(0, (value, searchedValue) => value.x === searchedValue);
// {"x":1} <-> {"x":2} <-> {"x":3}
它是
dropByValueAll的替代API.默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
dropMany(count).head()
dropMany(count: number).head(): ListNode<T>[]
删除链表中指定数量的头节点:
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.dropMany(2).head();
// "c"
它是
dropManyHead的替代API.
dropMany(count).tail()
dropMany(count: number).tail(): ListNode<T>[]
删除链表中指定数量的尾节点::
list.addMany(['a', 'b', 'c']).tail();
// "a" <-> "b" <-> "c"
list.dropMany(2).tail();
// "a"
它是
dropManyTail的替代API.
dropMany(count).byIndex(position)
dropMany(count: number).byIndex(position: number): ListNode<T>[]
删除链表中指定位置和数量的节点:
list.addMany(['a', 'b', 'c', 'd']).tail();
// "a" <-> "b" <-> "c" <-> "d
list.dropMany(2).byIndex(1);
// "a" <-> "d"
它也适用于负索引:
list.addMany(['a', 'b', 'c', 'd']).tail();
// "a" <-> "b" <-> "c" <-> "d
list.dropMany(2).byIndex(-2);
// "a" <-> "d"
它是
dropManyByIndex的替代API.
如何查找节点
有几个方法找到链表特定节点.
head
head: ListNode<T> | undefined;
链表中的第一个节点.
tail
tail: ListNode<T> | undefined;
链表中的最后一个节点.
length
length: number;
链表的节点总数.
find(predicate)
find(predicate: ListIteratorFunction<T>): ListNode<T> | undefined
从链表中找到与给定谓词匹配的第一个节点:
list.addManyTail(['a', 'b', 'b', 'c']);
// "a" <-> "b" <-> "b" <-> "c"
var found = list.find(node => node.value === 'b');
/*
found.value === "b"
found.previous.value === "a"
found.next.value === "b"
*/
findIndex(predicate)
findIndex(predicate: ListIteratorFunction<T>): number
从链表中找到与给定谓词匹配的第一个节点的位置:
list.addManyTail(['a', 'b', 'b', 'c']);
// "a" <-> "b" <-> "b" <-> "c"
var i0 = list.findIndex(node => node.next && node.next.value === 'b');
var i1 = list.findIndex(node => node.value === 'b');
var i2 = list.findIndex(node => node.previous && node.previous.value === 'b');
var i3 = list.findIndex(node => node.value === 'x');
/*
i0 === 0
i1 === 1
i2 === 2
i3 === -1
*/
get(position)
get(position: number): ListNode<T> | undefined
查找并返回链表中特定位置的节点:
list.addManyTail(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
var found = list.get(1);
/*
found.value === "b"
found.previous.value === "a"
found.next.value === "c"
*/
indexOf(value [, compareFn])
indexOf(value: T, compareFn?: ListComparisonFn<T>): number
在链表中找到匹配给定值的第一个节点位置:
list.addManyTail(['a', 'b', 'b', 'c']);
// "a" <-> "b" <-> "b" <-> "c"
var i0 = list.indexOf('a');
var i1 = list.indexOf('b');
var i2 = list.indexOf('c');
var i3 = list.indexOf('x');
/*
i0 === 0
i1 === 1
i2 === 3
i3 === -1
*/
你可以自定义比较器
list.addManyTail([{ x: 1 }, { x: 0 }, { x: 2 }, { x: 0 }, { x: 3 }]);
// {"x":1} <-> {"x":0} <-> {"x":2} <-> {"x":0} <-> {"x":3}
var i0 = indexOf(1, (value, searchedValue) => value.x === searchedValue);
var i1 = indexOf(2, (value, searchedValue) => value.x === searchedValue);
var i2 = indexOf(3, (value, searchedValue) => value.x === searchedValue);
var i3 = indexOf(0, (value, searchedValue) => value.x === searchedValue);
var i4 = indexOf(4, (value, searchedValue) => value.x === searchedValue);
/*
i0 === 0
i1 === 2
i2 === 4
i3 === 1
i4 === -1
*/
默认的比较函数检查深度相等性,因此你几乎不需要传递该参数.
如何检查所有节点
有几种方法来遍历或显示一个链表.
forEach(iteratorFn)
forEach(iteratorFn: ListIteratorFn<T>): void
从头到尾在链表中的所有节点上运行回调函数:
list.addManyTail(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
list.forEach((node, index) => console.log(node.value + index));
// 'a0'
// 'b1'
// 'c2'
*[Symbol.iterator]()
链表是可迭代的. 换句话说你可以使用诸如for ... of之类的方法.
list.addManyTail(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
for(var node of list) { /* ES6 for...of statement */
console.log(node.value);
}
// 'a'
// 'b'
// 'c'
toArray()
toArray(): T[]
转换链表值为数组:
list.addManyTail(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
var arr = list.toArray();
/*
arr === ['a', 'b', 'c']
*/
toNodeArray()
toNodeArray(): T[]
转换链表节点为数组:
list.addManyTail(['a', 'b', 'c']);
// "a" <-> "b" <-> "c"
var arr = list.toNodeArray();
/*
arr[0].value === 'a'
arr[1].value === 'a'
arr[2].value === 'a'
*/
toString(mapperFn)
toString(mapperFn: ListMapperFn<T> = JSON.stringify): string
将链表转换为节点及其关系的字符串表示形式:
list.addManyTail(['a', 2, 'c', { k: 4, v: 'd' }]);
// "a" <-> 2 <-> "c" <-> {"k":4,"v":"d"}
var str = list.toString();
/*
str === '"a" <-> 2 <-> "c" <-> {"k":4,"v":"d"}'
*/
你可以在对值进行字符串化之前通过自定义映射器函数来映射值:
list.addMany([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }, { x: 5 }]).tail();
// {"x":1} <-> {"x":2} <-> {"x":3} <-> {"x":4} <-> {"x":5}
var str = list.toString(value => value.x);
/*
str === '1 <-> 2 <-> 3 <-> 4 <-> 5'
*/
API
Classes
LinkedList
export class LinkedList<T = any> {
// properties and methods are explained above
}
ListNode
export class ListNode<T = any> {
next: ListNode | undefined;
previous: ListNode | undefined;
constructor(public readonly value: T) {}
}
ListNode 是存储在 LinkedList 中的每个记录的节点.
valuevalue是存储在节点中的值,通过构造函数传递.next引用列表中的下一个节点.previous引用列表中的上一个节点.
list.addManyTail([ 0, 1, 2 ]);
console.log(
list.head.value, // 0
list.head.next.value, // 1
list.head.next.next.value, // 2
list.head.next.next.previous.value, // 1
list.head.next.next.previous.previous.value, // 0
list.tail.value, // 2
list.tail.previous.value, // 1
list.tail.previous.previous.value, // 0
list.tail.previous.previous.next.value, // 1
list.tail.previous.previous.next.next.value, // 2
);
Types
ListMapperFn
type ListMapperFn<T = any> = (value: T) => any;
该函数在 toString 方法中用于在生成列表的字符串形式之前映射节点值.
ListComparisonFn
type ListComparisonFn<T = any> = (nodeValue: T, comparedValue: any) => boolean;
该函数用于根据比较值添加,删除和查找节点.
ListIteratorFn
type ListIteratorFn<T = any, R = boolean> = (
node: ListNode<T>,
index?: number,
list?: LinkedList,
) => R;
该函数在遍历列表时使用,可以对每个节点执行某些操作,也可以查找某个节点.
08-09 五月
