Skip to content

Commit 6b354ad

Browse files
huzaimatrekhleb
huzaima
authored and
trekhleb
committedJul 5, 2018
Added doubly linked list (trekhleb#92)
* Added doubly linked list * improved doubly linked list coverage
1 parent fef2aa7 commit 6b354ad

File tree

5 files changed

+510
-0
lines changed

5 files changed

+510
-0
lines changed
 

‎src/data-structures/doubly-linked-list/DoublyLinkedList.js

+211
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,211 @@
1+
import DoublyLinkedListNode from './DoublyLinkedListNode';
2+
import Comparator from './../../utils/comparator/Comparator';
3+
4+
export default class DoublyLinkedList {
5+
/**
6+
* @param {Function} [comparatorFunction]
7+
*/
8+
constructor(comparatorFunction) {
9+
/** @var DoublyLinkedListNode */
10+
this.head = null;
11+
12+
/** @var DoublyLinkedListNode */
13+
this.tail = null;
14+
15+
this.compare = new Comparator(comparatorFunction);
16+
}
17+
18+
/**
19+
* @param {*} value
20+
* @return {DoublyLinkedList}
21+
*/
22+
prepend(value) {
23+
// Make new node to be a head.
24+
const newNode = new DoublyLinkedListNode(value, this.head);
25+
26+
// If there is head, then it won't be head anymore
27+
// Therefore, make its previous reference to be new node (new head)
28+
// Then mark the new node as head
29+
if (this.head) {
30+
this.head.previous = newNode;
31+
}
32+
this.head = newNode;
33+
34+
// If there is no tail yet let's make new node a tail.
35+
if (!this.tail) {
36+
this.tail = newNode;
37+
}
38+
39+
return this;
40+
}
41+
42+
/**
43+
* @param {*} value
44+
* @return {DoublyLinkedList}
45+
*/
46+
append(value) {
47+
const newNode = new DoublyLinkedListNode(value);
48+
49+
// If there is no head yet let's make new node a head.
50+
if (!this.head) {
51+
this.head = newNode;
52+
this.tail = newNode;
53+
54+
return this;
55+
}
56+
57+
// Attach new node to the end of linked list.
58+
this.tail.next = newNode;
59+
60+
// Attach current tail to the new node's previous reference
61+
newNode.previous = this.tail;
62+
63+
// Set new node to be the tail of linked list.
64+
this.tail = newNode;
65+
66+
return this;
67+
}
68+
69+
/**
70+
* @param {*} value
71+
* @return {DoublyLinkedListNode}
72+
*/
73+
delete(value) {
74+
if (!this.head) {
75+
return null;
76+
}
77+
78+
let deletedNode = null;
79+
let currentNode = this.head;
80+
81+
do {
82+
if (this.compare.equal(currentNode.value, value)) {
83+
deletedNode = currentNode;
84+
85+
if (deletedNode === this.head) {
86+
// set head to second node, which will become new head
87+
this.head = deletedNode.next;
88+
89+
// set new head's previous to null
90+
if (this.head) {
91+
this.head.previous = null;
92+
}
93+
94+
// If all the nodes in list has same value that is passed as argument
95+
// then all nodes will get deleted, therefore tail needs to be updated
96+
if (deletedNode === this.tail) {
97+
this.tail = null;
98+
}
99+
} else if (deletedNode === this.tail) {
100+
// set tail to second last node, which will become new tail
101+
this.tail = deletedNode.previous;
102+
this.tail.next = null;
103+
} else {
104+
const previousNode = deletedNode.previous;
105+
const nextNode = deletedNode.next;
106+
previousNode.next = nextNode;
107+
nextNode.previous = previousNode;
108+
}
109+
}
110+
111+
currentNode = currentNode.next;
112+
} while (currentNode);
113+
114+
return deletedNode;
115+
}
116+
117+
/**
118+
* @param {Object} findParams
119+
* @param {*} findParams.value
120+
* @param {function} [findParams.callback]
121+
* @return {DoublyLinkedListNode}
122+
*/
123+
find({ value = undefined, callback = undefined }) {
124+
if (!this.head) {
125+
return null;
126+
}
127+
128+
let currentNode = this.head;
129+
130+
while (currentNode) {
131+
// If callback is specified then try to find node by callback.
132+
if (callback && callback(currentNode.value)) {
133+
return currentNode;
134+
}
135+
136+
// If value is specified then try to compare by value..
137+
if (value !== undefined && this.compare.equal(currentNode.value, value)) {
138+
return currentNode;
139+
}
140+
141+
currentNode = currentNode.next;
142+
}
143+
144+
return null;
145+
}
146+
147+
/**
148+
* @return {DoublyLinkedListNode}
149+
*/
150+
deleteTail() {
151+
if (!this.tail) {
152+
return null;
153+
} else if (this.head === this.tail) {
154+
const deletedTail = this.tail;
155+
this.head = null;
156+
this.tail = null;
157+
158+
return deletedTail;
159+
}
160+
161+
const deletedTail = this.tail;
162+
this.tail = this.tail.previous;
163+
this.tail.next = null;
164+
165+
return deletedTail;
166+
}
167+
168+
/**
169+
* @return {DoublyLinkedListNode}
170+
*/
171+
deleteHead() {
172+
if (!this.head) {
173+
return null;
174+
}
175+
176+
const deletedHead = this.head;
177+
178+
if (this.head.next) {
179+
this.head = this.head.next;
180+
this.head.previous = null;
181+
} else {
182+
this.head = null;
183+
this.tail = null;
184+
}
185+
186+
return deletedHead;
187+
}
188+
189+
/**
190+
* @return {DoublyLinkedListNode[]}
191+
*/
192+
toArray() {
193+
const nodes = [];
194+
195+
let currentNode = this.head;
196+
while (currentNode) {
197+
nodes.push(currentNode);
198+
currentNode = currentNode.next;
199+
}
200+
201+
return nodes;
202+
}
203+
204+
/**
205+
* @param {function} [callback]
206+
* @return {string}
207+
*/
208+
toString(callback) {
209+
return this.toArray().map(node => node.toString(callback)).toString();
210+
}
211+
}

‎src/data-structures/doubly-linked-list/DoublyLinkedListNode.js

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
export default class DoublyLinkedListNode {
2+
constructor(value, next = null, previous = null) {
3+
this.value = value;
4+
this.next = next;
5+
this.previous = previous;
6+
}
7+
8+
toString(callback) {
9+
return callback ? callback(this.value) : `${this.value}`;
10+
}
11+
}

‎src/data-structures/doubly-linked-list/README.md

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
# Doubly Linked List
2+
3+
In computer science, a doubly linked list is a linked data structure that consists of a set of sequentially linked records called nodes. Each node contains two fields, called links, that are references to the previous and to the next node in the sequence of nodes. The beginning and ending nodes' previous and next links, respectively, point to some kind of terminator, typically a sentinel node or null, to facilitate traversal of the list. If there is only one sentinel node, then the list is circularly linked via the sentinel node. It can be conceptualized as two singly linked lists formed from the same data items, but in opposite sequential orders.
4+
5+
![Doubly Linked List](https://upload.wikimedia.org/wikipedia/commons/5/5e/Doubly-linked-list.svg)
6+
7+
## References
8+
9+
- [Wikipedia](https://en.wikipedia.org/wiki/Doubly_linked_list)
10+
- [YouTube](https://www.youtube.com/watch?v=JdQeNxWCguQ)

‎src/data-structures/doubly-linked-list/__test__/DoublyLinkedList.test.js

+224
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,224 @@
1+
import DoublyLinkedList from '../DoublyLinkedList';
2+
3+
describe('DoublyLinkedList', () => {
4+
it('should create empty linked list', () => {
5+
const linkedList = new DoublyLinkedList();
6+
expect(linkedList.toString()).toBe('');
7+
});
8+
9+
it('should append node to linked list', () => {
10+
const linkedList = new DoublyLinkedList();
11+
12+
expect(linkedList.head).toBeNull();
13+
expect(linkedList.tail).toBeNull();
14+
15+
linkedList.append(1);
16+
linkedList.append(2);
17+
18+
expect(linkedList.head.next.value).toBe(2);
19+
expect(linkedList.tail.previous.value).toBe(1);
20+
expect(linkedList.toString()).toBe('1,2');
21+
});
22+
23+
it('should prepend node to linked list', () => {
24+
const linkedList = new DoublyLinkedList();
25+
26+
linkedList.prepend(2);
27+
expect(linkedList.head.toString()).toBe('2');
28+
expect(linkedList.tail.toString()).toBe('2');
29+
30+
linkedList.append(1);
31+
linkedList.prepend(3);
32+
33+
expect(linkedList.head.next.next.previous).toBe(linkedList.head.next);
34+
expect(linkedList.tail.previous.next).toBe(linkedList.tail);
35+
expect(linkedList.tail.previous.value).toBe(2);
36+
expect(linkedList.toString()).toBe('3,2,1');
37+
});
38+
39+
it('should delete node by value from linked list', () => {
40+
const linkedList = new DoublyLinkedList();
41+
42+
expect(linkedList.delete(5)).toBeNull();
43+
44+
linkedList.append(1);
45+
linkedList.append(1);
46+
linkedList.append(2);
47+
linkedList.append(3);
48+
linkedList.append(3);
49+
linkedList.append(3);
50+
linkedList.append(4);
51+
linkedList.append(5);
52+
53+
expect(linkedList.head.toString()).toBe('1');
54+
expect(linkedList.tail.toString()).toBe('5');
55+
56+
const deletedNode = linkedList.delete(3);
57+
expect(deletedNode.value).toBe(3);
58+
expect(linkedList.tail.previous.previous.value).toBe(2);
59+
expect(linkedList.toString()).toBe('1,1,2,4,5');
60+
61+
linkedList.delete(3);
62+
expect(linkedList.toString()).toBe('1,1,2,4,5');
63+
64+
linkedList.delete(1);
65+
expect(linkedList.toString()).toBe('2,4,5');
66+
67+
expect(linkedList.head.toString()).toBe('2');
68+
expect(linkedList.head.next.next).toBe(linkedList.tail);
69+
expect(linkedList.tail.previous.previous).toBe(linkedList.head);
70+
expect(linkedList.tail.toString()).toBe('5');
71+
72+
linkedList.delete(5);
73+
expect(linkedList.toString()).toBe('2,4');
74+
75+
expect(linkedList.head.toString()).toBe('2');
76+
expect(linkedList.tail.toString()).toBe('4');
77+
78+
linkedList.delete(4);
79+
expect(linkedList.toString()).toBe('2');
80+
81+
expect(linkedList.head.toString()).toBe('2');
82+
expect(linkedList.tail.toString()).toBe('2');
83+
expect(linkedList.head).toBe(linkedList.tail);
84+
85+
linkedList.delete(2);
86+
expect(linkedList.toString()).toBe('');
87+
});
88+
89+
it('should delete linked list tail', () => {
90+
const linkedList = new DoublyLinkedList();
91+
92+
expect(linkedList.deleteTail()).toBeNull();
93+
94+
linkedList.append(1);
95+
linkedList.append(2);
96+
linkedList.append(3);
97+
98+
expect(linkedList.head.toString()).toBe('1');
99+
expect(linkedList.tail.toString()).toBe('3');
100+
101+
const deletedNode1 = linkedList.deleteTail();
102+
103+
expect(deletedNode1.value).toBe(3);
104+
expect(linkedList.toString()).toBe('1,2');
105+
expect(linkedList.head.toString()).toBe('1');
106+
expect(linkedList.tail.toString()).toBe('2');
107+
108+
const deletedNode2 = linkedList.deleteTail();
109+
110+
expect(deletedNode2.value).toBe(2);
111+
expect(linkedList.toString()).toBe('1');
112+
expect(linkedList.head.toString()).toBe('1');
113+
expect(linkedList.tail.toString()).toBe('1');
114+
115+
const deletedNode3 = linkedList.deleteTail();
116+
117+
expect(deletedNode3.value).toBe(1);
118+
expect(linkedList.toString()).toBe('');
119+
expect(linkedList.head).toBeNull();
120+
expect(linkedList.tail).toBeNull();
121+
});
122+
123+
it('should delete linked list head', () => {
124+
const linkedList = new DoublyLinkedList();
125+
126+
expect(linkedList.deleteHead()).toBeNull();
127+
128+
linkedList.append(1);
129+
linkedList.append(2);
130+
131+
expect(linkedList.head.toString()).toBe('1');
132+
expect(linkedList.tail.toString()).toBe('2');
133+
134+
const deletedNode1 = linkedList.deleteHead();
135+
136+
expect(deletedNode1.value).toBe(1);
137+
expect(linkedList.head.previous).toBeNull();
138+
expect(linkedList.toString()).toBe('2');
139+
expect(linkedList.head.toString()).toBe('2');
140+
expect(linkedList.tail.toString()).toBe('2');
141+
142+
const deletedNode2 = linkedList.deleteHead();
143+
144+
expect(deletedNode2.value).toBe(2);
145+
expect(linkedList.toString()).toBe('');
146+
expect(linkedList.head).toBeNull();
147+
expect(linkedList.tail).toBeNull();
148+
});
149+
150+
it('should be possible to store objects in the list and to print them out', () => {
151+
const linkedList = new DoublyLinkedList();
152+
153+
const nodeValue1 = { value: 1, key: 'key1' };
154+
const nodeValue2 = { value: 2, key: 'key2' };
155+
156+
linkedList
157+
.append(nodeValue1)
158+
.prepend(nodeValue2);
159+
160+
const nodeStringifier = value => `${value.key}:${value.value}`;
161+
162+
expect(linkedList.toString(nodeStringifier)).toBe('key2:2,key1:1');
163+
});
164+
165+
it('should find node by value', () => {
166+
const linkedList = new DoublyLinkedList();
167+
168+
expect(linkedList.find({ value: 5 })).toBeNull();
169+
170+
linkedList.append(1);
171+
expect(linkedList.find({ value: 1 })).toBeDefined();
172+
173+
linkedList
174+
.append(2)
175+
.append(3);
176+
177+
const node = linkedList.find({ value: 2 });
178+
179+
expect(node.value).toBe(2);
180+
expect(linkedList.find({ value: 5 })).toBeNull();
181+
});
182+
183+
it('should find node by callback', () => {
184+
const linkedList = new DoublyLinkedList();
185+
186+
linkedList
187+
.append({ value: 1, key: 'test1' })
188+
.append({ value: 2, key: 'test2' })
189+
.append({ value: 3, key: 'test3' });
190+
191+
const node = linkedList.find({ callback: value => value.key === 'test2' });
192+
193+
expect(node).toBeDefined();
194+
expect(node.value.value).toBe(2);
195+
expect(node.value.key).toBe('test2');
196+
expect(linkedList.find({ callback: value => value.key === 'test5' })).toBeNull();
197+
});
198+
199+
it('should find node by means of custom compare function', () => {
200+
const comparatorFunction = (a, b) => {
201+
if (a.customValue === b.customValue) {
202+
return 0;
203+
}
204+
205+
return a.customValue < b.customValue ? -1 : 1;
206+
};
207+
208+
const linkedList = new DoublyLinkedList(comparatorFunction);
209+
210+
linkedList
211+
.append({ value: 1, customValue: 'test1' })
212+
.append({ value: 2, customValue: 'test2' })
213+
.append({ value: 3, customValue: 'test3' });
214+
215+
const node = linkedList.find({
216+
value: { value: 2, customValue: 'test2' },
217+
});
218+
219+
expect(node).toBeDefined();
220+
expect(node.value.value).toBe(2);
221+
expect(node.value.customValue).toBe('test2');
222+
expect(linkedList.find({ value: 2, customValue: 'test5' })).toBeNull();
223+
});
224+
});

‎src/data-structures/doubly-linked-list/__test__/DoublyLinkedListNode.test.js

+54
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
import DoublyLinkedListNode from './../DoublyLinkedListNode';
2+
3+
describe('DoublyLinkedListNode', () => {
4+
it('should create list node with value', () => {
5+
const node = new DoublyLinkedListNode(1);
6+
7+
expect(node.value).toBe(1);
8+
expect(node.next).toBeNull();
9+
});
10+
11+
it('should create list node with object as a value', () => {
12+
const nodeValue = { value: 1, key: 'test' };
13+
const node = new DoublyLinkedListNode(nodeValue);
14+
15+
expect(node.value.value).toBe(1);
16+
expect(node.value.key).toBe('test');
17+
expect(node.next).toBeNull();
18+
expect(node.previous).toBeNull();
19+
});
20+
21+
it('should link nodes together', () => {
22+
const node2 = new DoublyLinkedListNode(2);
23+
const node1 = new DoublyLinkedListNode(1, node2);
24+
const node3 = new DoublyLinkedListNode(10, node1, node2);
25+
26+
expect(node1.next).toBeDefined();
27+
expect(node1.previous).toBeNull();
28+
expect(node2.next).toBeNull();
29+
expect(node2.previous).toBeNull();
30+
expect(node3.next).toBeDefined();
31+
expect(node3.previous).toBeDefined();
32+
expect(node1.value).toBe(1);
33+
expect(node1.next.value).toBe(2);
34+
expect(node3.next.value).toBe(1);
35+
expect(node3.previous.value).toBe(2);
36+
});
37+
38+
it('should convert node to string', () => {
39+
const node = new DoublyLinkedListNode(1);
40+
41+
expect(node.toString()).toBe('1');
42+
43+
node.value = 'string value';
44+
expect(node.toString()).toBe('string value');
45+
});
46+
47+
it('should convert node to string with custom stringifier', () => {
48+
const nodeValue = { value: 1, key: 'test' };
49+
const node = new DoublyLinkedListNode(nodeValue);
50+
const toStringCallback = value => `value: ${value.value}, key: ${value.key}`;
51+
52+
expect(node.toString(toStringCallback)).toBe('value: 1, key: test');
53+
});
54+
});

0 commit comments

Comments
 (0)
Please sign in to comment.